Ops.cpp.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Definitions                                                             *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Ops.td                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
#ifdef GET_OP_LIST
#undef GET_OP_LIST
 
::llzk::constrain::EmitContainmentOp,
::llzk::constrain::EmitEqualityOp
#endif  // GET_OP_LIST
 
#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES
 
 
//===----------------------------------------------------------------------===//
// Local Utility Method Definitions
//===----------------------------------------------------------------------===//
 
namespace llzk {
namespace constrain {
 
static ::mlir::LogicalResult __mlir_ods_local_type_constraint_Ops0(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) {
  if (!((::llvm::isa<::llzk::array::ArrayType>(type)))) {
    return op->emitOpError(valueKind) << " #" << valueIndex
        << " must be n-dimensional array, but got " << type;
  }
  return ::mlir::success();
}
 
static ::mlir::LogicalResult __mlir_ods_local_type_constraint_Ops1(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) {
  if (!((::llzk::isValidArrayElemType(type)))) {
    return op->emitOpError(valueKind) << " #" << valueIndex
        << " must be a valid array element type, but got " << type;
  }
  return ::mlir::success();
}
 
static ::mlir::LogicalResult __mlir_ods_local_type_constraint_Ops2(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) {
  if (!((::llzk::isValidEmitEqType(type)))) {
    return op->emitOpError(valueKind) << " #" << valueIndex
        << " must be any LLZK type, excluding non-Signal struct and string types, but got " << type;
  }
  return ::mlir::success();
}
} // namespace constrain
} // namespace llzk
namespace llzk {
namespace constrain {
 
//===----------------------------------------------------------------------===//
// ::llzk::constrain::EmitContainmentOp definitions
//===----------------------------------------------------------------------===//
 
namespace detail {
EmitContainmentOpGenericAdaptorBase::EmitContainmentOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const ::mlir::EmptyProperties &properties, ::mlir::RegionRange regions) : odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
    odsOpName.emplace("constrain.in", odsAttrs.getContext());
}
 
EmitContainmentOpGenericAdaptorBase::EmitContainmentOpGenericAdaptorBase(EmitContainmentOp op) : EmitContainmentOpGenericAdaptorBase(op->getAttrDictionary(), op.getProperties(), op->getRegions()) {}
 
std::pair<unsigned, unsigned> EmitContainmentOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
  return {index, 1};
}
 
::mlir::DictionaryAttr EmitContainmentOpGenericAdaptorBase::getAttributes() {
  return odsAttrs;
}
 
} // namespace detail
EmitContainmentOpAdaptor::EmitContainmentOpAdaptor(EmitContainmentOp op) : EmitContainmentOpGenericAdaptor(op->getOperands(), op) {}
 
::mlir::LogicalResult EmitContainmentOpAdaptor::verify(::mlir::Location loc) {
  return ::mlir::success();
}
 
std::pair<unsigned, unsigned> EmitContainmentOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}
 
::mlir::Operation::operand_range EmitContainmentOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}
 
::mlir::TypedValue<::llzk::array::ArrayType> EmitContainmentOp::getLhs() {
  return ::llvm::cast<::mlir::TypedValue<::llzk::array::ArrayType>>(*getODSOperands(0).begin());
}
 
::mlir::Value EmitContainmentOp::getRhs() {
  return ::llvm::cast<::mlir::Value>(*getODSOperands(1).begin());
}
 
::mlir::OpOperand &EmitContainmentOp::getLhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return getOperation()->getOpOperand(range.first);
}
 
::mlir::OpOperand &EmitContainmentOp::getRhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return getOperation()->getOpOperand(range.first);
}
 
std::pair<unsigned, unsigned> EmitContainmentOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}
 
::mlir::Operation::result_range EmitContainmentOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}
 
void EmitContainmentOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
}
 
void EmitContainmentOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}
 
void EmitContainmentOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}
 
::mlir::LogicalResult EmitContainmentOp::verifyInvariantsImpl() {
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
 
    for (auto v : valueGroup0) {
      if (::mlir::failed(__mlir_ods_local_type_constraint_Ops0(*this, v.getType(), "operand", index++)))
        return ::mlir::failure();
    }
    auto valueGroup1 = getODSOperands(1);
 
    for (auto v : valueGroup1) {
      if (::mlir::failed(__mlir_ods_local_type_constraint_Ops1(*this, v.getType(), "operand", index++)))
        return ::mlir::failure();
    }
  }
  if (!((::llzk::typesUnify(::llvm::cast<::llzk::array::ArrayType>((*this->getODSOperands(0).begin()).getType()).getElementType(), (*this->getODSOperands(1).begin()).getType()))))
    return emitOpError("failed to verify that rhs type matches with lhs element type");
  return ::mlir::success();
}
 
::mlir::LogicalResult EmitContainmentOp::verifyInvariants() {
  return verifyInvariantsImpl();
}
 
::mlir::ParseResult EmitContainmentOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
  (void)lhsOperandsLoc;
  ::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
  (void)rhsOperandsLoc;
  ::mlir::Type lhsRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> lhsTypes(lhsRawTypes);
  ::mlir::Type rhsRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> rhsTypes(rhsRawTypes);
 
  lhsOperandsLoc = parser.getCurrentLocation();
  if (parser.parseOperand(lhsRawOperands[0]))
    return ::mlir::failure();
  if (parser.parseComma())
    return ::mlir::failure();
 
  rhsOperandsLoc = parser.getCurrentLocation();
  if (parser.parseOperand(rhsRawOperands[0]))
    return ::mlir::failure();
  if (parser.parseColon())
    return ::mlir::failure();
 
  {
    ::llzk::array::ArrayType type;
    if (parser.parseCustomTypeWithFallback(type))
      return ::mlir::failure();
    lhsRawTypes[0] = type;
  }
  {
    auto odsResult = parseInferredOrParsedType(parser, rhsRawTypes[0], lhsRawTypes[0]);
    if (odsResult) return ::mlir::failure();
  }
  {
    auto loc = parser.getCurrentLocation();(void)loc;
    if (parser.parseOptionalAttrDict(result.attributes))
      return ::mlir::failure();
  }
  if (parser.resolveOperands(lhsOperands, lhsTypes, lhsOperandsLoc, result.operands))
    return ::mlir::failure();
  if (parser.resolveOperands(rhsOperands, rhsTypes, rhsOperandsLoc, result.operands))
    return ::mlir::failure();
  return ::mlir::success();
}
 
void EmitContainmentOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
  _odsPrinter << ' ';
  _odsPrinter << getLhs();
  _odsPrinter << ",";
  _odsPrinter << ' ';
  _odsPrinter << getRhs();
  _odsPrinter << ' ' << ":";
  _odsPrinter << ' ';
  {
    auto type = getLhs().getType();
    if (auto validType = ::llvm::dyn_cast<::llzk::array::ArrayType>(type))
      _odsPrinter.printStrippedAttrOrType(validType);
   else
     _odsPrinter << type;
  }
  printInferredOrParsedType(_odsPrinter, *this, getRhs().getType(), getLhs().getType());
  ::llvm::SmallVector<::llvm::StringRef, 2> elidedAttrs;
  _odsPrinter.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
}
 
} // namespace constrain
} // namespace llzk
MLIR_DEFINE_EXPLICIT_TYPE_ID(::llzk::constrain::EmitContainmentOp)
 
namespace llzk {
namespace constrain {
 
//===----------------------------------------------------------------------===//
// ::llzk::constrain::EmitEqualityOp definitions
//===----------------------------------------------------------------------===//
 
namespace detail {
EmitEqualityOpGenericAdaptorBase::EmitEqualityOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const ::mlir::EmptyProperties &properties, ::mlir::RegionRange regions) : odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
    odsOpName.emplace("constrain.eq", odsAttrs.getContext());
}
 
EmitEqualityOpGenericAdaptorBase::EmitEqualityOpGenericAdaptorBase(EmitEqualityOp op) : EmitEqualityOpGenericAdaptorBase(op->getAttrDictionary(), op.getProperties(), op->getRegions()) {}
 
std::pair<unsigned, unsigned> EmitEqualityOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
  return {index, 1};
}
 
::mlir::DictionaryAttr EmitEqualityOpGenericAdaptorBase::getAttributes() {
  return odsAttrs;
}
 
} // namespace detail
EmitEqualityOpAdaptor::EmitEqualityOpAdaptor(EmitEqualityOp op) : EmitEqualityOpGenericAdaptor(op->getOperands(), op) {}
 
::mlir::LogicalResult EmitEqualityOpAdaptor::verify(::mlir::Location loc) {
  return ::mlir::success();
}
 
std::pair<unsigned, unsigned> EmitEqualityOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}
 
::mlir::Operation::operand_range EmitEqualityOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}
 
::mlir::Value EmitEqualityOp::getLhs() {
  return ::llvm::cast<::mlir::Value>(*getODSOperands(0).begin());
}
 
::mlir::Value EmitEqualityOp::getRhs() {
  return ::llvm::cast<::mlir::Value>(*getODSOperands(1).begin());
}
 
::mlir::OpOperand &EmitEqualityOp::getLhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return getOperation()->getOpOperand(range.first);
}
 
::mlir::OpOperand &EmitEqualityOp::getRhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return getOperation()->getOpOperand(range.first);
}
 
std::pair<unsigned, unsigned> EmitEqualityOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}
 
::mlir::Operation::result_range EmitEqualityOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}
 
void EmitEqualityOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
}
 
void EmitEqualityOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}
 
void EmitEqualityOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}
 
::mlir::LogicalResult EmitEqualityOp::verifyInvariantsImpl() {
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
 
    for (auto v : valueGroup0) {
      if (::mlir::failed(__mlir_ods_local_type_constraint_Ops2(*this, v.getType(), "operand", index++)))
        return ::mlir::failure();
    }
    auto valueGroup1 = getODSOperands(1);
 
    for (auto v : valueGroup1) {
      if (::mlir::failed(__mlir_ods_local_type_constraint_Ops2(*this, v.getType(), "operand", index++)))
        return ::mlir::failure();
    }
  }
  if (!((::llzk::typesUnify((*this->getODSOperands(0).begin()).getType(), (*this->getODSOperands(1).begin()).getType()))))
    return emitOpError("failed to verify that rhs type matches with lhs type");
  return ::mlir::success();
}
 
::mlir::LogicalResult EmitEqualityOp::verifyInvariants() {
  return verifyInvariantsImpl();
}
 
::mlir::ParseResult EmitEqualityOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
  (void)lhsOperandsLoc;
  ::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
  (void)rhsOperandsLoc;
  ::mlir::Type lhsRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> lhsTypes(lhsRawTypes);
  ::mlir::Type rhsRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> rhsTypes(rhsRawTypes);
 
  lhsOperandsLoc = parser.getCurrentLocation();
  if (parser.parseOperand(lhsRawOperands[0]))
    return ::mlir::failure();
  if (parser.parseComma())
    return ::mlir::failure();
 
  rhsOperandsLoc = parser.getCurrentLocation();
  if (parser.parseOperand(rhsRawOperands[0]))
    return ::mlir::failure();
  if (parser.parseColon())
    return ::mlir::failure();
 
  {
    ::mlir::Type type;
    if (parser.parseCustomTypeWithFallback(type))
      return ::mlir::failure();
    lhsRawTypes[0] = type;
  }
  {
    auto odsResult = parseInferredOrParsedType(parser, rhsRawTypes[0], lhsRawTypes[0]);
    if (odsResult) return ::mlir::failure();
  }
  {
    auto loc = parser.getCurrentLocation();(void)loc;
    if (parser.parseOptionalAttrDict(result.attributes))
      return ::mlir::failure();
  }
  if (parser.resolveOperands(lhsOperands, lhsTypes, lhsOperandsLoc, result.operands))
    return ::mlir::failure();
  if (parser.resolveOperands(rhsOperands, rhsTypes, rhsOperandsLoc, result.operands))
    return ::mlir::failure();
  return ::mlir::success();
}
 
void EmitEqualityOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
  _odsPrinter << ' ';
  _odsPrinter << getLhs();
  _odsPrinter << ",";
  _odsPrinter << ' ';
  _odsPrinter << getRhs();
  _odsPrinter << ' ' << ":";
  _odsPrinter << ' ';
  {
    auto type = getLhs().getType();
    if (auto validType = ::llvm::dyn_cast<::mlir::Type>(type))
      _odsPrinter.printStrippedAttrOrType(validType);
   else
     _odsPrinter << type;
  }
  printInferredOrParsedType(_odsPrinter, *this, getRhs().getType(), getLhs().getType());
  ::llvm::SmallVector<::llvm::StringRef, 2> elidedAttrs;
  _odsPrinter.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
}
 
} // namespace constrain
} // namespace llzk
MLIR_DEFINE_EXPLICIT_TYPE_ID(::llzk::constrain::EmitEqualityOp)
 
 
#endif  // GET_OP_CLASSES