549 lines
30 KiB
C++
549 lines
30 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Interface Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir {
|
|
|
|
/// An operation that has argument and result attributes. This interface
|
|
/// provides functions to access and modify the argument and result
|
|
/// attributes of the operation.
|
|
class ArgAndResultAttrsOpInterface;
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// A call-like operation is one that transfers control from one sub-routine to
|
|
/// another. These operations may be traditional direct calls `call @foo`, or
|
|
/// indirect calls to other operations `call_indirect %foo`. An operation that
|
|
/// uses this interface, must *not* also provide the `CallableOpInterface`.
|
|
class CallOpInterface;
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// A callable operation is one who represents a potential sub-routine, and may
|
|
/// be a target for a call-like operation (those providing the CallOpInterface
|
|
/// above). These operations may be traditional functional operation
|
|
/// `func @foo(...)`, as well as function producing operations
|
|
/// `%foo = dialect.create_function(...)`. These operations may only contain a
|
|
/// single region, or subroutine.
|
|
class CallableOpInterface;
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// An operation that has argument and result attributes. This interface
|
|
/// provides functions to access and modify the argument and result
|
|
/// attributes of the operation.
|
|
namespace detail {
|
|
struct ArgAndResultAttrsOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::ArrayAttr (*getArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
|
|
::mlir::ArrayAttr (*getResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
|
|
void (*setArgAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
|
|
void (*setResAttrsAttr)(const Concept *impl, ::mlir::Operation *, ::mlir::ArrayAttr);
|
|
::mlir::Attribute (*removeArgAttrsAttr)(const Concept *impl, ::mlir::Operation *);
|
|
::mlir::Attribute (*removeResAttrsAttr)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::ArgAndResultAttrsOpInterface;
|
|
Model() : Concept{getArgAttrsAttr, getResAttrsAttr, setArgAttrsAttr, setResAttrsAttr, removeArgAttrsAttr, removeResAttrsAttr} {}
|
|
|
|
static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
|
|
static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
|
|
static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::ArgAndResultAttrsOpInterface;
|
|
FallbackModel() : Concept{getArgAttrsAttr, getResAttrsAttr, setArgAttrsAttr, setResAttrsAttr, removeArgAttrsAttr, removeResAttrsAttr} {}
|
|
|
|
static inline ::mlir::ArrayAttr getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::ArrayAttr getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline void setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
|
|
static inline void setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs);
|
|
static inline ::mlir::Attribute removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Attribute removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteOp;
|
|
};
|
|
};
|
|
template <typename ConcreteOp>
|
|
struct ArgAndResultAttrsOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class ArgAndResultAttrsOpInterface : public ::mlir::OpInterface<ArgAndResultAttrsOpInterface, detail::ArgAndResultAttrsOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<ArgAndResultAttrsOpInterface, detail::ArgAndResultAttrsOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::ArgAndResultAttrsOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get the array of argument attribute dictionaries. The method should
|
|
/// return an array attribute containing only dictionary attributes equal in
|
|
/// number to the number of arguments. Alternatively, the method can
|
|
/// return null to indicate that there are no argument attributes.
|
|
::mlir::ArrayAttr getArgAttrsAttr();
|
|
|
|
/// Get the array of result attribute dictionaries. The method should return
|
|
/// an array attribute containing only dictionary attributes equal in number
|
|
/// to the number of results. Alternatively, the method can return
|
|
/// null to indicate that there are no result attributes.
|
|
::mlir::ArrayAttr getResAttrsAttr();
|
|
|
|
/// Set the array of argument attribute dictionaries.
|
|
void setArgAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Set the array of result attribute dictionaries.
|
|
void setResAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Remove the array of argument attribute dictionaries. This is the same as
|
|
/// setting all argument attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeArgAttrsAttr();
|
|
|
|
/// Remove the array of result attribute dictionaries. This is the same as
|
|
/// setting all result attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeResAttrsAttr();
|
|
};
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// A call-like operation is one that transfers control from one sub-routine to
|
|
/// another. These operations may be traditional direct calls `call @foo`, or
|
|
/// indirect calls to other operations `call_indirect %foo`. An operation that
|
|
/// uses this interface, must *not* also provide the `CallableOpInterface`.
|
|
namespace detail {
|
|
struct CallOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::CallInterfaceCallable (*getCallableForCallee)(const Concept *impl, ::mlir::Operation *);
|
|
void (*setCalleeFromCallable)(const Concept *impl, ::mlir::Operation *, ::mlir::CallInterfaceCallable);
|
|
::mlir::Operation::operand_range (*getArgOperands)(const Concept *impl, ::mlir::Operation *);
|
|
::mlir::MutableOperandRange (*getArgOperandsMutable)(const Concept *impl, ::mlir::Operation *);
|
|
::mlir::Operation *(*resolveCallableInTable)(const Concept *impl, ::mlir::Operation *, ::mlir::SymbolTableCollection *);
|
|
::mlir::Operation *(*resolveCallable)(const Concept *impl, ::mlir::Operation *);
|
|
/// The base classes of this interface.
|
|
const ::mlir::ArgAndResultAttrsOpInterface::Concept *implArgAndResultAttrsOpInterface = nullptr;
|
|
|
|
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
|
|
implArgAndResultAttrsOpInterface = interfaceMap.lookup<::mlir::ArgAndResultAttrsOpInterface>();
|
|
assert(implArgAndResultAttrsOpInterface && "`::mlir::CallOpInterface` expected its base interface `::mlir::ArgAndResultAttrsOpInterface` to be registered");
|
|
}
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::CallOpInterface;
|
|
Model() : Concept{getCallableForCallee, setCalleeFromCallable, getArgOperands, getArgOperandsMutable, resolveCallableInTable, resolveCallable} {}
|
|
|
|
static inline ::mlir::CallInterfaceCallable getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline void setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee);
|
|
static inline ::mlir::Operation::operand_range getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::MutableOperandRange getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Operation *resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable);
|
|
static inline ::mlir::Operation *resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::CallOpInterface;
|
|
FallbackModel() : Concept{getCallableForCallee, setCalleeFromCallable, getArgOperands, getArgOperandsMutable, resolveCallableInTable, resolveCallable} {}
|
|
|
|
static inline ::mlir::CallInterfaceCallable getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline void setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee);
|
|
static inline ::mlir::Operation::operand_range getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::MutableOperandRange getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Operation *resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable);
|
|
static inline ::mlir::Operation *resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteOp;
|
|
::mlir::Operation *resolveCallableInTable(::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection *symbolTable) const;
|
|
::mlir::Operation *resolveCallable(::mlir::Operation *tablegen_opaque_val) const;
|
|
};
|
|
};
|
|
template <typename ConcreteOp>
|
|
struct CallOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class CallOpInterface : public ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::CallOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Returns the callee of this call-like operation. A `callee` is either a
|
|
/// reference to a symbol, via SymbolRefAttr, or a reference to a defined
|
|
/// SSA value. If the reference is an SSA value, the SSA value corresponds
|
|
/// to a region of a lambda-like operation.
|
|
::mlir::CallInterfaceCallable getCallableForCallee();
|
|
|
|
/// Sets the callee of this call-like operation. A `callee` is either a
|
|
/// reference to a symbol, via SymbolRefAttr, or a reference to a defined
|
|
/// SSA value. The type of the `callee` is expected to be the same as the
|
|
/// return type of `getCallableForCallee`, e.g., `callee` should be
|
|
/// SymbolRefAttr for `func.call`.
|
|
void setCalleeFromCallable(::mlir::CallInterfaceCallable callee);
|
|
|
|
/// Returns the operands within this call that are used as arguments to the
|
|
/// callee.
|
|
::mlir::Operation::operand_range getArgOperands();
|
|
|
|
/// Returns the operands within this call that are used as arguments to the
|
|
/// callee as a mutable range.
|
|
::mlir::MutableOperandRange getArgOperandsMutable();
|
|
|
|
/// Resolve the callable operation for given callee to a
|
|
/// CallableOpInterface, or nullptr if a valid callable was not resolved.
|
|
/// `symbolTable` parameter allow for using a cached symbol table for symbol
|
|
/// lookups instead of performing an O(N) scan.
|
|
::mlir::Operation *resolveCallableInTable(::mlir::SymbolTableCollection * symbolTable);
|
|
|
|
/// Resolve the callable operation for given callee to a
|
|
/// CallableOpInterface, or nullptr if a valid callable was not resolved.
|
|
::mlir::Operation *resolveCallable();
|
|
//===----------------------------------------------------------------===//
|
|
// Inherited from ::mlir::ArgAndResultAttrsOpInterface
|
|
//===----------------------------------------------------------------===//
|
|
|
|
operator ::mlir::ArgAndResultAttrsOpInterface () const {
|
|
if (!*this) return nullptr;
|
|
return ::mlir::ArgAndResultAttrsOpInterface(*this, getImpl()->implArgAndResultAttrsOpInterface);
|
|
}
|
|
|
|
|
|
/// Get the array of argument attribute dictionaries. The method should
|
|
/// return an array attribute containing only dictionary attributes equal in
|
|
/// number to the number of arguments. Alternatively, the method can
|
|
/// return null to indicate that there are no argument attributes.
|
|
::mlir::ArrayAttr getArgAttrsAttr();
|
|
|
|
/// Get the array of result attribute dictionaries. The method should return
|
|
/// an array attribute containing only dictionary attributes equal in number
|
|
/// to the number of results. Alternatively, the method can return
|
|
/// null to indicate that there are no result attributes.
|
|
::mlir::ArrayAttr getResAttrsAttr();
|
|
|
|
/// Set the array of argument attribute dictionaries.
|
|
void setArgAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Set the array of result attribute dictionaries.
|
|
void setResAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Remove the array of argument attribute dictionaries. This is the same as
|
|
/// setting all argument attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeArgAttrsAttr();
|
|
|
|
/// Remove the array of result attribute dictionaries. This is the same as
|
|
/// setting all result attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeResAttrsAttr();
|
|
};
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
/// A callable operation is one who represents a potential sub-routine, and may
|
|
/// be a target for a call-like operation (those providing the CallOpInterface
|
|
/// above). These operations may be traditional functional operation
|
|
/// `func @foo(...)`, as well as function producing operations
|
|
/// `%foo = dialect.create_function(...)`. These operations may only contain a
|
|
/// single region, or subroutine.
|
|
namespace detail {
|
|
struct CallableOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::Region *(*getCallableRegion)(const Concept *impl, ::mlir::Operation *);
|
|
::llvm::ArrayRef<::mlir::Type> (*getArgumentTypes)(const Concept *impl, ::mlir::Operation *);
|
|
::llvm::ArrayRef<::mlir::Type> (*getResultTypes)(const Concept *impl, ::mlir::Operation *);
|
|
/// The base classes of this interface.
|
|
const ::mlir::ArgAndResultAttrsOpInterface::Concept *implArgAndResultAttrsOpInterface = nullptr;
|
|
|
|
void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
|
|
implArgAndResultAttrsOpInterface = interfaceMap.lookup<::mlir::ArgAndResultAttrsOpInterface>();
|
|
assert(implArgAndResultAttrsOpInterface && "`::mlir::CallableOpInterface` expected its base interface `::mlir::ArgAndResultAttrsOpInterface` to be registered");
|
|
}
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::CallableOpInterface;
|
|
Model() : Concept{getCallableRegion, getArgumentTypes, getResultTypes} {}
|
|
|
|
static inline ::mlir::Region *getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::llvm::ArrayRef<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::llvm::ArrayRef<::mlir::Type> getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::CallableOpInterface;
|
|
FallbackModel() : Concept{getCallableRegion, getArgumentTypes, getResultTypes} {}
|
|
|
|
static inline ::mlir::Region *getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::llvm::ArrayRef<::mlir::Type> getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::llvm::ArrayRef<::mlir::Type> getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteOp;
|
|
};
|
|
};
|
|
template <typename ConcreteOp>
|
|
struct CallableOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class CallableOpInterface : public ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::CallableOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Returns the region on the current operation that is callable. This may
|
|
/// return null in the case of an external callable object, e.g. an external
|
|
/// function.
|
|
::mlir::Region *getCallableRegion();
|
|
|
|
/// Returns the callable's argument types based exclusively on the type (to
|
|
/// allow for this method may be called on function declarations).
|
|
::llvm::ArrayRef<::mlir::Type> getArgumentTypes();
|
|
|
|
/// Returns the callable's result types based exclusively on the type (to
|
|
/// allow for this method may be called on function declarations).
|
|
::llvm::ArrayRef<::mlir::Type> getResultTypes();
|
|
//===----------------------------------------------------------------===//
|
|
// Inherited from ::mlir::ArgAndResultAttrsOpInterface
|
|
//===----------------------------------------------------------------===//
|
|
|
|
operator ::mlir::ArgAndResultAttrsOpInterface () const {
|
|
if (!*this) return nullptr;
|
|
return ::mlir::ArgAndResultAttrsOpInterface(*this, getImpl()->implArgAndResultAttrsOpInterface);
|
|
}
|
|
|
|
|
|
/// Get the array of argument attribute dictionaries. The method should
|
|
/// return an array attribute containing only dictionary attributes equal in
|
|
/// number to the number of arguments. Alternatively, the method can
|
|
/// return null to indicate that there are no argument attributes.
|
|
::mlir::ArrayAttr getArgAttrsAttr();
|
|
|
|
/// Get the array of result attribute dictionaries. The method should return
|
|
/// an array attribute containing only dictionary attributes equal in number
|
|
/// to the number of results. Alternatively, the method can return
|
|
/// null to indicate that there are no result attributes.
|
|
::mlir::ArrayAttr getResAttrsAttr();
|
|
|
|
/// Set the array of argument attribute dictionaries.
|
|
void setArgAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Set the array of result attribute dictionaries.
|
|
void setResAttrsAttr(::mlir::ArrayAttr attrs);
|
|
|
|
/// Remove the array of argument attribute dictionaries. This is the same as
|
|
/// setting all argument attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeArgAttrsAttr();
|
|
|
|
/// Remove the array of result attribute dictionaries. This is the same as
|
|
/// setting all result attributes to an empty dictionary. The method should
|
|
/// return the removed attribute.
|
|
::mlir::Attribute removeResAttrsAttr();
|
|
};
|
|
|
|
} // namespace mlir
|
|
namespace mlir::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct ArgAndResultAttrsOpInterfaceTrait : public ::mlir::OpInterface<ArgAndResultAttrsOpInterface, detail::ArgAndResultAttrsOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::detail
|
|
namespace mlir::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct CallOpInterfaceTrait : public ::mlir::OpInterface<CallOpInterface, detail::CallOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
|
|
/// Resolve the callable operation for given callee to a
|
|
/// CallableOpInterface, or nullptr if a valid callable was not resolved.
|
|
/// `symbolTable` parameter allow for using a cached symbol table for symbol
|
|
/// lookups instead of performing an O(N) scan.
|
|
::mlir::Operation *resolveCallableInTable(::mlir::SymbolTableCollection * symbolTable) {
|
|
return ::mlir::call_interface_impl::resolveCallable((*static_cast<ConcreteOp *>(this)), symbolTable);
|
|
}
|
|
|
|
/// Resolve the callable operation for given callee to a
|
|
/// CallableOpInterface, or nullptr if a valid callable was not resolved.
|
|
::mlir::Operation *resolveCallable() {
|
|
return ::mlir::call_interface_impl::resolveCallable((*static_cast<ConcreteOp *>(this)));
|
|
}
|
|
};
|
|
|
|
} // namespace mlir::detail
|
|
namespace mlir::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct CallableOpInterfaceTrait : public ::mlir::OpInterface<CallableOpInterface, detail::CallableOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::detail
|
|
namespace mlir {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::ArrayAttr detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgAttrsAttr();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::ArrayAttr detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getResAttrsAttr();
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setArgAttrsAttr(attrs);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setResAttrsAttr(attrs);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Attribute detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeArgAttrsAttr();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Attribute detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::Model<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).removeResAttrsAttr();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::ArrayAttr detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getArgAttrsAttr(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::ArrayAttr detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getResAttrsAttr(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
|
|
return static_cast<const ConcreteOp *>(impl)->setArgAttrsAttr(tablegen_opaque_val, attrs);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::ArrayAttr attrs) {
|
|
return static_cast<const ConcreteOp *>(impl)->setResAttrsAttr(tablegen_opaque_val, attrs);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Attribute detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeArgAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->removeArgAttrsAttr(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Attribute detail::ArgAndResultAttrsOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::removeResAttrsAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->removeResAttrsAttr(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::CallInterfaceCallable detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCallableForCallee();
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setCalleeFromCallable(callee);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation::operand_range detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgOperands();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::MutableOperandRange detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgOperandsMutable();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).resolveCallableInTable(symbolTable);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::Model<ConcreteOp>::resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).resolveCallable();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::CallInterfaceCallable detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCallableForCallee(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getCallableForCallee(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setCalleeFromCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::CallInterfaceCallable callee) {
|
|
return static_cast<const ConcreteOp *>(impl)->setCalleeFromCallable(tablegen_opaque_val, callee);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation::operand_range detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgOperands(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getArgOperands(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::MutableOperandRange detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgOperandsMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getArgOperandsMutable(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::resolveCallableInTable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection * symbolTable) {
|
|
return static_cast<const ConcreteOp *>(impl)->resolveCallableInTable(tablegen_opaque_val, symbolTable);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::resolveCallable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->resolveCallable(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::resolveCallableInTable(::mlir::Operation *tablegen_opaque_val, ::mlir::SymbolTableCollection *symbolTable) const {
|
|
return ::mlir::call_interface_impl::resolveCallable((llvm::cast<ConcreteOp>(tablegen_opaque_val)), symbolTable);
|
|
}
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
::mlir::Operation *detail::CallOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::resolveCallable(::mlir::Operation *tablegen_opaque_val) const {
|
|
return ::mlir::call_interface_impl::resolveCallable((llvm::cast<ConcreteOp>(tablegen_opaque_val)));
|
|
}
|
|
|
|
} // namespace mlir
|
|
namespace mlir {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::Region *detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCallableRegion();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArgumentTypes();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getResultTypes();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Region *detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCallableRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getCallableRegion(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArgumentTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getArgumentTypes(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::llvm::ArrayRef<::mlir::Type> detail::CallableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getResultTypes(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getResultTypes(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir
|