llvm/tools/mlir/include/mlir/Dialect/Transform/DebugExtension/DebugExtensionOps.cpp.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Definitions                                                             *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: DebugExtensionOps.td                                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::transform::DebugEmitParamAsRemarkOp,
::mlir::transform::DebugEmitRemarkAtOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


//===----------------------------------------------------------------------===//
// Local Utility Method Definitions
//===----------------------------------------------------------------------===//

namespace mlir {
namespace transform {

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_DebugExtensionOps0(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_DebugExtensionOps1(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_type_constraint_DebugExtensionOps2(
    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
    unsigned valueIndex) { … }

static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_DebugExtensionOps0(
    ::mlir::Attribute attr, ::llvm::StringRef attrName, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }
static ::llvm::LogicalResult __mlir_ods_local_attr_constraint_DebugExtensionOps0(
    ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) { … }
} // namespace transform
} // namespace mlir
namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::DebugEmitParamAsRemarkOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
DebugEmitParamAsRemarkOpGenericAdaptorBase::DebugEmitParamAsRemarkOpGenericAdaptorBase(DebugEmitParamAsRemarkOp op) : … { … }

std::pair<unsigned, unsigned> DebugEmitParamAsRemarkOpGenericAdaptorBase::getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { … }

::std::optional< ::llvm::StringRef > DebugEmitParamAsRemarkOpGenericAdaptorBase::getMessage() { … }

} // namespace detail
DebugEmitParamAsRemarkOpAdaptor::DebugEmitParamAsRemarkOpAdaptor(DebugEmitParamAsRemarkOp op) : … { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOpAdaptor::verify(::mlir::Location loc) { … }

std::pair<unsigned, unsigned> DebugEmitParamAsRemarkOp::getODSOperandIndexAndLength(unsigned index) { … }

::mlir::MutableOperandRange DebugEmitParamAsRemarkOp::getAnchorMutable() { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::mlir::Attribute DebugEmitParamAsRemarkOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }

llvm::hash_code DebugEmitParamAsRemarkOp::computePropertiesHash(const Properties &prop) { … }

std::optional<mlir::Attribute> DebugEmitParamAsRemarkOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }

void DebugEmitParamAsRemarkOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }

void DebugEmitParamAsRemarkOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }

void DebugEmitParamAsRemarkOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }

::std::optional< ::llvm::StringRef > DebugEmitParamAsRemarkOp::getMessage() { … }

void DebugEmitParamAsRemarkOp::setMessage(::std::optional<::llvm::StringRef> attrValue) { … }

void DebugEmitParamAsRemarkOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value param, /*optional*/::mlir::Value anchor, /*optional*/::mlir::StringAttr message) { … }

void DebugEmitParamAsRemarkOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value param, /*optional*/::mlir::Value anchor, /*optional*/::mlir::StringAttr message) { … }

void DebugEmitParamAsRemarkOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult DebugEmitParamAsRemarkOp::verifyInvariants() { … }

::mlir::ParseResult DebugEmitParamAsRemarkOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void DebugEmitParamAsRemarkOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::DebugEmitParamAsRemarkOp)

namespace mlir {
namespace transform {

//===----------------------------------------------------------------------===//
// ::mlir::transform::DebugEmitRemarkAtOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
DebugEmitRemarkAtOpGenericAdaptorBase::DebugEmitRemarkAtOpGenericAdaptorBase(DebugEmitRemarkAtOp op) : … { … }

::llvm::StringRef DebugEmitRemarkAtOpGenericAdaptorBase::getMessage() { … }

} // namespace detail
DebugEmitRemarkAtOpAdaptor::DebugEmitRemarkAtOpAdaptor(DebugEmitRemarkAtOp op) : … { … }

::llvm::LogicalResult DebugEmitRemarkAtOpAdaptor::verify(::mlir::Location loc) { … }

::llvm::LogicalResult DebugEmitRemarkAtOp::setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::mlir::Attribute DebugEmitRemarkAtOp::getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop) { … }

llvm::hash_code DebugEmitRemarkAtOp::computePropertiesHash(const Properties &prop) { … }

std::optional<mlir::Attribute> DebugEmitRemarkAtOp::getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name) { … }

void DebugEmitRemarkAtOp::setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value) { … }

void DebugEmitRemarkAtOp::populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs) { … }

::llvm::LogicalResult DebugEmitRemarkAtOp::verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) { … }

::llvm::LogicalResult DebugEmitRemarkAtOp::readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state) { … }

void DebugEmitRemarkAtOp::writeProperties(::mlir::DialectBytecodeWriter &writer) { … }

::llvm::StringRef DebugEmitRemarkAtOp::getMessage() { … }

void DebugEmitRemarkAtOp::setMessage(::llvm::StringRef attrValue) { … }

void DebugEmitRemarkAtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value at, ::mlir::StringAttr message) { … }

void DebugEmitRemarkAtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value at, ::mlir::StringAttr message) { … }

void DebugEmitRemarkAtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value at, ::llvm::StringRef message) { … }

void DebugEmitRemarkAtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value at, ::llvm::StringRef message) { … }

void DebugEmitRemarkAtOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) { … }

::llvm::LogicalResult DebugEmitRemarkAtOp::verifyInvariantsImpl() { … }

::llvm::LogicalResult DebugEmitRemarkAtOp::verifyInvariants() { … }

::mlir::ParseResult DebugEmitRemarkAtOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) { … }

void DebugEmitRemarkAtOp::print(::mlir::OpAsmPrinter &_odsPrinter) { … }

} // namespace transform
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::transform::DebugEmitRemarkAtOp)


#endif  // GET_OP_CLASSES