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 llzkArray_ArrayLengthOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue arr_ref, MlirValue dim) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("array.len"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &arr_ref);
  mlirOperationStateAddOperands(&state, 1, &dim);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Array_ArrayLengthOp(MlirOperation inp) {
  return llvm::isa<ArrayLengthOp>(unwrap(inp));
}
 
MlirValue llzkArray_ArrayLengthOpGetArrRef(MlirOperation op) {
  auto range = llvm::cast<ArrayLengthOp>(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 llzkArray_ArrayLengthOpSetArrRef(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<ArrayLengthOp>(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 llzkArray_ArrayLengthOpGetDim(MlirOperation op) {
  auto range = llvm::cast<ArrayLengthOp>(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 llzkArray_ArrayLengthOpSetDim(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<ArrayLengthOp>(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);
}
 
MlirValue llzkArray_ArrayLengthOpGetLength(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirType llzkArray_ArrayLengthOpGetArrRefType(MlirOperation inp) {
  return wrap(llvm::cast<ArrayLengthOp>(unwrap(inp)).getArrRefType());
}
 
bool llzkOperationIsA_Array_CreateArrayOp(MlirOperation inp) {
  return llvm::isa<CreateArrayOp>(unwrap(inp));
}
 
intptr_t llzkArray_CreateArrayOpGetElementsCount(MlirOperation op) {
  auto range = llvm::cast<CreateArrayOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  return range.second;
}
 
MlirValue llzkArray_CreateArrayOpGetElementsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<CreateArrayOp>(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 llzkArray_CreateArrayOpSetElements(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<CreateArrayOp>(unwrap(op)).getElementsMutable().assign(vals);
}
 
intptr_t llzkArray_CreateArrayOpGetMapOperandsCount(MlirOperation op) {
  auto range = llvm::cast<CreateArrayOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkArray_CreateArrayOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<CreateArrayOp>(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 llzkArray_CreateArrayOpSetMapOperands(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<CreateArrayOp>(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 llzkArray_CreateArrayOpGetNumDimsPerMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"));
}
 
void llzkArray_CreateArrayOpSetNumDimsPerMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"), attr);
}
 
MlirAttribute llzkArray_CreateArrayOpGetMapOpGroupSizes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"));
}
 
void llzkArray_CreateArrayOpSetMapOpGroupSizes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"), attr);
}
 
MlirValue llzkArray_CreateArrayOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkArray_ExtractArrayOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue arr_ref, intptr_t indicesSize, MlirValue const *indices) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("array.extract"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &arr_ref);
  mlirOperationStateAddOperands(&state, indicesSize, indices);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Array_ExtractArrayOp(MlirOperation inp) {
  return llvm::isa<ExtractArrayOp>(unwrap(inp));
}
 
MlirValue llzkArray_ExtractArrayOpGetArrRef(MlirOperation op) {
  auto range = llvm::cast<ExtractArrayOp>(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 llzkArray_ExtractArrayOpSetArrRef(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<ExtractArrayOp>(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 llzkArray_ExtractArrayOpGetIndicesCount(MlirOperation op) {
  auto range = llvm::cast<ExtractArrayOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkArray_ExtractArrayOpGetIndicesAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<ExtractArrayOp>(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 llzkArray_ExtractArrayOpSetIndices(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<ExtractArrayOp>(unwrap(op)).getIndicesMutable().assign(vals);
}
 
MlirValue llzkArray_ExtractArrayOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirType llzkArray_ExtractArrayOpGetArrRefType(MlirOperation inp) {
  return wrap(llvm::cast<ExtractArrayOp>(unwrap(inp)).getArrRefType());
}
 
MlirOperation llzkArray_InsertArrayOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue arr_ref, intptr_t indicesSize, MlirValue const *indices, MlirValue rvalue) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("array.insert"), location);
  mlirOperationStateAddOperands(&state, 1, &arr_ref);
  mlirOperationStateAddOperands(&state, indicesSize, indices);
  mlirOperationStateAddOperands(&state, 1, &rvalue);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Array_InsertArrayOp(MlirOperation inp) {
  return llvm::isa<InsertArrayOp>(unwrap(inp));
}
 
MlirValue llzkArray_InsertArrayOpGetArrRef(MlirOperation op) {
  auto range = llvm::cast<InsertArrayOp>(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 llzkArray_InsertArrayOpSetArrRef(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<InsertArrayOp>(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 llzkArray_InsertArrayOpGetIndicesCount(MlirOperation op) {
  auto range = llvm::cast<InsertArrayOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkArray_InsertArrayOpGetIndicesAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<InsertArrayOp>(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 llzkArray_InsertArrayOpSetIndices(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<InsertArrayOp>(unwrap(op)).getIndicesMutable().assign(vals);
}
 
MlirValue llzkArray_InsertArrayOpGetRvalue(MlirOperation op) {
  auto range = llvm::cast<InsertArrayOp>(unwrap(op)).getODSOperandIndexAndLength(2);
  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 llzkArray_InsertArrayOpSetRvalue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<InsertArrayOp>(unwrap(op)).getODSOperandIndexAndLength(2);
  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);
}
 
MlirType llzkArray_InsertArrayOpGetArrRefType(MlirOperation inp) {
  return wrap(llvm::cast<InsertArrayOp>(unwrap(inp)).getArrRefType());
}
 
MlirOperation llzkArray_ReadArrayOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue arr_ref, intptr_t indicesSize, MlirValue const *indices) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("array.read"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &arr_ref);
  mlirOperationStateAddOperands(&state, indicesSize, indices);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Array_ReadArrayOp(MlirOperation inp) {
  return llvm::isa<ReadArrayOp>(unwrap(inp));
}
 
MlirValue llzkArray_ReadArrayOpGetArrRef(MlirOperation op) {
  auto range = llvm::cast<ReadArrayOp>(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 llzkArray_ReadArrayOpSetArrRef(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<ReadArrayOp>(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 llzkArray_ReadArrayOpGetIndicesCount(MlirOperation op) {
  auto range = llvm::cast<ReadArrayOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkArray_ReadArrayOpGetIndicesAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<ReadArrayOp>(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 llzkArray_ReadArrayOpSetIndices(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<ReadArrayOp>(unwrap(op)).getIndicesMutable().assign(vals);
}
 
MlirValue llzkArray_ReadArrayOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirType llzkArray_ReadArrayOpGetArrRefType(MlirOperation inp) {
  return wrap(llvm::cast<ReadArrayOp>(unwrap(inp)).getArrRefType());
}
 
MlirOperation llzkArray_WriteArrayOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue arr_ref, intptr_t indicesSize, MlirValue const *indices, MlirValue rvalue) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("array.write"), location);
  mlirOperationStateAddOperands(&state, 1, &arr_ref);
  mlirOperationStateAddOperands(&state, indicesSize, indices);
  mlirOperationStateAddOperands(&state, 1, &rvalue);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Array_WriteArrayOp(MlirOperation inp) {
  return llvm::isa<WriteArrayOp>(unwrap(inp));
}
 
MlirValue llzkArray_WriteArrayOpGetArrRef(MlirOperation op) {
  auto range = llvm::cast<WriteArrayOp>(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 llzkArray_WriteArrayOpSetArrRef(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<WriteArrayOp>(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 llzkArray_WriteArrayOpGetIndicesCount(MlirOperation op) {
  auto range = llvm::cast<WriteArrayOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkArray_WriteArrayOpGetIndicesAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<WriteArrayOp>(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 llzkArray_WriteArrayOpSetIndices(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<WriteArrayOp>(unwrap(op)).getIndicesMutable().assign(vals);
}
 
MlirValue llzkArray_WriteArrayOpGetRvalue(MlirOperation op) {
  auto range = llvm::cast<WriteArrayOp>(unwrap(op)).getODSOperandIndexAndLength(2);
  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 llzkArray_WriteArrayOpSetRvalue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<WriteArrayOp>(unwrap(op)).getODSOperandIndexAndLength(2);
  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);
}
 
MlirType llzkArray_WriteArrayOpGetArrRefType(MlirOperation inp) {
  return wrap(llvm::cast<WriteArrayOp>(unwrap(inp)).getArrRefType());
}