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 llzkConstrain_EmitContainmentOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("constrain.in"), location);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Constrain_EmitContainmentOp(MlirOperation inp) {
  return llvm::isa<EmitContainmentOp>(unwrap(inp));
}
 
MlirValue llzkConstrain_EmitContainmentOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<EmitContainmentOp>(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 llzkConstrain_EmitContainmentOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EmitContainmentOp>(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 llzkConstrain_EmitContainmentOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<EmitContainmentOp>(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 llzkConstrain_EmitContainmentOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EmitContainmentOp>(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);
}
 
MlirOperation llzkConstrain_EmitEqualityOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("constrain.eq"), location);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Constrain_EmitEqualityOp(MlirOperation inp) {
  return llvm::isa<EmitEqualityOp>(unwrap(inp));
}
 
MlirValue llzkConstrain_EmitEqualityOpGetLhs(MlirOperation op) {
  auto range = llvm::cast<EmitEqualityOp>(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 llzkConstrain_EmitEqualityOpSetLhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EmitEqualityOp>(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 llzkConstrain_EmitEqualityOpGetRhs(MlirOperation op) {
  auto range = llvm::cast<EmitEqualityOp>(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 llzkConstrain_EmitEqualityOpSetRhs(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EmitEqualityOp>(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);
}