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_Poly_ApplyMapOp(MlirOperation inp) {
  return llvm::isa<ApplyMapOp>(unwrap(inp));
}
 
intptr_t llzkPoly_ApplyMapOpGetMapOperandsCount(MlirOperation op) {
  auto range = llvm::cast<ApplyMapOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  return range.second;
}
 
MlirValue llzkPoly_ApplyMapOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<ApplyMapOp>(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 llzkPoly_ApplyMapOpSetMapOperands(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<ApplyMapOp>(unwrap(op)).getMapOperandsMutable().assign(vals);
}
 
MlirAttribute llzkPoly_ApplyMapOpGetMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("map"));
}
 
void llzkPoly_ApplyMapOpSetMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("map"), attr);
}
 
MlirAttribute llzkPoly_ApplyMapOpGetNumDims(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDims"));
}
 
void llzkPoly_ApplyMapOpSetNumDims(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDims"), attr);
}
 
MlirValue llzkPoly_ApplyMapOpGetResult0(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirAffineMap llzkPoly_ApplyMapOpGetAffineMap(MlirOperation inp) {
  return wrap(llvm::cast<ApplyMapOp>(unwrap(inp)).getAffineMap());
}
 
MlirOperation llzkPoly_ConstReadOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType valType, MlirAttribute const_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.read_const"), location);
  mlirOperationStateAddResults(&state, 1, &valType);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(const_name)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("const_name")), const_name));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Poly_ConstReadOp(MlirOperation inp) {
  return llvm::isa<ConstReadOp>(unwrap(inp));
}
 
MlirAttribute llzkPoly_ConstReadOpGetConstName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("const_name"));
}
 
void llzkPoly_ConstReadOpSetConstName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("const_name"), attr);
}
 
MlirValue llzkPoly_ConstReadOpGetVal(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkPoly_TemplateExprOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.expr"), location);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(sym_name))) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), reinterpret_cast<MlirAttribute&>(sym_name)));
  }
  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_Poly_TemplateExprOp(MlirOperation inp) {
  return llvm::isa<TemplateExprOp>(unwrap(inp));
}
 
MlirAttribute llzkPoly_TemplateExprOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkPoly_TemplateExprOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirRegion llzkPoly_TemplateExprOpGetInitializerRegion(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
MlirType llzkPoly_TemplateExprOpGetType(MlirOperation inp) {
  return wrap(llvm::cast<TemplateExprOp>(unwrap(inp)).getType());
}
 
MlirOperation llzkPoly_TemplateOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.template"), location);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(sym_name))) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), reinterpret_cast<MlirAttribute&>(sym_name)));
  }
  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_Poly_TemplateOp(MlirOperation inp) {
  return llvm::isa<TemplateOp>(unwrap(inp));
}
 
MlirAttribute llzkPoly_TemplateOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkPoly_TemplateOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirRegion llzkPoly_TemplateOpGetBodyRegion(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
MlirOperation llzkPoly_TemplateParamOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name, MlirAttribute type_opt) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.param"), location);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 2> attributes;
  if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(sym_name))) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), reinterpret_cast<MlirAttribute&>(sym_name)));
  }
  if (!mlirAttributeIsNull(type_opt)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("type_opt")), type_opt));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Poly_TemplateParamOp(MlirOperation inp) {
  return llvm::isa<TemplateParamOp>(unwrap(inp));
}
 
MlirAttribute llzkPoly_TemplateParamOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkPoly_TemplateParamOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirAttribute llzkPoly_TemplateParamOpGetTypeOpt(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("type_opt"));
}
 
void llzkPoly_TemplateParamOpSetTypeOpt(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("type_opt"), attr);
}
 
MlirOperation llzkPoly_UnifiableCastOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue input) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.unifiable_cast"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &input);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Poly_UnifiableCastOp(MlirOperation inp) {
  return llvm::isa<UnifiableCastOp>(unwrap(inp));
}
 
MlirValue llzkPoly_UnifiableCastOpGetInput(MlirOperation op) {
  auto range = llvm::cast<UnifiableCastOp>(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 llzkPoly_UnifiableCastOpSetInput(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<UnifiableCastOp>(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 llzkPoly_UnifiableCastOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkPoly_YieldOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue val) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("poly.yield"), location);
  mlirOperationStateAddOperands(&state, 1, &val);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Poly_YieldOp(MlirOperation inp) {
  return llvm::isa<YieldOp>(unwrap(inp));
}
 
MlirValue llzkPoly_YieldOpGetVal(MlirOperation op) {
  auto range = llvm::cast<YieldOp>(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 llzkPoly_YieldOpSetVal(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<YieldOp>(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);
}