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 llzkStruct_CreateStructOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("struct.new"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Struct_CreateStructOp(MlirOperation inp) {
  return llvm::isa<CreateStructOp>(unwrap(inp));
}
 
MlirValue llzkStruct_CreateStructOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
bool llzkOperationIsA_Struct_MemberDefOp(MlirOperation inp) {
  return llvm::isa<MemberDefOp>(unwrap(inp));
}
 
MlirAttribute llzkStruct_MemberDefOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkStruct_MemberDefOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirAttribute llzkStruct_MemberDefOpGetType(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("type"));
}
 
void llzkStruct_MemberDefOpSetType(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("type"), attr);
}
 
MlirAttribute llzkStruct_MemberDefOpGetColumn(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("column"));
}
 
void llzkStruct_MemberDefOpSetColumn(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("column"), attr);
}
 
MlirAttribute llzkStruct_MemberDefOpGetSignal(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("signal"));
}
 
void llzkStruct_MemberDefOpSetSignal(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("signal"), attr);
}
 
void llzkStruct_MemberDefOpSetPublicAttr(MlirOperation inp, bool newValue) {
  llvm::cast<MemberDefOp>(unwrap(inp)).setPublicAttr(newValue);
}
 
bool llzkStruct_MemberDefOpHasPublicAttr(MlirOperation inp) {
  return llvm::cast<MemberDefOp>(unwrap(inp)).hasPublicAttr();
}
 
bool llzkOperationIsA_Struct_MemberReadOp(MlirOperation inp) {
  return llvm::isa<MemberReadOp>(unwrap(inp));
}
 
MlirValue llzkStruct_MemberReadOpGetComponent(MlirOperation op) {
  auto range = llvm::cast<MemberReadOp>(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 llzkStruct_MemberReadOpSetComponent(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<MemberReadOp>(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);
}
 
intptr_t llzkStruct_MemberReadOpGetMapOperandsCount(MlirOperation op) {
  auto range = llvm::cast<MemberReadOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkStruct_MemberReadOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<MemberReadOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  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 llzkStruct_MemberReadOpSetMapOperands(MlirOperation op, intptr_t groupCount, MlirValueRange const *groups) {
  if (groupCount < 0)
    return;
 
  ::llvm::SmallVector<::mlir::Value> vals;
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(groups[g].size >= 0 && "group size must be non-negative");
    for (intptr_t i = 0; i < groups[g].size; ++i) {
      vals.push_back(unwrap(groups[g].values[i]));
    }
  }
  ::llvm::cast<MemberReadOp>(unwrap(op)).getMapOperandsMutable().join().assign(vals);
 
  ::llvm::SmallVector<int32_t> newGroupSizes;
  newGroupSizes.reserve(static_cast<size_t>(groupCount));
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(
        groups[g].size <= static_cast<intptr_t>(std::numeric_limits<int32_t>::max()) &&
        "group size exceeds int32_t range"
    );
    newGroupSizes.push_back(static_cast<int32_t>(groups[g].size));
  }
  MlirContext ctx = mlirOperationGetContext(op);
  assert(
      newGroupSizes.size() <= static_cast<size_t>(std::numeric_limits<intptr_t>::max()) &&
      "group count exceeds intptr_t range"
  );
  mlirOperationSetAttributeByName(
      op, mlirStringRefCreateFromCString("mapOpGroupSizes"),
      mlirDenseI32ArrayGet(ctx, static_cast<intptr_t>(newGroupSizes.size()), newGroupSizes.data())
  );
}
 
MlirAttribute llzkStruct_MemberReadOpGetMemberName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("member_name"));
}
 
void llzkStruct_MemberReadOpSetMemberName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("member_name"), attr);
}
 
MlirAttribute llzkStruct_MemberReadOpGetTableOffset(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("tableOffset"));
}
 
void llzkStruct_MemberReadOpSetTableOffset(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("tableOffset"), attr);
}
 
MlirAttribute llzkStruct_MemberReadOpGetNumDimsPerMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"));
}
 
void llzkStruct_MemberReadOpSetNumDimsPerMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"), attr);
}
 
MlirAttribute llzkStruct_MemberReadOpGetMapOpGroupSizes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"));
}
 
void llzkStruct_MemberReadOpSetMapOpGroupSizes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"), attr);
}
 
MlirValue llzkStruct_MemberReadOpGetVal(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkStruct_MemberWriteOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue component, MlirValue val, MlirAttribute member_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("struct.writem"), location);
  mlirOperationStateAddOperands(&state, 1, &component);
  mlirOperationStateAddOperands(&state, 1, &val);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(member_name)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("member_name")), member_name));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Struct_MemberWriteOp(MlirOperation inp) {
  return llvm::isa<MemberWriteOp>(unwrap(inp));
}
 
MlirValue llzkStruct_MemberWriteOpGetComponent(MlirOperation op) {
  auto range = llvm::cast<MemberWriteOp>(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 llzkStruct_MemberWriteOpSetComponent(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<MemberWriteOp>(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 llzkStruct_MemberWriteOpGetVal(MlirOperation op) {
  auto range = llvm::cast<MemberWriteOp>(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 llzkStruct_MemberWriteOpSetVal(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<MemberWriteOp>(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);
}
 
MlirAttribute llzkStruct_MemberWriteOpGetMemberName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("member_name"));
}
 
void llzkStruct_MemberWriteOpSetMemberName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("member_name"), attr);
}
 
MlirOperation llzkStruct_StructDefOpBuild(MlirOpBuilder builder, MlirLocation location, MlirIdentifier sym_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("struct.def"), 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_Struct_StructDefOp(MlirOperation inp) {
  return llvm::isa<StructDefOp>(unwrap(inp));
}
 
MlirAttribute llzkStruct_StructDefOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkStruct_StructDefOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirRegion llzkStruct_StructDefOpGetBodyRegion(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
MlirOperation llzkStruct_StructDefOpGetComputeFuncOp(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).getComputeFuncOp());
}
 
MlirOperation llzkStruct_StructDefOpGetProductFuncOp(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).getProductFuncOp());
}
 
MlirOperation llzkStruct_StructDefOpGetMemberDef(MlirOperation inp, MlirIdentifier memberName) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).getMemberDef(unwrap(memberName)));
}
 
MlirLogicalResult llzkStruct_StructDefOpHasColumns(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).hasColumns());
}
 
bool llzkStruct_StructDefOpHasComputeConstrain(MlirOperation inp) {
  return llvm::cast<StructDefOp>(unwrap(inp)).hasComputeConstrain();
}
 
MlirOperation llzkStruct_StructDefOpGetConstrainFuncOp(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).getConstrainFuncOp());
}
 
bool llzkStruct_StructDefOpHasTemplateSymbolBindings(MlirOperation inp) {
  return llvm::cast<StructDefOp>(unwrap(inp)).hasTemplateSymbolBindings();
}
 
MlirLogicalResult llzkStruct_StructDefOpHasSignals(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).hasSignals());
}
 
bool llzkStruct_StructDefOpIsMainComponent(MlirOperation inp) {
  return llvm::cast<StructDefOp>(unwrap(inp)).isMainComponent();
}
 
MlirAttribute llzkStruct_StructDefOpGetFullyQualifiedName(MlirOperation inp) {
  return wrap(llvm::cast<StructDefOp>(unwrap(inp)).getFullyQualifiedName());
}