1 | /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
2 | |* *| |
3 | |* Interface Declarations *| |
4 | |* *| |
5 | |* Automatically generated file, do not edit! *| |
6 | |* *| |
7 | \*===----------------------------------------------------------------------===*/ |
8 | |
9 | namespace mlir { |
10 | namespace tfg { |
11 | class ControlArgumentInterface; |
12 | namespace detail { |
13 | struct ControlArgumentInterfaceInterfaceTraits { |
14 | struct Concept { |
15 | mlir::BlockArgument (*getDataValueOf)(BlockArgument); |
16 | mlir::BlockArgument (*getControlTokenOf)(BlockArgument); |
17 | mlir::BlockArgument (*getDataValue)(Region &, unsigned); |
18 | mlir::BlockArgument (*getControlToken)(Region &, unsigned); |
19 | }; |
20 | template<typename ConcreteOp> |
21 | class Model : public Concept { |
22 | public: |
23 | using Interface = ::mlir::tfg::ControlArgumentInterface; |
24 | Model() : Concept{getDataValueOf, getControlTokenOf, getDataValue, getControlToken} {} |
25 | |
26 | static inline mlir::BlockArgument getDataValueOf(BlockArgument ctl); |
27 | static inline mlir::BlockArgument getControlTokenOf(BlockArgument data); |
28 | static inline mlir::BlockArgument getDataValue(Region & region, unsigned idx); |
29 | static inline mlir::BlockArgument getControlToken(Region & region, unsigned idx); |
30 | }; |
31 | template<typename ConcreteOp> |
32 | class FallbackModel : public Concept { |
33 | public: |
34 | using Interface = ::mlir::tfg::ControlArgumentInterface; |
35 | FallbackModel() : Concept{getDataValueOf, getControlTokenOf, getDataValue, getControlToken} {} |
36 | |
37 | static inline mlir::BlockArgument getDataValueOf(BlockArgument ctl); |
38 | static inline mlir::BlockArgument getControlTokenOf(BlockArgument data); |
39 | static inline mlir::BlockArgument getDataValue(Region & region, unsigned idx); |
40 | static inline mlir::BlockArgument getControlToken(Region & region, unsigned idx); |
41 | }; |
42 | template<typename ConcreteModel, typename ConcreteOp> |
43 | class ExternalModel : public FallbackModel<ConcreteModel> { |
44 | public: |
45 | using ConcreteEntity = ConcreteOp; |
46 | static mlir::BlockArgument getControlToken(Region ®ion, unsigned idx); |
47 | }; |
48 | };template <typename ConcreteOp> |
49 | struct ControlArgumentInterfaceTrait; |
50 | |
51 | } // namespace detail |
52 | class ControlArgumentInterface : public ::mlir::OpInterface<ControlArgumentInterface, detail::ControlArgumentInterfaceInterfaceTraits> { |
53 | public: |
54 | using ::mlir::OpInterface<ControlArgumentInterface, detail::ControlArgumentInterfaceInterfaceTraits>::OpInterface; |
55 | template <typename ConcreteOp> |
56 | struct Trait : public detail::ControlArgumentInterfaceTrait<ConcreteOp> {}; |
57 | /// Given a block argument that is a control token, return the associated |
58 | /// data argument. |
59 | mlir::BlockArgument getDataValueOf(BlockArgument ctl); |
60 | /// Given a block argument that is a data value, return the associated |
61 | /// control token. |
62 | mlir::BlockArgument getControlTokenOf(BlockArgument data); |
63 | /// Get the data value corresponding to a given argument index. |
64 | mlir::BlockArgument getDataValue(Region & region, unsigned idx); |
65 | /// Get the control token corresponding to a given argument index. |
66 | mlir::BlockArgument getControlToken(Region & region, unsigned idx); |
67 | |
68 | /// Verify that a region has the same number of data and control arguments. |
69 | static LogicalResult verifyRegion(Operation *op, Region ®ion); |
70 | |
71 | }; |
72 | namespace detail { |
73 | template <typename ConcreteOp> |
74 | struct ControlArgumentInterfaceTrait : public ::mlir::OpInterface<ControlArgumentInterface, detail::ControlArgumentInterfaceInterfaceTraits>::Trait<ConcreteOp> { |
75 | /// Get the control token corresponding to a given argument index. |
76 | static mlir::BlockArgument getControlToken(Region & region, unsigned idx) { |
77 | mlir::BlockArgument data = ConcreteOp::getDataValue(region, idx); |
78 | return ConcreteOp::getControlTokenOf(data); |
79 | } |
80 | static ::mlir::LogicalResult verifyTrait(::mlir::Operation *op) { |
81 | for (Region ®ion : op->getRegions()) |
82 | if (failed(ControlArgumentInterface::verifyRegion(op, region))) |
83 | return failure(); |
84 | return success(); |
85 | } |
86 | }; |
87 | }// namespace detail |
88 | template<typename ConcreteOp> |
89 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getDataValueOf(BlockArgument ctl) { |
90 | return ConcreteOp::getDataValueOf(ctl); |
91 | } |
92 | template<typename ConcreteOp> |
93 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getControlTokenOf(BlockArgument data) { |
94 | return ConcreteOp::getControlTokenOf(data); |
95 | } |
96 | template<typename ConcreteOp> |
97 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getDataValue(Region & region, unsigned idx) { |
98 | return ConcreteOp::getDataValue(region, idx); |
99 | } |
100 | template<typename ConcreteOp> |
101 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getControlToken(Region & region, unsigned idx) { |
102 | return ConcreteOp::getControlToken(region, idx); |
103 | } |
104 | template<typename ConcreteOp> |
105 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getDataValueOf(BlockArgument ctl) { |
106 | return ConcreteOp::getDataValueOf(ctl); |
107 | } |
108 | template<typename ConcreteOp> |
109 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getControlTokenOf(BlockArgument data) { |
110 | return ConcreteOp::getControlTokenOf(data); |
111 | } |
112 | template<typename ConcreteOp> |
113 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getDataValue(Region & region, unsigned idx) { |
114 | return ConcreteOp::getDataValue(region, idx); |
115 | } |
116 | template<typename ConcreteOp> |
117 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getControlToken(Region & region, unsigned idx) { |
118 | return ConcreteOp::getControlToken(region, idx); |
119 | } |
120 | template<typename ConcreteModel, typename ConcreteOp> |
121 | mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::getControlToken(Region ®ion, unsigned idx) { |
122 | mlir::BlockArgument data = ConcreteOp::getDataValue(region, idx); |
123 | return ConcreteOp::getControlTokenOf(data); |
124 | } |
125 | } // namespace tfg |
126 | } // namespace mlir |
127 | namespace mlir { |
128 | namespace tfg { |
129 | class PreservedAttributesInterface; |
130 | namespace detail { |
131 | struct PreservedAttributesInterfaceInterfaceTraits { |
132 | struct Concept { |
133 | mlir::tfg::RegionAttr (*getPreservedAttrs)(const Concept *impl, ::mlir::Operation *, unsigned); |
134 | void (*setPreservedAttrs)(const Concept *impl, ::mlir::Operation *, unsigned, RegionAttr); |
135 | }; |
136 | template<typename ConcreteOp> |
137 | class Model : public Concept { |
138 | public: |
139 | using Interface = ::mlir::tfg::PreservedAttributesInterface; |
140 | Model() : Concept{getPreservedAttrs, setPreservedAttrs} {} |
141 | |
142 | static inline mlir::tfg::RegionAttr getPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx); |
143 | static inline void setPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx, RegionAttr attrs); |
144 | }; |
145 | template<typename ConcreteOp> |
146 | class FallbackModel : public Concept { |
147 | public: |
148 | using Interface = ::mlir::tfg::PreservedAttributesInterface; |
149 | FallbackModel() : Concept{getPreservedAttrs, setPreservedAttrs} {} |
150 | |
151 | static inline mlir::tfg::RegionAttr getPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx); |
152 | static inline void setPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx, RegionAttr attrs); |
153 | }; |
154 | template<typename ConcreteModel, typename ConcreteOp> |
155 | class ExternalModel : public FallbackModel<ConcreteModel> { |
156 | public: |
157 | using ConcreteEntity = ConcreteOp; |
158 | }; |
159 | };template <typename ConcreteOp> |
160 | struct PreservedAttributesInterfaceTrait; |
161 | |
162 | } // namespace detail |
163 | class PreservedAttributesInterface : public ::mlir::OpInterface<PreservedAttributesInterface, detail::PreservedAttributesInterfaceInterfaceTraits> { |
164 | public: |
165 | using ::mlir::OpInterface<PreservedAttributesInterface, detail::PreservedAttributesInterfaceInterfaceTraits>::OpInterface; |
166 | template <typename ConcreteOp> |
167 | struct Trait : public detail::PreservedAttributesInterfaceTrait<ConcreteOp> {}; |
168 | /// Get the (potentially null) RegionAttr corresponding to the region |
169 | /// at the given index. |
170 | mlir::tfg::RegionAttr getPreservedAttrs(unsigned idx); |
171 | /// Set the non-null RegionAttr corresponding to the region at the |
172 | /// given index. |
173 | void setPreservedAttrs(unsigned idx, RegionAttr attrs); |
174 | }; |
175 | namespace detail { |
176 | template <typename ConcreteOp> |
177 | struct PreservedAttributesInterfaceTrait : public ::mlir::OpInterface<PreservedAttributesInterface, detail::PreservedAttributesInterfaceInterfaceTraits>::Trait<ConcreteOp> { |
178 | }; |
179 | }// namespace detail |
180 | template<typename ConcreteOp> |
181 | mlir::tfg::RegionAttr detail::PreservedAttributesInterfaceInterfaceTraits::Model<ConcreteOp>::getPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx) { |
182 | return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getPreservedAttrs(idx); |
183 | } |
184 | template<typename ConcreteOp> |
185 | void detail::PreservedAttributesInterfaceInterfaceTraits::Model<ConcreteOp>::setPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx, RegionAttr attrs) { |
186 | return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).setPreservedAttrs(idx, attrs); |
187 | } |
188 | template<typename ConcreteOp> |
189 | mlir::tfg::RegionAttr detail::PreservedAttributesInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx) { |
190 | return static_cast<const ConcreteOp *>(impl)->getPreservedAttrs(tablegen_opaque_val, idx); |
191 | } |
192 | template<typename ConcreteOp> |
193 | void detail::PreservedAttributesInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::setPreservedAttrs(const Concept *impl, ::mlir::Operation *tablegen_opaque_val, unsigned idx, RegionAttr attrs) { |
194 | return static_cast<const ConcreteOp *>(impl)->setPreservedAttrs(tablegen_opaque_val, idx, attrs); |
195 | } |
196 | } // namespace tfg |
197 | } // namespace mlir |
198 | namespace mlir { |
199 | namespace tfg { |
200 | class TensorFlowRegistryInterface; |
201 | namespace detail { |
202 | struct TensorFlowRegistryInterfaceInterfaceTraits { |
203 | struct Concept { |
204 | bool (*isStateful)(const Concept *impl, ::mlir::Operation *); |
205 | }; |
206 | template<typename ConcreteOp> |
207 | class Model : public Concept { |
208 | public: |
209 | using Interface = ::mlir::tfg::TensorFlowRegistryInterface; |
210 | Model() : Concept{isStateful} {} |
211 | |
212 | static inline bool isStateful(const Concept *impl, ::mlir::Operation *tablegen_opaque_val); |
213 | }; |
214 | template<typename ConcreteOp> |
215 | class FallbackModel : public Concept { |
216 | public: |
217 | using Interface = ::mlir::tfg::TensorFlowRegistryInterface; |
218 | FallbackModel() : Concept{isStateful} {} |
219 | |
220 | static inline bool isStateful(const Concept *impl, ::mlir::Operation *tablegen_opaque_val); |
221 | }; |
222 | template<typename ConcreteModel, typename ConcreteOp> |
223 | class ExternalModel : public FallbackModel<ConcreteModel> { |
224 | public: |
225 | using ConcreteEntity = ConcreteOp; |
226 | }; |
227 | };template <typename ConcreteOp> |
228 | struct TensorFlowRegistryInterfaceTrait; |
229 | |
230 | } // namespace detail |
231 | class TensorFlowRegistryInterface : public ::mlir::OpInterface<TensorFlowRegistryInterface, detail::TensorFlowRegistryInterfaceInterfaceTraits> { |
232 | public: |
233 | using ::mlir::OpInterface<TensorFlowRegistryInterface, detail::TensorFlowRegistryInterfaceInterfaceTraits>::OpInterface; |
234 | template <typename ConcreteOp> |
235 | struct Trait : public detail::TensorFlowRegistryInterfaceTrait<ConcreteOp> {}; |
236 | /// Returns true if the current op is stateful, according to TensorFlow. |
237 | bool isStateful(); |
238 | }; |
239 | namespace detail { |
240 | template <typename ConcreteOp> |
241 | struct TensorFlowRegistryInterfaceTrait : public ::mlir::OpInterface<TensorFlowRegistryInterface, detail::TensorFlowRegistryInterfaceInterfaceTraits>::Trait<ConcreteOp> { |
242 | }; |
243 | }// namespace detail |
244 | template<typename ConcreteOp> |
245 | bool detail::TensorFlowRegistryInterfaceInterfaceTraits::Model<ConcreteOp>::isStateful(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) { |
246 | return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).isStateful(); |
247 | } |
248 | template<typename ConcreteOp> |
249 | bool detail::TensorFlowRegistryInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isStateful(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) { |
250 | return static_cast<const ConcreteOp *>(impl)->isStateful(tablegen_opaque_val); |
251 | } |
252 | } // namespace tfg |
253 | } // namespace mlir |
254 | |