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                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
 
bool llzkOperationIsA_Function_CallOp(MlirOperation inp) {
  return llvm::isa<CallOp>(unwrap(inp));
}
 
intptr_t llzkFunction_CallOpGetArgOperandsCount(MlirOperation op) {
  intptr_t count = mlirOperationGetNumOperands(op);
  assert(count >= 0 && "operand count less than start index");
  return count - 0;
}
 
MlirValue llzkFunction_CallOpGetArgOperandsAt(MlirOperation op, intptr_t index) {
  return mlirOperationGetOperand(op, 0 + index);
}
 
void llzkFunction_CallOpSetArgOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  intptr_t numOperands = mlirOperationGetNumOperands(op);
  intptr_t startIdx = 0;
 
  // Validate bounds
  if (startIdx < 0 || startIdx > numOperands) {
    return;
  }
  if (count < 0 || count > (std::numeric_limits<intptr_t>::max() - startIdx)) {
    return;
  }
 
  intptr_t oldCount = numOperands - startIdx;
  intptr_t newNumOperands = startIdx + count;
 
  std::vector<MlirValue> newOperands(newNumOperands);
 
  // Copy operands before this variadic group
  for (intptr_t i = 0; i < startIdx; ++i) {
    newOperands[i] = mlirOperationGetOperand(op, i);
  }
 
  // Copy new variadic operands
  for (intptr_t i = 0; i < count; ++i) {
    newOperands[startIdx + i] = values[i];
  }
 
  // Copy operands after this variadic group
  for (intptr_t i = startIdx + oldCount; i < numOperands; ++i) {
    newOperands[i - oldCount + count] = mlirOperationGetOperand(op, i);
  }
 
  mlirOperationSetOperands(op, newNumOperands, newOperands.data());
}
 
intptr_t llzkFunction_CallOpGetMapOperandsCount(MlirOperation op) {
  intptr_t count = mlirOperationGetNumOperands(op);
  assert(count >= 1 && "operand count less than start index");
  return count - 1;
}
 
MlirValue llzkFunction_CallOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  return mlirOperationGetOperand(op, 1 + index);
}
 
void llzkFunction_CallOpSetMapOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  intptr_t numOperands = mlirOperationGetNumOperands(op);
  intptr_t startIdx = 1;
 
  // Validate bounds
  if (startIdx < 0 || startIdx > numOperands) {
    return;
  }
  if (count < 0 || count > (std::numeric_limits<intptr_t>::max() - startIdx)) {
    return;
  }
 
  intptr_t oldCount = numOperands - startIdx;
  intptr_t newNumOperands = startIdx + count;
 
  std::vector<MlirValue> newOperands(newNumOperands);
 
  // Copy operands before this variadic group
  for (intptr_t i = 0; i < startIdx; ++i) {
    newOperands[i] = mlirOperationGetOperand(op, i);
  }
 
  // Copy new variadic operands
  for (intptr_t i = 0; i < count; ++i) {
    newOperands[startIdx + i] = values[i];
  }
 
  // Copy operands after this variadic group
  for (intptr_t i = startIdx + oldCount; i < numOperands; ++i) {
    newOperands[i - oldCount + count] = mlirOperationGetOperand(op, i);
  }
 
  mlirOperationSetOperands(op, newNumOperands, newOperands.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);
}
 
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());
}
 
MlirType llzkFunction_CallOpGetTypeSignature(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).getTypeSignature());
}
 
bool llzkFunction_CallOpCalleeIsCompute(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsCompute();
}
 
bool llzkFunction_CallOpCalleeIsConstrain(MlirOperation inp) {
  return llvm::cast<CallOp>(unwrap(inp)).calleeIsConstrain();
}
 
MlirOperation llzkFunction_CallOpResolveCallable(MlirOperation inp) {
  return wrap(llvm::cast<CallOp>(unwrap(inp)).resolveCallable());
}
 
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_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);
}
 
MlirAttribute llzkFunction_FuncDefOpGetFullyQualifiedName(MlirOperation inp, bool requireParent) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getFullyQualifiedName(requireParent));
}
 
void llzkFunction_FuncDefOpSetAllowNonNativeFieldOpsAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowNonNativeFieldOpsAttr(newValue);
}
 
bool llzkFunction_FuncDefOpIsDeclaration(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isDeclaration();
}
 
bool llzkFunction_FuncDefOpHasAllowNonNativeFieldOpsAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowNonNativeFieldOpsAttr();
}
 
bool llzkFunction_FuncDefOpNameIsProduct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsProduct();
}
 
bool llzkFunction_FuncDefOpHasArgPublicAttr(MlirOperation inp, unsigned index) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasArgPublicAttr(index);
}
 
bool llzkFunction_FuncDefOpIsStructProduct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructProduct();
}
 
MlirValue llzkFunction_FuncDefOpGetSelfValueFromConstrain(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSelfValueFromConstrain());
}
 
MlirType llzkFunction_FuncDefOpGetSingleResultTypeOfCompute(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSingleResultTypeOfCompute());
}
 
bool llzkFunction_FuncDefOpHasAllowWitnessAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowWitnessAttr();
}
 
bool llzkFunction_FuncDefOpNameIsConstrain(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsConstrain();
}
 
MlirRegion llzkFunction_FuncDefOpGetCallableRegion(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getCallableRegion());
}
 
void llzkFunction_FuncDefOpSetAllowConstraintAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowConstraintAttr(newValue);
}
 
MlirValue llzkFunction_FuncDefOpGetSelfValueFromCompute(MlirOperation inp) {
  return wrap(llvm::cast<FuncDefOp>(unwrap(inp)).getSelfValueFromCompute());
}
 
bool llzkFunction_FuncDefOpHasAllowConstraintAttr(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).hasAllowConstraintAttr();
}
 
bool llzkFunction_FuncDefOpIsInStruct(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isInStruct();
}
 
void llzkFunction_FuncDefOpSetAllowWitnessAttr(MlirOperation inp, bool newValue) {
  llvm::cast<FuncDefOp>(unwrap(inp)).setAllowWitnessAttr(newValue);
}
 
bool llzkFunction_FuncDefOpNameIsCompute(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).nameIsCompute();
}
 
bool llzkFunction_FuncDefOpIsStructConstrain(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructConstrain();
}
 
bool llzkFunction_FuncDefOpIsStructCompute(MlirOperation inp) {
  return llvm::cast<FuncDefOp>(unwrap(inp)).isStructCompute();
}
 
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) {
  intptr_t count = mlirOperationGetNumOperands(op);
  assert(count >= 0 && "operand count less than start index");
  return count - 0;
}
 
MlirValue llzkFunction_ReturnOpGetOperandsAt(MlirOperation op, intptr_t index) {
  return mlirOperationGetOperand(op, 0 + index);
}
 
void llzkFunction_ReturnOpSetOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  intptr_t numOperands = mlirOperationGetNumOperands(op);
  intptr_t startIdx = 0;
 
  // Validate bounds
  if (startIdx < 0 || startIdx > numOperands) {
    return;
  }
  if (count < 0 || count > (std::numeric_limits<intptr_t>::max() - startIdx)) {
    return;
  }
 
  intptr_t oldCount = numOperands - startIdx;
  intptr_t newNumOperands = startIdx + count;
 
  std::vector<MlirValue> newOperands(newNumOperands);
 
  // Copy operands before this variadic group
  for (intptr_t i = 0; i < startIdx; ++i) {
    newOperands[i] = mlirOperationGetOperand(op, i);
  }
 
  // Copy new variadic operands
  for (intptr_t i = 0; i < count; ++i) {
    newOperands[startIdx + i] = values[i];
  }
 
  // Copy operands after this variadic group
  for (intptr_t i = startIdx + oldCount; i < numOperands; ++i) {
    newOperands[i - oldCount + count] = mlirOperationGetOperand(op, i);
  }
 
  mlirOperationSetOperands(op, newNumOperands, newOperands.data());
}