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 llzkGlobal_GlobalDefOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name, MlirAttribute constant, MlirAttribute type, MlirAttribute initial_value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("global.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(constant)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("constant")), constant));
  }
  if (!mlirAttributeIsNull(type)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("type")), type));
  }
  if (!mlirAttributeIsNull(initial_value)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("initial_value")), initial_value));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Global_GlobalDefOp(MlirOperation inp) {
  return llvm::isa<GlobalDefOp>(unwrap(inp));
}
 
MlirAttribute llzkGlobal_GlobalDefOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkGlobal_GlobalDefOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirAttribute llzkGlobal_GlobalDefOpGetConstant(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("constant"));
}
 
void llzkGlobal_GlobalDefOpSetConstant(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("constant"), attr);
}
 
MlirAttribute llzkGlobal_GlobalDefOpGetType(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("type"));
}
 
void llzkGlobal_GlobalDefOpSetType(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("type"), attr);
}
 
MlirAttribute llzkGlobal_GlobalDefOpGetInitialValue(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("initial_value"));
}
 
void llzkGlobal_GlobalDefOpSetInitialValue(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("initial_value"), attr);
}
 
bool llzkGlobal_GlobalDefOpIsConstant(MlirOperation inp) {
  return llvm::cast<GlobalDefOp>(unwrap(inp)).isConstant();
}
 
MlirOperation llzkGlobal_GlobalReadOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType valType, MlirAttribute constant, MlirAttribute name_ref) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("global.read"), location);
  mlirOperationStateAddResults(&state, 1, &valType);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 2> attributes;
  if (!mlirAttributeIsNull(constant)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("constant")), constant));
  }
  if (!mlirAttributeIsNull(name_ref)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("name_ref")), name_ref));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Global_GlobalReadOp(MlirOperation inp) {
  return llvm::isa<GlobalReadOp>(unwrap(inp));
}
 
MlirAttribute llzkGlobal_GlobalReadOpGetConstant(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("constant"));
}
 
void llzkGlobal_GlobalReadOpSetConstant(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("constant"), attr);
}
 
MlirAttribute llzkGlobal_GlobalReadOpGetNameRef(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("name_ref"));
}
 
void llzkGlobal_GlobalReadOpSetNameRef(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("name_ref"), attr);
}
 
MlirValue llzkGlobal_GlobalReadOpGetVal(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
bool llzkGlobal_GlobalReadOpIsConstant(MlirOperation inp) {
  return llvm::cast<GlobalReadOp>(unwrap(inp)).isConstant();
}
 
MlirOperation llzkGlobal_GlobalWriteOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue val, MlirAttribute name_ref) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("global.write"), location);
  mlirOperationStateAddOperands(&state, 1, &val);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(name_ref)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("name_ref")), name_ref));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Global_GlobalWriteOp(MlirOperation inp) {
  return llvm::isa<GlobalWriteOp>(unwrap(inp));
}
 
MlirValue llzkGlobal_GlobalWriteOpGetVal(MlirOperation op) {
  auto range = llvm::cast<GlobalWriteOp>(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 llzkGlobal_GlobalWriteOpSetVal(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<GlobalWriteOp>(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 llzkGlobal_GlobalWriteOpGetNameRef(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("name_ref"));
}
 
void llzkGlobal_GlobalWriteOpSetNameRef(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("name_ref"), attr);
}