P4C
The P4 Compiler
Loading...
Searching...
No Matches
ir-inline.h
1/*
2Copyright 2013-present Barefoot Networks, Inc.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17#ifndef IR_IR_INLINE_H_
18#define IR_IR_INLINE_H_
19
20#include "ir/id.h"
21#include "ir/indexed_vector.h"
22#include "ir/json_generator.h"
23#include "ir/namemap.h"
24#include "ir/nodemap.h"
25#include "ir/visitor.h"
26#define DEFINE_APPLY_FUNCTIONS(CLASS, TEMPLATE, TT, INLINE) \
27 TEMPLATE INLINE bool IR::CLASS TT::apply_visitor_preorder(Modifier &v) { \
28 Node::traceVisit("Mod pre"); \
29 return v.preorder(this); \
30 } \
31 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_postorder(Modifier &v) { \
32 Node::traceVisit("Mod post"); \
33 v.postorder(this); \
34 } \
35 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_revisit(Modifier &v, const Node *n) const { \
36 Node::traceVisit("Mod revisit"); \
37 v.revisit(this, n); \
38 } \
39 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_loop_revisit(Modifier &v) const { \
40 Node::traceVisit("Mod loop_revisit"); \
41 v.loop_revisit(this); \
42 } \
43 TEMPLATE INLINE bool IR::CLASS TT::apply_visitor_preorder(Inspector &v) const { \
44 Node::traceVisit("Insp pre"); \
45 return v.preorder(this); \
46 } \
47 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_postorder(Inspector &v) const { \
48 Node::traceVisit("Insp post"); \
49 v.postorder(this); \
50 } \
51 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_revisit(Inspector &v) const { \
52 Node::traceVisit("Insp revisit"); \
53 v.revisit(this); \
54 } \
55 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_loop_revisit(Inspector &v) const { \
56 Node::traceVisit("Insp loop_revisit"); \
57 v.loop_revisit(this); \
58 } \
59 TEMPLATE INLINE const IR::Node *IR::CLASS TT::apply_visitor_preorder(Transform &v) { \
60 Node::traceVisit("Trans pre"); \
61 return v.preorder(this); \
62 } \
63 TEMPLATE INLINE const IR::Node *IR::CLASS TT::apply_visitor_postorder(Transform &v) { \
64 Node::traceVisit("Trans post"); \
65 return v.postorder(this); \
66 } \
67 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_revisit(Transform &v, const Node *n) const { \
68 Node::traceVisit("Trans revisit"); \
69 v.revisit(this, n); \
70 } \
71 TEMPLATE INLINE void IR::CLASS TT::apply_visitor_loop_revisit(Transform &v) const { \
72 Node::traceVisit("Trans loop_revisit"); \
73 v.loop_revisit(this); \
74 }
75
76IRNODE_ALL_TEMPLATES(DEFINE_APPLY_FUNCTIONS, inline)
77
78template <class T>
79void IR::Vector<T>::visit_children(Visitor &v) {
80 for (auto i = vec.begin(); i != vec.end();) {
81 const IR::Node *n = v.apply_visitor(*i);
82 if (!n && *i) {
83 i = erase(i);
84 continue;
85 }
86 CHECK_NULL(n);
87 if (n == *i) {
88 i++;
89 continue;
90 }
91 if (auto l = n->to<Vector<T>>()) {
92 i = erase(i);
93 i = insert(i, l->vec.begin(), l->vec.end());
94 i += l->vec.size();
95 continue;
96 }
97 if (const auto *v = n->to<VectorBase>()) {
98 if (v->empty()) {
99 i = erase(i);
100 } else {
101 i = insert(i, v->size() - 1, nullptr);
102 for (const auto *el : *v) {
103 CHECK_NULL(el);
104 if (auto e = el->template to<T>()) {
105 *i++ = e;
106 } else {
107 BUG("visitor returned invalid type %s for Vector<%s>", el->node_type_name(),
108 T::static_type_name());
109 }
110 }
111 }
112 continue;
113 }
114 if (auto e = n->to<T>()) {
115 *i++ = e;
116 continue;
117 }
118 BUG("visitor returned invalid type %s for Vector<%s>", n->node_type_name(),
119 T::static_type_name());
120 }
121}
122template <class T>
123void IR::Vector<T>::visit_children(Visitor &v) const {
124 for (auto &a : vec) v.visit(a);
125}
126template <class T>
127void IR::Vector<T>::parallel_visit_children(Visitor &v) {
128 SplitFlowVisitVector<T>(v, *this).run_visit();
129}
130template <class T>
131void IR::Vector<T>::parallel_visit_children(Visitor &v) const {
132 SplitFlowVisitVector<T>(v, *this).run_visit();
133}
134IRNODE_DEFINE_APPLY_OVERLOAD(Vector, template <class T>, <T>)
135template <class T>
136void IR::Vector<T>::toJSON(JSONGenerator &json) const {
137 const char *sep = "";
138 Node::toJSON(json);
139 json << "," << std::endl << json.indent++ << "\"vec\" : [";
140 for (auto &k : vec) {
141 json << sep << std::endl << json.indent << k;
142 sep = ",";
143 }
144 --json.indent;
145 if (*sep) {
146 json << std::endl << json.indent;
147 }
148 json << "]";
149}
150
151std::ostream &operator<<(std::ostream &out, const IR::Vector<IR::Expression> &v);
152
153template <class T>
154void IR::IndexedVector<T>::visit_children(Visitor &v) {
155 for (auto i = begin(); i != end();) {
156 auto n = v.apply_visitor(*i);
157 if (!n && *i) {
158 i = erase(i);
159 continue;
160 }
161 CHECK_NULL(n);
162 if (n == *i) {
163 i++;
164 continue;
165 }
166 if (auto l = n->template to<Vector<T>>()) {
167 i = erase(i);
168 i = insert(i, l->begin(), l->end());
169 i += l->Vector<T>::size();
170 continue;
171 }
172 if (auto e = n->template to<T>()) {
173 i = replace(i, e);
174 continue;
175 }
176 BUG("visitor returned invalid type %s for IndexedVector<%s>", n->node_type_name(),
177 T::static_type_name());
178 }
179}
180template <class T>
181void IR::IndexedVector<T>::visit_children(Visitor &v) const {
182 for (auto &a : *this) v.visit(a);
183}
184template <class T>
185void IR::IndexedVector<T>::toJSON(JSONGenerator &json) const {
186 const char *sep = "";
187 Vector<T>::toJSON(json);
188 json << "," << std::endl << json.indent++ << "\"declarations\" : {";
189 for (const auto &k : declarations) {
190 json << sep << std::endl << json.indent << k.first << " : " << k.second;
191 sep = ",";
192 }
193 --json.indent;
194 if (*sep != 0) {
195 json << std::endl << json.indent;
196 }
197 json << "}";
198}
199IRNODE_DEFINE_APPLY_OVERLOAD(IndexedVector, template <class T>, <T>)
200
201#include "lib/ordered_map.h"
202template <class MAP>
203static inline void namemap_insert_helper(typename MAP::iterator, typename MAP::key_type k,
204 typename MAP::mapped_type v, MAP &, MAP &new_symbols) {
205 new_symbols.emplace(std::move(k), std::move(v));
206}
207
208template <class MAP, class InputIterator>
209static inline void namemap_insert_helper(typename MAP::iterator, InputIterator b, InputIterator e,
210 MAP &, MAP &new_symbols) {
211 new_symbols.insert(b, e);
212}
213
214template <class T>
215static inline void namemap_insert_helper(typename ordered_map<cstring, T>::iterator it, cstring k,
216 T v, ordered_map<cstring, T> &symbols,
217 ordered_map<cstring, T> &) {
218 symbols.emplace_hint(it, std::move(k), std::move(v));
219}
220
221template <class T, class InputIterator>
222static inline void namemap_insert_helper(typename ordered_map<cstring, T>::iterator it,
223 InputIterator b, InputIterator e,
224 ordered_map<cstring, T> &symbols,
225 ordered_map<cstring, T> &) {
226 symbols.insert(it, b, e);
227}
228
229template <class T, template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
230 class COMP /*= std::less<cstring>*/,
231 class ALLOC /*= std::allocator<std::pair<const cstring, const T*>>*/>
232void IR::NameMap<T, MAP, COMP, ALLOC>::visit_children(Visitor &v) {
233 map_t new_symbols;
234 for (auto i = symbols.begin(); i != symbols.end();) {
235 const IR::Node *n = v.apply_visitor(i->second, i->first);
236 if (!n && i->second) {
237 i = symbols.erase(i);
238 continue;
239 }
240 CHECK_NULL(n);
241 if (n == i->second) {
242 i++;
243 continue;
244 }
245 if (auto m = n->to<NameMap>()) {
246 namemap_insert_helper(i, m->symbols.begin(), m->symbols.end(), symbols, new_symbols);
247 i = symbols.erase(i);
248 continue;
249 }
250 if (auto s = n->to<T>()) {
251 if (match_name(i->first, s)) {
252 i->second = s;
253 i++;
254 } else {
255 namemap_insert_helper(i, cstring(obj_name(s)), std::move(s), symbols, new_symbols);
256 i = symbols.erase(i);
257 }
258 continue;
259 }
260 BUG("visitor returned invalid type %s for NameMap<%s>", n->node_type_name(),
261 T::static_type_name());
262 }
263 symbols.insert(new_symbols.begin(), new_symbols.end());
264}
265template <class T, template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
266 class COMP /*= std::less<cstring>*/,
267 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
268void IR::NameMap<T, MAP, COMP, ALLOC>::visit_children(Visitor &v) const {
269 for (auto &k : symbols) {
270 v.visit(k.second, k.first);
271 }
272}
273template <class T, template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
274 class COMP /*= std::less<cstring>*/,
275 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
276void IR::NameMap<T, MAP, COMP, ALLOC>::toJSON(JSONGenerator &json) const {
277 const char *sep = "";
278 Node::toJSON(json);
279 json << "," << std::endl << json.indent++ << "\"symbols\" : {";
280 for (auto &k : symbols) {
281 json << sep << std::endl << json.indent << k.first << " : " << k.second;
282 sep = ",";
283 }
284 --json.indent;
285 if (*sep) {
286 json << std::endl << json.indent;
287 }
288 json << "}";
289}
290
291template <class KEY, class VALUE,
292 template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
293 class COMP /*= std::less<cstring>*/,
294 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
295void IR::NodeMap<KEY, VALUE, MAP, COMP, ALLOC>::visit_children(Visitor &v) {
296 map_t new_symbols;
297 for (auto i = symbols.begin(); i != symbols.end();) {
298 auto nk = i->first;
299 v.visit(nk);
300 if (!nk && i->first) {
301 i = symbols.erase(i);
302 } else if (nk == i->first) {
303 v.visit(i->second);
304 if (i->second) {
305 ++i;
306 } else {
307 i = symbols.erase(i);
308 }
309 } else {
310 auto nv = i->second;
311 v.visit(nv);
312 if (nv) new_symbols.emplace(nk, nv);
313 i = symbols.erase(i);
314 }
315 }
316 symbols.insert(new_symbols.begin(), new_symbols.end());
317}
318template <class KEY, class VALUE,
319 template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
320 class COMP /*= std::less<cstring>*/,
321 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
322void IR::NodeMap<KEY, VALUE, MAP, COMP, ALLOC>::visit_children(Visitor &v) const {
323 for (auto &k : symbols) {
324 v.visit(k.first);
325 v.visit(k.second);
326 }
327}
328#endif /* IR_IR_INLINE_H_ */
IR::IndexedVector
Definition node.h:50
IR::NameMap
Definition namemap.h:36
IR::Node
Definition node.h:93
IR::NodeMap
Definition nodemap.h:29
IR::Vector
Definition vector.h:56
JSONGenerator
Definition json_generator.h:34
SplitFlowVisitVector
Definition visitor.h:692
Visitor
Definition visitor.h:73
cstring
Definition cstring.h:80
ordered_map
Definition ordered_map.h:30
RTTI::Base::to
T * to() noexcept
Definition rtti.h:226