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;
 
bool llzkOperationIsA_Function_CallOp(MlirOperation inp) {
  return llvm::isa<CallOp>(unwrap(inp));
}
 
intptr_t llzkFunction_CallOpGetArgOperandsCount(MlirOperation op) {
  auto range = llvm::cast<CallOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  return range.second;
}
 
MlirValue llzkFunction_CallOpGetArgOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<CallOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(index >= 0 && index < range.second && "variadic operand index out of range");
  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) + index);
}
 
void llzkFunction_CallOpSetArgOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  if (count < 0)
    return;
  ::llvm::SmallVector<::mlir::Value> vals;
  vals.reserve(static_cast<size_t>(count));
  for (intptr_t i = 0; i < count; ++i)
    vals.push_back(unwrap(values[i]));
  ::llvm::cast<CallOp>(unwrap(op)).getArgOperandsMutable().assign(vals);
}
 
intptr_t llzkFunction_CallOpGetMapOperandsCount(MlirOperation op) {
  auto range = llvm::cast<CallOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkFunction_CallOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<CallOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(index >= 0 && index < range.second && "variadic operand index out of range");
  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) + index);
}
 
void llzkFunction_CallOpSetMapOperands(MlirOperation op, intptr_t groupCount, MlirValueRange const *groups) {
  if (groupCount < 0)
    return;
 
  ::llvm::SmallVector<::mlir::Value> vals;
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(groups[g].size >= 0 && "group size must be non-negative");
    for (intptr_t i = 0; i < groups[g].size; ++i) {
      vals.push_back(unwrap(groups[g].values[i]));
    }
  }
  ::llvm::cast<CallOp>(unwrap(op)).getMapOperandsMutable().join().assign(vals);
 
  ::llvm::SmallVector<int32_t> newGroupSizes;
  newGroupSizes.reserve(static_cast<size_t>(groupCount));
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(
        groups[g].size <= static_cast<intptr_t>(std::numeric_limits<int32_t>::max()) &&
        "group size exceeds int32_t range"
    );
    newGroupSizes.push_back(static_cast<int32_t>(groups[g].size));
  }
  MlirContext ctx = mlirOperationGetContext(op);
  assert(
      newGroupSizes.size() <= static_cast<size_t>(std::numeric_limits<intptr_t>::max()) &&
      "group count exceeds intptr_t range"
  );
  mlirOperationSetAttributeByName(
      op, mlirStringRefCreateFromCString("mapOpGroupSizes"),
      mlirDenseI32ArrayGet(ctx, static_cast<intptr_t>(newGroupSizes.size()), newGroupSizes.data())
  );
}
 
MlirAttribute llzkFunction_CallOpGetCallee(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("callee"));
}
 
void llzkFunction_CallOpSetCallee(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("callee"), attr);
}
 
MlirAttribute llzkFunction_CallOpGetTemplateParams(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("templateParams"));
}
 
void llzkFunction_CallOpSetTemplateParams(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("templateParams"), attr);
}
 
MlirAttribute llzkFunction_CallOpGetNumDimsPerMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"));
}
 
void llzkFunction_CallOpSetNumDimsPerMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"), attr);
}
 
MlirAttribute llzkFunction_CallOpGetMapOpGroupSizes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"));
}
 
void llzkFunction_CallOpSetMapOpGroupSizes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"), attr);
}
 
MlirAttribute llzkFunction_CallOpGetArgAttrs(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"));
}
 
void llzkFunction_CallOpSetArgAttrs(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"), attr);
}
 
MlirAttribute llzkFunction_CallOpGetResAttrs(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("res_attrs"));
}
 
void llzkFunction_CallOpSetResAttrs(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("res_attrs"), attr);
}
 
intptr_t llzkFunction_CallOpGetResult0Count(MlirOperation op) {
  intptr_t count = mlirOperationGetNumResults(op);
  assert(count >= 0 && "result count less than start index");
  return count - 0;
}
 
MlirValue llzkFunction_CallOpGetResult0At(MlirOperation op, intptr_t index) {
  return mlirOperationGetResult(op, 0 + index);
}
 
bool llzkFunction_CallOpCalleeContainsWitnessGen(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeContainsWitnessGen();
}
 
bool llzkFunction_CallOpCalleeIsStructCompute(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsStructCompute();
}
 
MlirType llzkFunction_CallOpGetSingleResultTypeOfCompute(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSingleResultTypeOfCompute());
}
 
bool llzkFunction_CallOpCalleeIsStructConstrain(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsStructConstrain();
}
 
MlirValue llzkFunction_CallOpGetSelfValueFromConstrain(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSelfValueFromConstrain());
}
 
bool llzkFunction_CallOpCalleeIsCompute(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsCompute();
}
 
bool llzkFunction_CallOpCalleeIsConstrain(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsConstrain();
}
 
bool llzkFunction_CallOpCalleeIsProduct(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsProduct();
}
 
bool llzkFunction_CallOpCalleeIsStructProduct(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsStructProduct();
}
 
bool llzkFunction_CallOpCalleeIsInStruct(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsInStruct();
}
 
MlirValue llzkFunction_CallOpGetSelfValueFromProduct(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSelfValueFromProduct());
}
 
MlirValue llzkFunction_CallOpGetSelfValueFromCompute(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSelfValueFromCompute());
}
 
MlirType llzkFunction_CallOpGetSingleResultTypeOfWitnessGen(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSingleResultTypeOfWitnessGen());
}
 
MlirOperation llzkFunction_CallOpResolveCallable(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).resolveCallable());
}
 
MlirValue llzkFunction_CallOpGetSelfValue(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getSelfValue());
}
 
MlirOperation llzkFunction_FuncDefOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name, MlirAttribute function_type, MlirAttribute arg_attrs, MlirAttribute res_attrs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("function.def"), location);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 4> attributes;
  if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(sym_name))) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), reinterpret_cast<MlirAttribute&>(sym_name)));
  }
  if (!mlirAttributeIsNull(function_type)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("function_type")), function_type));
  }
  if (!mlirAttributeIsNull(arg_attrs)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("arg_attrs")), arg_attrs));
  }
  if (!mlirAttributeIsNull(res_attrs)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("res_attrs")), res_attrs));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
  llvm::SmallVector<MlirRegion, 1> regions;
  regions.push_back(mlirRegionCreate());
  mlirOperationStateAddOwnedRegions(&state, regions.size(), regions.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Function_FuncDefOp(MlirOperation inp) {
  return llvm::isa<FuncDefOp>(unwrap(inp));
}
 
MlirAttribute llzkFunction_FuncDefOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkFunction_FuncDefOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirAttribute llzkFunction_FuncDefOpGetFunctionType(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("function_type"));
}
 
void llzkFunction_FuncDefOpSetFunctionType(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("function_type"), attr);
}
 
MlirAttribute llzkFunction_FuncDefOpGetArgAttrs(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"));
}
 
void llzkFunction_FuncDefOpSetArgAttrs(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"), attr);
}
 
MlirAttribute llzkFunction_FuncDefOpGetResAttrs(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("res_attrs"));
}
 
void llzkFunction_FuncDefOpSetResAttrs(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("res_attrs"), attr);
}
 
MlirRegion llzkFunction_FuncDefOpGetBody(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
void llzkFunction_FuncDefOpSetAllowNonNativeFieldOpsAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowNonNativeFieldOpsAttr(newValue);
}
 
bool llzkFunction_FuncDefOpIsStructProduct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructProduct();
}
 
bool llzkFunction_FuncDefOpHasAllowNonNativeFieldOpsAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowNonNativeFieldOpsAttr();
}
 
bool llzkFunction_FuncDefOpHasArgPublicAttr(MlirOperation inp, unsigned index) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasArgPublicAttr(index);
}
 
bool llzkFunction_FuncDefOpNameIsProduct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsProduct();
}
 
bool llzkFunction_FuncDefOpHasAllowWitnessAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowWitnessAttr();
}
 
bool llzkFunction_FuncDefOpHasAllowVerifOpsAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowVerifOpsAttr();
}
 
bool llzkFunction_FuncDefOpHasResName(MlirOperation inp, unsigned index) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasResName(index);
}
 
bool llzkFunction_FuncDefOpIsStructConstrain(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructConstrain();
}
 
bool llzkFunction_FuncDefOpNameIsCompute(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsCompute();
}
 
bool llzkFunction_FuncDefOpIsDeclaration(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isDeclaration();
}
 
MlirType llzkFunction_FuncDefOpGetSingleResultTypeOfCompute(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSingleResultTypeOfCompute());
}
 
MlirValue llzkFunction_FuncDefOpGetSelfValueFromConstrain(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSelfValueFromConstrain());
}
 
void llzkFunction_FuncDefOpSetAllowVerifOpsAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowVerifOpsAttr(newValue);
}
 
bool llzkFunction_FuncDefOpNameIsConstrain(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsConstrain();
}
 
void llzkFunction_FuncDefOpSetAllowConstraintAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowConstraintAttr(newValue);
}
 
MlirRegion llzkFunction_FuncDefOpGetCallableRegion(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getCallableRegion());
}
 
bool llzkFunction_FuncDefOpHasAllowConstraintAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowConstraintAttr();
}
 
bool llzkFunction_FuncDefOpIsInStruct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isInStruct();
}
 
bool llzkFunction_FuncDefOpIsStructCompute(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructCompute();
}
 
void llzkFunction_FuncDefOpSetAllowWitnessAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowWitnessAttr(newValue);
}
 
MlirValue llzkFunction_FuncDefOpGetSelfValueFromCompute(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSelfValueFromCompute());
}
 
MlirValue llzkFunction_FuncDefOpGetSelfValueFromProduct(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSelfValueFromProduct());
}
 
bool llzkFunction_FuncDefOpHasArgName(MlirOperation inp, unsigned index) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasArgName(index);
}
 
MlirAttribute llzkFunction_FuncDefOpGetFullyQualifiedName(MlirOperation inp, bool requireParent) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getFullyQualifiedName(requireParent));
}
 
MlirOperation llzkFunction_ReturnOpBuild(MlirOpBuilder builder, MlirLocation location, intptr_t operandsSize, MlirValue const *operands) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("function.return"), location);
  mlirOperationStateAddOperands(&state, operandsSize, operands);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Function_ReturnOp(MlirOperation inp) {
  return llvm::isa<ReturnOp>(unwrap(inp));
}
 
intptr_t llzkFunction_ReturnOpGetOperandsCount(MlirOperation op) {
  auto range = llvm::cast<ReturnOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  return range.second;
}
 
MlirValue llzkFunction_ReturnOpGetOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<ReturnOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(index >= 0 && index < range.second && "variadic operand index out of range");
  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) + index);
}
 
void llzkFunction_ReturnOpSetOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  if (count < 0)
    return;
  ::llvm::SmallVector<::mlir::Value> vals;
  vals.reserve(static_cast<size_t>(count));
  for (intptr_t i = 0; i < count; ++i)
    vals.push_back(unwrap(values[i]));
  ::llvm::cast<ReturnOp>(unwrap(op)).getOperandsMutable().assign(vals);
}