147 lines
7.3 KiB
C++
147 lines
7.3 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Interface Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::bufferization {
|
|
|
|
/// An op interface for the buffer view flow analysis. This interface describes
|
|
/// buffer dependencies between operands and op results/region entry block
|
|
/// arguments.
|
|
class BufferViewFlowOpInterface;
|
|
|
|
} // namespace mlir::bufferization
|
|
namespace mlir::bufferization {
|
|
|
|
/// An op interface for the buffer view flow analysis. This interface describes
|
|
/// buffer dependencies between operands and op results/region entry block
|
|
/// arguments.
|
|
namespace detail {
|
|
struct BufferViewFlowOpInterfaceInterfaceTraits {
|
|
struct Concept {
|
|
/// The methods defined by the interface.
|
|
void (*populateDependencies)(const Concept *impl, ::mlir::Operation *, ::mlir::bufferization::RegisterDependenciesFn);
|
|
bool (*mayBeTerminalBuffer)(const Concept *impl, ::mlir::Operation *, Value);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class Model : public Concept {
|
|
public:
|
|
using Interface = ::mlir::bufferization::BufferViewFlowOpInterface;
|
|
Model() : Concept{populateDependencies, mayBeTerminalBuffer} {}
|
|
|
|
static inline void populateDependencies(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::bufferization::RegisterDependenciesFn registerDependenciesFn);
|
|
static inline bool mayBeTerminalBuffer(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, Value value);
|
|
};
|
|
template<typename ConcreteOp>
|
|
class FallbackModel : public Concept {
|
|
public:
|
|
using Interface = ::mlir::bufferization::BufferViewFlowOpInterface;
|
|
FallbackModel() : Concept{populateDependencies, mayBeTerminalBuffer} {}
|
|
|
|
static inline void populateDependencies(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::bufferization::RegisterDependenciesFn registerDependenciesFn);
|
|
static inline bool mayBeTerminalBuffer(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, Value value);
|
|
};
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
class ExternalModel : public FallbackModel<ConcreteModel> {
|
|
public:
|
|
using ConcreteEntity = ConcreteOp;
|
|
bool mayBeTerminalBuffer(::mlir::Operation *tablegen_opaque_val, Value value) const;
|
|
};
|
|
};
|
|
template <typename ConcreteOp>
|
|
struct BufferViewFlowOpInterfaceTrait;
|
|
|
|
} // namespace detail
|
|
class BufferViewFlowOpInterface : public ::mlir::OpInterface<BufferViewFlowOpInterface, detail::BufferViewFlowOpInterfaceInterfaceTraits> {
|
|
public:
|
|
using ::mlir::OpInterface<BufferViewFlowOpInterface, detail::BufferViewFlowOpInterfaceInterfaceTraits>::OpInterface;
|
|
template <typename ConcreteOp>
|
|
struct Trait : public detail::BufferViewFlowOpInterfaceTrait<ConcreteOp> {};
|
|
|
|
/// Populate buffer dependencies between operands and op results/region
|
|
/// entry block arguments.
|
|
///
|
|
/// Implementations should register dependencies between an operand ("X")
|
|
/// and an op result/region entry block argument ("Y") if Y may depend
|
|
/// on X. Y depends on X if Y and X are the same buffer or if Y is a
|
|
/// subview of X.
|
|
///
|
|
/// Example:
|
|
/// ```
|
|
/// %r = arith.select %c, %m1, %m2 : memref<5xf32>
|
|
/// ```
|
|
/// In the above example, %0 may depend on %m1 or %m2 and a correct
|
|
/// interface implementation should call:
|
|
/// - "registerDependenciesFn(%m1, %r)".
|
|
/// - "registerDependenciesFn(%m2, %r)"
|
|
void populateDependencies(::mlir::bufferization::RegisterDependenciesFn registerDependenciesFn);
|
|
|
|
/// Return "true" if the given value may be a terminal buffer. A buffer
|
|
/// value is "terminal" if it cannot be traced back any further in the
|
|
/// buffer view flow analysis.
|
|
///
|
|
/// Examples: A buffer could be terminal because:
|
|
/// - it is a newly allocated buffer (e.g., "memref.alloc"),
|
|
/// - or: because there is not enough compile-time information available
|
|
/// to make a definite decision (e.g., "memref.realloc" may reallocate
|
|
/// but we do not know for sure; another example are call ops where we
|
|
/// would have to analyze the body of the callee).
|
|
///
|
|
/// Implementations can assume that the given SSA value is an OpResult of
|
|
/// this operation or a region entry block argument of this operation.
|
|
bool mayBeTerminalBuffer(Value value);
|
|
};
|
|
|
|
} // namespace mlir::bufferization
|
|
namespace mlir::bufferization::detail {
|
|
|
|
template <typename ConcreteOp>
|
|
struct BufferViewFlowOpInterfaceTrait : public ::mlir::OpInterface<BufferViewFlowOpInterface, detail::BufferViewFlowOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
|
|
|
|
/// Return "true" if the given value may be a terminal buffer. A buffer
|
|
/// value is "terminal" if it cannot be traced back any further in the
|
|
/// buffer view flow analysis.
|
|
///
|
|
/// Examples: A buffer could be terminal because:
|
|
/// - it is a newly allocated buffer (e.g., "memref.alloc"),
|
|
/// - or: because there is not enough compile-time information available
|
|
/// to make a definite decision (e.g., "memref.realloc" may reallocate
|
|
/// but we do not know for sure; another example are call ops where we
|
|
/// would have to analyze the body of the callee).
|
|
///
|
|
/// Implementations can assume that the given SSA value is an OpResult of
|
|
/// this operation or a region entry block argument of this operation.
|
|
bool mayBeTerminalBuffer(Value value) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
} // namespace mlir::bufferization::detail
|
|
namespace mlir::bufferization {
|
|
|
|
template<typename ConcreteOp>
|
|
void detail::BufferViewFlowOpInterfaceInterfaceTraits::Model<ConcreteOp>::populateDependencies(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::bufferization::RegisterDependenciesFn registerDependenciesFn) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).populateDependencies(registerDependenciesFn);
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::BufferViewFlowOpInterfaceInterfaceTraits::Model<ConcreteOp>::mayBeTerminalBuffer(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, Value value) {
|
|
return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).mayBeTerminalBuffer(value);
|
|
}
|
|
template<typename ConcreteOp>
|
|
void detail::BufferViewFlowOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::populateDependencies(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, ::mlir::bufferization::RegisterDependenciesFn registerDependenciesFn) {
|
|
return static_cast<const ConcreteOp *>(impl)->populateDependencies(tablegen_opaque_val, registerDependenciesFn);
|
|
}
|
|
template<typename ConcreteOp>
|
|
bool detail::BufferViewFlowOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::mayBeTerminalBuffer(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, Value value) {
|
|
return static_cast<const ConcreteOp *>(impl)->mayBeTerminalBuffer(tablegen_opaque_val, value);
|
|
}
|
|
template<typename ConcreteModel, typename ConcreteOp>
|
|
bool detail::BufferViewFlowOpInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::mayBeTerminalBuffer(::mlir::Operation *tablegen_opaque_val, Value value) const {
|
|
return false;
|
|
}
|
|
|
|
} // namespace mlir::bufferization
|