610 lines
26 KiB
C++
610 lines
26 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Interface Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for compute and loop construct operations.
|
|
class ComputeRegionOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that access a partial entity such as
|
|
/// field or array element access.
|
|
class PartialEntityAccessOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that compute the address of a global variable
|
|
/// or symbol.
|
|
class AddressOfGlobalOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that define global variables. This interface
|
|
/// provides a uniform way to query properties of global variables across
|
|
/// different dialects.
|
|
class GlobalVariableOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that indirectly access global symbols.
|
|
/// This interface provides a way to query which global symbols are referenced
|
|
/// by an operation, which is useful for tracking dependencies and performing
|
|
/// analysis on global variable usage.
|
|
///
|
|
/// The symbolTable parameter is optional. If null, implementations will look up
|
|
/// their own symbol table. This allows callers to pass a pre-existing symbol
|
|
/// table for efficiency when querying multiple operations.
|
|
class IndirectGlobalAccessOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that are candidates for rematerialization
|
|
/// during outlining. These operations produce synthetic types or values
|
|
/// that cannot be passed as arguments to outlined regions and must be
|
|
/// rematerialized inside the region instead.
|
|
///
|
|
/// Operations implementing this interface are expected to be memory effect
|
|
/// free. Their results are typically used for type construction or providing
|
|
/// metadata (such as shape information for arrays).
|
|
///
|
|
/// `isRematerializationCandidate` refines whether a particular operation
|
|
/// instance participates in rematerialization; `isa<OutlineRematerializationOpInterface>`
|
|
/// requires both a registered model and this predicate.
|
|
class OutlineRematerializationOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations whose regions are targets for offloading
|
|
/// and outlining. Operations implementing this interface indicate that
|
|
/// their regions will be extracted and compiled separately (e.g., as
|
|
/// device kernels or outlined functions).
|
|
class OffloadRegionOpInterface;
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for compute and loop construct operations.
|
|
namespace detail {
|
|
struct ComputeRegionOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::Block*(*getAllocaBlock)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::ComputeRegionOpInterface;
|
|
Model() : Concept{getAllocaBlock} {}
|
|
|
|
static inline ::mlir::Block*getAllocaBlock(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::ComputeRegionOpInterface;
|
|
FallbackModel() : Concept{getAllocaBlock} {}
|
|
|
|
static inline ::mlir::Block*getAllocaBlock(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 ComputeRegionOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class ComputeRegionOpInterface : public ::mlir::OpInterface<ComputeRegionOpInterface, detail::ComputeRegionOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<ComputeRegionOpInterface, detail::ComputeRegionOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::ComputeRegionOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get alloca block
|
|
::mlir::Block*getAllocaBlock();
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that access a partial entity such as
|
|
/// field or array element access.
|
|
namespace detail {
|
|
struct PartialEntityAccessOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::Value (*getBaseEntity)(const Concept *impl, ::mlir::Operation *);
|
|
bool (*isCompleteView)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::PartialEntityAccessOpInterface;
|
|
Model() : Concept{getBaseEntity, isCompleteView} {}
|
|
|
|
static inline ::mlir::Value getBaseEntity(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline bool isCompleteView(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::PartialEntityAccessOpInterface;
|
|
FallbackModel() : Concept{getBaseEntity, isCompleteView} {}
|
|
|
|
static inline ::mlir::Value getBaseEntity(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline bool isCompleteView(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 PartialEntityAccessOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class PartialEntityAccessOpInterface : public ::mlir::OpInterface<PartialEntityAccessOpInterface, detail::PartialEntityAccessOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<PartialEntityAccessOpInterface, detail::PartialEntityAccessOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::PartialEntityAccessOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get the base entity being accessed
|
|
::mlir::Value getBaseEntity();
|
|
|
|
/// Check if this is a complete view of the entity
|
|
bool isCompleteView();
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that compute the address of a global variable
|
|
/// or symbol.
|
|
namespace detail {
|
|
struct AddressOfGlobalOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::SymbolRefAttr (*getSymbol)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::AddressOfGlobalOpInterface;
|
|
Model() : Concept{getSymbol} {}
|
|
|
|
static inline ::mlir::SymbolRefAttr getSymbol(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::AddressOfGlobalOpInterface;
|
|
FallbackModel() : Concept{getSymbol} {}
|
|
|
|
static inline ::mlir::SymbolRefAttr getSymbol(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 AddressOfGlobalOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class AddressOfGlobalOpInterface : public ::mlir::OpInterface<AddressOfGlobalOpInterface, detail::AddressOfGlobalOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<AddressOfGlobalOpInterface, detail::AddressOfGlobalOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::AddressOfGlobalOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get the symbol reference to the global
|
|
::mlir::SymbolRefAttr getSymbol();
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that define global variables. This interface
|
|
/// provides a uniform way to query properties of global variables across
|
|
/// different dialects.
|
|
namespace detail {
|
|
struct GlobalVariableOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
bool (*isConstant)(const Concept *impl, ::mlir::Operation *);
|
|
::mlir::Region*(*getInitRegion)(const Concept *impl, ::mlir::Operation *);
|
|
bool (*isDeviceData)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::GlobalVariableOpInterface;
|
|
Model() : Concept{isConstant, getInitRegion, isDeviceData} {}
|
|
|
|
static inline bool isConstant(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Region*getInitRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline bool isDeviceData(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::GlobalVariableOpInterface;
|
|
FallbackModel() : Concept{isConstant, getInitRegion, isDeviceData} {}
|
|
|
|
static inline bool isConstant(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline ::mlir::Region*getInitRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
static inline bool isDeviceData(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 GlobalVariableOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class GlobalVariableOpInterface : public ::mlir::OpInterface<GlobalVariableOpInterface, detail::GlobalVariableOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<GlobalVariableOpInterface, detail::GlobalVariableOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::GlobalVariableOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Check if the global variable is constant
|
|
bool isConstant();
|
|
|
|
/// Get the initialization region (returns nullptr if none)
|
|
::mlir::Region*getInitRegion();
|
|
|
|
/// Check if the global variable is device data
|
|
bool isDeviceData();
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that indirectly access global symbols.
|
|
/// This interface provides a way to query which global symbols are referenced
|
|
/// by an operation, which is useful for tracking dependencies and performing
|
|
/// analysis on global variable usage.
|
|
///
|
|
/// The symbolTable parameter is optional. If null, implementations will look up
|
|
/// their own symbol table. This allows callers to pass a pre-existing symbol
|
|
/// table for efficiency when querying multiple operations.
|
|
namespace detail {
|
|
struct IndirectGlobalAccessOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
void (*getReferencedSymbols)(const Concept *impl, ::mlir::Operation *, ::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>&, ::mlir::SymbolTable *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::IndirectGlobalAccessOpInterface;
|
|
Model() : Concept{getReferencedSymbols} {}
|
|
|
|
static inline void getReferencedSymbols(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>& symbols, ::mlir::SymbolTable * symbolTable);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::IndirectGlobalAccessOpInterface;
|
|
FallbackModel() : Concept{getReferencedSymbols} {}
|
|
|
|
static inline void getReferencedSymbols(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>& symbols, ::mlir::SymbolTable * symbolTable);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteOp;
|
|
};
|
|
};
|
|
template <typename ConcreteOp>
|
|
struct IndirectGlobalAccessOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class IndirectGlobalAccessOpInterface : public ::mlir::OpInterface<IndirectGlobalAccessOpInterface, detail::IndirectGlobalAccessOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<IndirectGlobalAccessOpInterface, detail::IndirectGlobalAccessOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::IndirectGlobalAccessOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get the symbols referenced by this operation
|
|
void getReferencedSymbols(::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>& symbols, ::mlir::SymbolTable * symbolTable);
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations that are candidates for rematerialization
|
|
/// during outlining. These operations produce synthetic types or values
|
|
/// that cannot be passed as arguments to outlined regions and must be
|
|
/// rematerialized inside the region instead.
|
|
///
|
|
/// Operations implementing this interface are expected to be memory effect
|
|
/// free. Their results are typically used for type construction or providing
|
|
/// metadata (such as shape information for arrays).
|
|
///
|
|
/// `isRematerializationCandidate` refines whether a particular operation
|
|
/// instance participates in rematerialization; `isa<OutlineRematerializationOpInterface>`
|
|
/// requires both a registered model and this predicate.
|
|
namespace detail {
|
|
struct OutlineRematerializationOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
bool (*isRematerializationCandidate)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::OutlineRematerializationOpInterface;
|
|
Model() : Concept{isRematerializationCandidate} {}
|
|
|
|
static inline bool isRematerializationCandidate(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::OutlineRematerializationOpInterface;
|
|
FallbackModel() : Concept{isRematerializationCandidate} {}
|
|
|
|
static inline bool isRematerializationCandidate(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 OutlineRematerializationOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class OutlineRematerializationOpInterface : public ::mlir::OpInterface<OutlineRematerializationOpInterface, detail::OutlineRematerializationOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<OutlineRematerializationOpInterface, detail::OutlineRematerializationOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::OutlineRematerializationOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Returns whether this operation instance should be treated as an outline rematerialization candidate.
|
|
bool isRematerializationCandidate();
|
|
static bool classof(::mlir::Operation * base) {
|
|
auto* interface = getInterfaceFor(base);
|
|
if (!interface)
|
|
return false;
|
|
OutlineRematerializationOpInterface odsInterfaceInstance(base, interface);
|
|
return odsInterfaceInstance.isRematerializationCandidate();
|
|
}
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
/// An interface for operations whose regions are targets for offloading
|
|
/// and outlining. Operations implementing this interface indicate that
|
|
/// their regions will be extracted and compiled separately (e.g., as
|
|
/// device kernels or outlined functions).
|
|
namespace detail {
|
|
struct OffloadRegionOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
::mlir::Region&(*getOffloadRegion)(const Concept *impl, ::mlir::Operation *);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::OffloadRegionOpInterface;
|
|
Model() : Concept{getOffloadRegion} {}
|
|
|
|
static inline ::mlir::Region&getOffloadRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::acc::OffloadRegionOpInterface;
|
|
FallbackModel() : Concept{getOffloadRegion} {}
|
|
|
|
static inline ::mlir::Region&getOffloadRegion(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 OffloadRegionOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class OffloadRegionOpInterface : public ::mlir::OpInterface<OffloadRegionOpInterface, detail::OffloadRegionOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<OffloadRegionOpInterface, detail::OffloadRegionOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::OffloadRegionOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Get the offload region
|
|
::mlir::Region&getOffloadRegion();
|
|
};
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct ComputeRegionOpInterfaceTrait : public ::mlir::OpInterface<ComputeRegionOpInterface, detail::ComputeRegionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct PartialEntityAccessOpInterfaceTrait : public ::mlir::OpInterface<PartialEntityAccessOpInterface, detail::PartialEntityAccessOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct AddressOfGlobalOpInterfaceTrait : public ::mlir::OpInterface<AddressOfGlobalOpInterface, detail::AddressOfGlobalOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct GlobalVariableOpInterfaceTrait : public ::mlir::OpInterface<GlobalVariableOpInterface, detail::GlobalVariableOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct IndirectGlobalAccessOpInterfaceTrait : public ::mlir::OpInterface<IndirectGlobalAccessOpInterface, detail::IndirectGlobalAccessOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct OutlineRematerializationOpInterfaceTrait : public ::mlir::OpInterface<OutlineRematerializationOpInterface, detail::OutlineRematerializationOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
static ::llvm::LogicalResult verifyTrait(::mlir::Operation *op) {
|
|
if (!::mlir::isMemoryEffectFree(op))
|
|
return op->emitOpError("must be memory effect free");
|
|
return ::mlir::success();
|
|
}
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct OffloadRegionOpInterfaceTrait : public ::mlir::OpInterface<OffloadRegionOpInterface, detail::OffloadRegionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
};
|
|
|
|
} // namespace mlir::acc::detail
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::Block*detail::ComputeRegionOpInterfaceInterfaceTraits::Model<ConcreteOp>::getAllocaBlock(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return &(llvm::cast<ConcreteOp>(tablegen_opaque_val)).getRegion().front();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Block*detail::ComputeRegionOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getAllocaBlock(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getAllocaBlock(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::Value detail::PartialEntityAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::getBaseEntity(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getBaseEntity();
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::PartialEntityAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::isCompleteView(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return false;
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Value detail::PartialEntityAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getBaseEntity(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getBaseEntity(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::PartialEntityAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isCompleteView(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->isCompleteView(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::SymbolRefAttr detail::AddressOfGlobalOpInterfaceInterfaceTraits::Model<ConcreteOp>::getSymbol(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getSymbol();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::SymbolRefAttr detail::AddressOfGlobalOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getSymbol(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getSymbol(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
bool detail::GlobalVariableOpInterfaceInterfaceTraits::Model<ConcreteOp>::isConstant(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return false;
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Region*detail::GlobalVariableOpInterfaceInterfaceTraits::Model<ConcreteOp>::getInitRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getInitRegion();
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::GlobalVariableOpInterfaceInterfaceTraits::Model<ConcreteOp>::isDeviceData(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return false;
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::GlobalVariableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isConstant(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->isConstant(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Region*detail::GlobalVariableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getInitRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getInitRegion(tablegen_opaque_val);
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::GlobalVariableOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isDeviceData(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->isDeviceData(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
void detail::IndirectGlobalAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::getReferencedSymbols(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>& symbols, ::mlir::SymbolTable * symbolTable) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getReferencedSymbols(symbols, symbolTable);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::IndirectGlobalAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getReferencedSymbols(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::llvm::SmallVectorImpl<::mlir::SymbolRefAttr>& symbols, ::mlir::SymbolTable * symbolTable) {
|
|
return static_cast<const ConcreteOp *>(impl)->getReferencedSymbols(tablegen_opaque_val, symbols, symbolTable);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
bool detail::OutlineRematerializationOpInterfaceInterfaceTraits::Model<ConcreteOp>::isRematerializationCandidate(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return true;
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::OutlineRematerializationOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isRematerializationCandidate(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->isRematerializationCandidate(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|
|
namespace mlir::acc {
|
|
|
|
template<typename ConcreteOp>
|
|
::mlir::Region&detail::OffloadRegionOpInterfaceInterfaceTraits::Model<ConcreteOp>::getOffloadRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getRegion();
|
|
}
|
|
template<typename ConcreteOp>
|
|
::mlir::Region&detail::OffloadRegionOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getOffloadRegion(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
|
|
return static_cast<const ConcreteOp *>(impl)->getOffloadRegion(tablegen_opaque_val);
|
|
}
|
|
|
|
} // namespace mlir::acc
|