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 llzkCast_FeltToIndexOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value, MlirAttribute overflow) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("cast.toindex"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &value);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(overflow)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("overflow")), overflow));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Cast_FeltToIndexOp(MlirOperation inp) {
  return llvm::isa<FeltToIndexOp>(unwrap(inp));
}
 
MlirValue llzkCast_FeltToIndexOpGetValue(MlirOperation op) {
  auto range = llvm::cast<FeltToIndexOp>(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 llzkCast_FeltToIndexOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<FeltToIndexOp>(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 llzkCast_FeltToIndexOpGetOverflow(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("overflow"));
}
 
void llzkCast_FeltToIndexOpSetOverflow(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("overflow"), attr);
}
 
MlirValue llzkCast_FeltToIndexOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkCast_IntToFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value, MlirAttribute overflow) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("cast.tofelt"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &value);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(overflow)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("overflow")), overflow));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Cast_IntToFeltOp(MlirOperation inp) {
  return llvm::isa<IntToFeltOp>(unwrap(inp));
}
 
MlirValue llzkCast_IntToFeltOpGetValue(MlirOperation op) {
  auto range = llvm::cast<IntToFeltOp>(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 llzkCast_IntToFeltOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<IntToFeltOp>(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 llzkCast_IntToFeltOpGetOverflow(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("overflow"));
}
 
void llzkCast_IntToFeltOpSetOverflow(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("overflow"), attr);
}
 
MlirValue llzkCast_IntToFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}