1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Interface Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9namespace mlir {
10namespace tfg {
11class ControlArgumentInterface;
12namespace detail {
13struct 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 &region, unsigned idx);
47 };
48};template <typename ConcreteOp>
49struct ControlArgumentInterfaceTrait;
50
51} // namespace detail
52class ControlArgumentInterface : public ::mlir::OpInterface<ControlArgumentInterface, detail::ControlArgumentInterfaceInterfaceTraits> {
53public:
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 &region);
70
71};
72namespace 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 &region : op->getRegions())
82 if (failed(ControlArgumentInterface::verifyRegion(op, region)))
83 return failure();
84 return success();
85 }
86 };
87}// namespace detail
88template<typename ConcreteOp>
89mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getDataValueOf(BlockArgument ctl) {
90 return ConcreteOp::getDataValueOf(ctl);
91}
92template<typename ConcreteOp>
93mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getControlTokenOf(BlockArgument data) {
94 return ConcreteOp::getControlTokenOf(data);
95}
96template<typename ConcreteOp>
97mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getDataValue(Region & region, unsigned idx) {
98 return ConcreteOp::getDataValue(region, idx);
99}
100template<typename ConcreteOp>
101mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::Model<ConcreteOp>::getControlToken(Region & region, unsigned idx) {
102 return ConcreteOp::getControlToken(region, idx);
103}
104template<typename ConcreteOp>
105mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getDataValueOf(BlockArgument ctl) {
106 return ConcreteOp::getDataValueOf(ctl);
107}
108template<typename ConcreteOp>
109mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getControlTokenOf(BlockArgument data) {
110 return ConcreteOp::getControlTokenOf(data);
111}
112template<typename ConcreteOp>
113mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getDataValue(Region & region, unsigned idx) {
114 return ConcreteOp::getDataValue(region, idx);
115}
116template<typename ConcreteOp>
117mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getControlToken(Region & region, unsigned idx) {
118 return ConcreteOp::getControlToken(region, idx);
119}
120template<typename ConcreteModel, typename ConcreteOp>
121mlir::BlockArgument detail::ControlArgumentInterfaceInterfaceTraits::ExternalModel<ConcreteModel, ConcreteOp>::getControlToken(Region &region, unsigned idx) {
122mlir::BlockArgument data = ConcreteOp::getDataValue(region, idx);
123 return ConcreteOp::getControlTokenOf(data);
124}
125} // namespace tfg
126} // namespace mlir
127namespace mlir {
128namespace tfg {
129class PreservedAttributesInterface;
130namespace detail {
131struct 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>
160struct PreservedAttributesInterfaceTrait;
161
162} // namespace detail
163class PreservedAttributesInterface : public ::mlir::OpInterface<PreservedAttributesInterface, detail::PreservedAttributesInterfaceInterfaceTraits> {
164public:
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};
175namespace detail {
176 template <typename ConcreteOp>
177 struct PreservedAttributesInterfaceTrait : public ::mlir::OpInterface<PreservedAttributesInterface, detail::PreservedAttributesInterfaceInterfaceTraits>::Trait<ConcreteOp> {
178 };
179}// namespace detail
180template<typename ConcreteOp>
181mlir::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}
184template<typename ConcreteOp>
185void 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}
188template<typename ConcreteOp>
189mlir::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}
192template<typename ConcreteOp>
193void 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
198namespace mlir {
199namespace tfg {
200class TensorFlowRegistryInterface;
201namespace detail {
202struct 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>
228struct TensorFlowRegistryInterfaceTrait;
229
230} // namespace detail
231class TensorFlowRegistryInterface : public ::mlir::OpInterface<TensorFlowRegistryInterface, detail::TensorFlowRegistryInterfaceInterfaceTraits> {
232public:
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};
239namespace detail {
240 template <typename ConcreteOp>
241 struct TensorFlowRegistryInterfaceTrait : public ::mlir::OpInterface<TensorFlowRegistryInterface, detail::TensorFlowRegistryInterfaceInterfaceTraits>::Trait<ConcreteOp> {
242 };
243}// namespace detail
244template<typename ConcreteOp>
245bool detail::TensorFlowRegistryInterfaceInterfaceTraits::Model<ConcreteOp>::isStateful(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
246 return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).isStateful();
247}
248template<typename ConcreteOp>
249bool 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