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                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
 
bool llzkOperationIsA_Pod_NewPodOp(MlirOperation inp) {
  return llvm::isa<NewPodOp>(unwrap(inp));
}
 
intptr_t llzkPod_NewPodOpGetInitialValuesCount(MlirOperation op) {
  intptr_t count = mlirOperationGetNumOperands(op);
  assert(count >= 0 && "operand count less than start index");
  return count - 0;
}
 
MlirValue llzkPod_NewPodOpGetInitialValuesAt(MlirOperation op, intptr_t index) {
  return mlirOperationGetOperand(op, 0 + index);
}
 
void llzkPod_NewPodOpSetInitialValues(MlirOperation op, intptr_t count, MlirValue const *values) {
  intptr_t numOperands = mlirOperationGetNumOperands(op);
  intptr_t startIdx = 0;
 
  // Validate bounds
  if (startIdx < 0 || startIdx > numOperands) {
    return;
  }
  if (count < 0 || count > (std::numeric_limits<intptr_t>::max() - startIdx)) {
    return;
  }
 
  intptr_t oldCount = numOperands - startIdx;
  intptr_t newNumOperands = startIdx + count;
 
  std::vector<MlirValue> newOperands(newNumOperands);
 
  // Copy operands before this variadic group
  for (intptr_t i = 0; i < startIdx; ++i) {
    newOperands[i] = mlirOperationGetOperand(op, i);
  }
 
  // Copy new variadic operands
  for (intptr_t i = 0; i < count; ++i) {
    newOperands[startIdx + i] = values[i];
  }
 
  // Copy operands after this variadic group
  for (intptr_t i = startIdx + oldCount; i < numOperands; ++i) {
    newOperands[i - oldCount + count] = mlirOperationGetOperand(op, i);
  }
 
  mlirOperationSetOperands(op, newNumOperands, newOperands.data());
}
 
intptr_t llzkPod_NewPodOpGetMapOperandsCount(MlirOperation op) {
  intptr_t count = mlirOperationGetNumOperands(op);
  assert(count >= 1 && "operand count less than start index");
  return count - 1;
}
 
MlirValue llzkPod_NewPodOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  return mlirOperationGetOperand(op, 1 + index);
}
 
void llzkPod_NewPodOpSetMapOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  intptr_t numOperands = mlirOperationGetNumOperands(op);
  intptr_t startIdx = 1;
 
  // Validate bounds
  if (startIdx < 0 || startIdx > numOperands) {
    return;
  }
  if (count < 0 || count > (std::numeric_limits<intptr_t>::max() - startIdx)) {
    return;
  }
 
  intptr_t oldCount = numOperands - startIdx;
  intptr_t newNumOperands = startIdx + count;
 
  std::vector<MlirValue> newOperands(newNumOperands);
 
  // Copy operands before this variadic group
  for (intptr_t i = 0; i < startIdx; ++i) {
    newOperands[i] = mlirOperationGetOperand(op, i);
  }
 
  // Copy new variadic operands
  for (intptr_t i = 0; i < count; ++i) {
    newOperands[startIdx + i] = values[i];
  }
 
  // Copy operands after this variadic group
  for (intptr_t i = startIdx + oldCount; i < numOperands; ++i) {
    newOperands[i - oldCount + count] = mlirOperationGetOperand(op, i);
  }
 
  mlirOperationSetOperands(op, newNumOperands, newOperands.data());
}
 
MlirAttribute llzkPod_NewPodOpGetInitializedRecords(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("initializedRecords"));
}
 
void llzkPod_NewPodOpSetInitializedRecords(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("initializedRecords"), attr);
}
 
MlirAttribute llzkPod_NewPodOpGetNumDimsPerMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"));
}
 
void llzkPod_NewPodOpSetNumDimsPerMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"), attr);
}
 
MlirAttribute llzkPod_NewPodOpGetMapOpGroupSizes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"));
}
 
void llzkPod_NewPodOpSetMapOpGroupSizes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"), attr);
}
 
MlirValue llzkPod_NewPodOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkPod_ReadPodOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue pod_ref, MlirAttribute record_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("pod.read"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &pod_ref);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(record_name)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("record_name")), record_name));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Pod_ReadPodOp(MlirOperation inp) {
  return llvm::isa<ReadPodOp>(unwrap(inp));
}
 
MlirValue llzkPod_ReadPodOpGetPodRef(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkPod_ReadPodOpSetPodRef(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirAttribute llzkPod_ReadPodOpGetRecordName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("record_name"));
}
 
void llzkPod_ReadPodOpSetRecordName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("record_name"), attr);
}
 
MlirValue llzkPod_ReadPodOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkPod_WritePodOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue pod_ref, MlirValue value, MlirAttribute record_name) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("pod.write"), location);
  mlirOperationStateAddOperands(&state, 1, &pod_ref);
  mlirOperationStateAddOperands(&state, 1, &value);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(record_name)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("record_name")), record_name));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Pod_WritePodOp(MlirOperation inp) {
  return llvm::isa<WritePodOp>(unwrap(inp));
}
 
MlirValue llzkPod_WritePodOpGetPodRef(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkPod_WritePodOpSetPodRef(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkPod_WritePodOpGetValue(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkPod_WritePodOpSetValue(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirAttribute llzkPod_WritePodOpGetRecordName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("record_name"));
}
 
void llzkPod_WritePodOpSetRecordName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("record_name"), attr);
}