Ops.capi.cpp.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op C API Definitions                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Ops.td                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
 
#include <limits>
 
using namespace mlir;
using namespace llvm;
 
MlirOperation llzkBool_AndBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.and"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_AndBoolOp(MlirOperation inp) {
  return llvm::isa<AndBoolOp>(unwrap(inp));
}
 
MlirValue llzkBool_AndBoolOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_AndBoolOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_AndBoolOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_AndBoolOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_AndBoolOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkBool_AssertOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition, MlirIdentifier msg) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.assert"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(msg))) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("msg")), reinterpret_cast<MlirAttribute&>(msg)));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_AssertOp(MlirOperation inp) {
  return llvm::isa<AssertOp>(unwrap(inp));
}
 
MlirValue llzkBool_AssertOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<AssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_AssertOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<AssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirAttribute llzkBool_AssertOpGetMsg(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("msg"));
}
 
void llzkBool_AssertOpSetMsg(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("msg"), attr);
}
 
MlirOperation llzkBool_CmpOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs, MlirAttribute predicate) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.cmp"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(predicate)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("predicate")), predicate));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_CmpOp(MlirOperation inp) {
  return llvm::isa<CmpOp>(unwrap(inp));
}
 
MlirValue llzkBool_CmpOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_CmpOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_CmpOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_CmpOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirAttribute llzkBool_CmpOpGetPredicate(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("predicate"));
}
 
void llzkBool_CmpOpSetPredicate(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("predicate"), attr);
}
 
MlirValue llzkBool_CmpOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkBool_NotBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue operand) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.not"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &operand);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_NotBoolOp(MlirOperation inp) {
  return llvm::isa<NotBoolOp>(unwrap(inp));
}
 
MlirValue llzkBool_NotBoolOpGetOperand(MlirOperation op) {
  auto range = llvm::cast<NotBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_NotBoolOpSetOperand(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<NotBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_NotBoolOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkBool_OrBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.or"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_OrBoolOp(MlirOperation inp) {
  return llvm::isa<OrBoolOp>(unwrap(inp));
}
 
MlirValue llzkBool_OrBoolOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_OrBoolOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_OrBoolOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_OrBoolOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_OrBoolOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkBool_XorBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.xor"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Bool_XorBoolOp(MlirOperation inp) {
  return llvm::isa<XorBoolOp>(unwrap(inp));
}
 
MlirValue llzkBool_XorBoolOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_XorBoolOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_XorBoolOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkBool_XorBoolOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkBool_XorBoolOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}