Polynomial.cpp.inc | Explore in Territory

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

#ifdef GET_OP_LIST
#undef GET_OP_LIST

::mlir::polynomial::AddOp,
::mlir::polynomial::ConstantOp,
::mlir::polynomial::FromTensorOp,
::mlir::polynomial::INTTOp,
::mlir::polynomial::LeadingTermOp,
::mlir::polynomial::MonicMonomialMulOp,
::mlir::polynomial::MonomialOp,
::mlir::polynomial::MulOp,
::mlir::polynomial::MulScalarOp,
::mlir::polynomial::NTTOp,
::mlir::polynomial::SubOp,
::mlir::polynomial::ToTensorOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


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

namespace mlir {
namespace polynomial {

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::AddOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
AddOpAdaptor::AddOpAdaptor(AddOp op) : … { … }

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

void AddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void AddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void AddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) { … }

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

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

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

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

::llvm::LogicalResult AddOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) { … }

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

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

void AddOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::AddOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::ConstantOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
ConstantOpGenericAdaptorBase::ConstantOpGenericAdaptorBase(ConstantOp op) : … { … }

::mlir::Attribute ConstantOpGenericAdaptorBase::getValue() { … }

} // namespace detail
ConstantOpAdaptor::ConstantOpAdaptor(ConstantOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::mlir::Attribute ConstantOp::getValue() { … }

void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Attribute value) { … }

void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Attribute value) { … }

void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Attribute value) { … }

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

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

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

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

void ConstantOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

::llvm::LogicalResult
ConstantOp::inferReturnTypes(::mlir::MLIRContext *context,
                  std::optional<::mlir::Location> location,
                  ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
                  ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions,
                  ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::ConstantOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::FromTensorOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
FromTensorOpAdaptor::FromTensorOpAdaptor(FromTensorOp op) : … { … }

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

void FromTensorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value input) { … }

void FromTensorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input) { … }

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

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

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

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

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

void FromTensorOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::FromTensorOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::INTTOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
INTTOpGenericAdaptorBase::INTTOpGenericAdaptorBase(INTTOp op) : … { … }

::std::optional<::mlir::polynomial::PrimitiveRootAttr> INTTOpGenericAdaptorBase::getRoot() { … }

} // namespace detail
INTTOpAdaptor::INTTOpAdaptor(INTTOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::polynomial::PrimitiveRootAttr> INTTOp::getRoot() { … }

void INTTOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value input, /*optional*/::mlir::polynomial::PrimitiveRootAttr root) { … }

void INTTOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, /*optional*/::mlir::polynomial::PrimitiveRootAttr root) { … }

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

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

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

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

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

void INTTOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::INTTOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::LeadingTermOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
LeadingTermOpAdaptor::LeadingTermOpAdaptor(LeadingTermOp op) : … { … }

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

void LeadingTermOp::getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn) { … }

void LeadingTermOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type degree, ::mlir::Type coefficient, ::mlir::Value input) { … }

void LeadingTermOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input) { … }

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

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

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

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

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

void LeadingTermOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::LeadingTermOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::MonicMonomialMulOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MonicMonomialMulOpAdaptor::MonicMonomialMulOpAdaptor(MonicMonomialMulOp op) : … { … }

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

void MonicMonomialMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value input, ::mlir::Value monomialDegree) { … }

void MonicMonomialMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value input, ::mlir::Value monomialDegree) { … }

void MonicMonomialMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value monomialDegree) { … }

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

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

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

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

::llvm::LogicalResult MonicMonomialMulOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) { … }

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

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

void MonicMonomialMulOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::MonicMonomialMulOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::MonomialOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MonomialOpAdaptor::MonomialOpAdaptor(MonomialOp op) : … { … }

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

void MonomialOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value coefficient, ::mlir::Value degree) { … }

void MonomialOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value coefficient, ::mlir::Value degree) { … }

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

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

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

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

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

void MonomialOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::MonomialOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::MulOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MulOpAdaptor::MulOpAdaptor(MulOp op) : … { … }

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

void MulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void MulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void MulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) { … }

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

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

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

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

::llvm::LogicalResult MulOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) { … }

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

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

void MulOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::MulOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::MulScalarOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
MulScalarOpAdaptor::MulScalarOpAdaptor(MulScalarOp op) : … { … }

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

void MulScalarOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value polynomial, ::mlir::Value scalar) { … }

void MulScalarOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value polynomial, ::mlir::Value scalar) { … }

void MulScalarOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value polynomial, ::mlir::Value scalar) { … }

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

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

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

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

::llvm::LogicalResult MulScalarOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) { … }

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

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

void MulScalarOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::MulScalarOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::NTTOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
NTTOpGenericAdaptorBase::NTTOpGenericAdaptorBase(NTTOp op) : … { … }

::std::optional<::mlir::polynomial::PrimitiveRootAttr> NTTOpGenericAdaptorBase::getRoot() { … }

} // namespace detail
NTTOpAdaptor::NTTOpAdaptor(NTTOp op) : … { … }

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

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

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

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

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

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

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

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

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

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

::std::optional<::mlir::polynomial::PrimitiveRootAttr> NTTOp::getRoot() { … }

void NTTOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value input, /*optional*/::mlir::polynomial::PrimitiveRootAttr root) { … }

void NTTOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, /*optional*/::mlir::polynomial::PrimitiveRootAttr root) { … }

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

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

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

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

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

void NTTOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::NTTOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::SubOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
SubOpAdaptor::SubOpAdaptor(SubOp op) : … { … }

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

void SubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void SubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) { … }

void SubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) { … }

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

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

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

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

::llvm::LogicalResult SubOp::inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) { … }

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

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

void SubOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::SubOp)

namespace mlir {
namespace polynomial {

//===----------------------------------------------------------------------===//
// ::mlir::polynomial::ToTensorOp definitions
//===----------------------------------------------------------------------===//

namespace detail {
} // namespace detail
ToTensorOpAdaptor::ToTensorOpAdaptor(ToTensorOp op) : … { … }

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

void ToTensorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type output, ::mlir::Value input) { … }

void ToTensorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input) { … }

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

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

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

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

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

void ToTensorOp::getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) { … }

} // namespace polynomial
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::polynomial::ToTensorOp)


#endif  // GET_OP_CLASSES
llvm/tools/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.cpp.inc
