P4C
The P4 Compiler
Loading...
Searching...
No Matches
toP4.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 P4_TOP4_TOP4_H_
18#define P4_TOP4_TOP4_H_
19
20#include <optional>
21
22#include "frontends/common/resolveReferences/resolveReferences.h"
23#include "ir/ir.h"
24#include "ir/visitor.h"
25#include "lib/sourceCodeBuilder.h"
26
27namespace P4 {
28
33class ToP4 : public Inspector, ResolutionContext {
34 int expressionPrecedence;
35 bool isDeclaration;
36 bool showIR;
37 bool withinArgument;
38 bool noIncludes = false;
40
41 struct VecPrint {
42 cstring separator;
43 cstring terminator;
44
45 VecPrint(const char *sep, const char *term) : separator(sep), terminator(term) {}
46 };
47
48 struct ListPrint {
49 cstring start;
50 cstring end;
51
52 ListPrint(const char *start, const char *end) : start(start), end(end) {}
53 };
54
55 // maintained as stacks
56 std::vector<VecPrint> vectorSeparator;
57 size_t vectorSeparator_init_apply_size = 0;
58 std::vector<ListPrint> listTerminators;
59 size_t listTerminators_init_apply_size = 0;
60
61 void setVecSep(const char *sep, const char *term = nullptr) {
62 vectorSeparator.push_back(VecPrint(sep, term));
63 }
64 void doneVec() {
65 BUG_CHECK(!vectorSeparator.empty(), "Empty vectorSeparator");
66 vectorSeparator.pop_back();
67 }
68 VecPrint getSep() {
69 BUG_CHECK(!vectorSeparator.empty(), "Empty vectorSeparator");
70 return vectorSeparator.back();
71 }
72
73 void doneList() {
74 BUG_CHECK(!listTerminators.empty(), "Empty listTerminators");
75 listTerminators.pop_back();
76 }
78 std::optional<cstring> ifSystemFile(const IR::Node *node);
80 void dump(unsigned depth, const IR::Node *node = nullptr, unsigned adjDepth = 0);
81 unsigned curDepth() const;
82
83 public:
84 // Output is constructed here
85 Util::SourceCodeBuilder &builder;
86 /* FIXME -- simplify this by getting rid of the 'builder' object and just emitting
87 * directly to the ostream. The SourceCodeBuilder object does not appear to add any
88 * useful functionality the ostream does not already provide; it just serves to
89 * obfuscate the code */
90 std::ostream *outStream;
94 cstring mainFile;
95
96 ToP4(Util::SourceCodeBuilder &builder, bool showIR, cstring mainFile = nullptr)
97 : expressionPrecedence(DBPrint::Prec_Low),
98 isDeclaration(true),
99 showIR(showIR),
100 withinArgument(false),
101 builder(builder),
102 outStream(nullptr),
103 mainFile(mainFile) {
104 visitDagOnce = false;
105 setName("ToP4");
106 }
107 ToP4(std::ostream *outStream, bool showIR, cstring mainFile = nullptr)
108 : expressionPrecedence(DBPrint::Prec_Low),
109 isDeclaration(true),
110 showIR(showIR),
111 withinArgument(false),
112 builder(*new Util::SourceCodeBuilder()),
113 outStream(outStream),
114 mainFile(mainFile) {
115 visitDagOnce = false;
116 setName("ToP4");
117 }
118 ToP4()
119 : // this is useful for debugging
120 expressionPrecedence(DBPrint::Prec_Low),
121 isDeclaration(true),
122 showIR(false),
123 withinArgument(false),
124 builder(*new Util::SourceCodeBuilder()),
125 outStream(&std::cout),
126 mainFile(nullptr) {
127 visitDagOnce = false;
128 setName("ToP4");
129 }
130
131 using Inspector::preorder;
132
133 void setnoIncludesArg(bool condition) { noIncludes = condition; }
134
135 void setListTerm(const char *start, const char *end) {
136 listTerminators.push_back(ListPrint(start, end));
137 }
138 Visitor::profile_t init_apply(const IR::Node *node) override;
139 void end_apply(const IR::Node *node) override;
140
141 bool process(const IR::Type_StructLike *t, const char *name);
142 // types
143 bool preorder(const IR::Type_Boolean *t) override;
144 bool preorder(const IR::Type_Varbits *t) override;
145 bool preorder(const IR::Type_Bits *t) override;
146 bool preorder(const IR::Type_InfInt *t) override;
147 bool preorder(const IR::Type_String *t) override;
148 bool preorder(const IR::Type_Var *t) override;
149 bool preorder(const IR::Type_Dontcare *t) override;
150 bool preorder(const IR::Type_Void *t) override;
151 bool preorder(const IR::Type_Error *t) override;
152 bool preorder(const IR::Type_Struct *t) override { return process(t, "struct"); }
153 bool preorder(const IR::Type_Header *t) override { return process(t, "header"); }
154 bool preorder(const IR::Type_HeaderUnion *t) override { return process(t, "header_union"); }
155 bool preorder(const IR::Type_Package *t) override;
156 bool preorder(const IR::Type_Parser *t) override;
157 bool preorder(const IR::Type_Control *t) override;
158 bool preorder(const IR::Type_Name *t) override;
159 bool preorder(const IR::Type_Stack *t) override;
160 bool preorder(const IR::Type_Specialized *t) override;
161 bool preorder(const IR::Type_Enum *t) override;
162 bool preorder(const IR::Type_SerEnum *t) override;
163 bool preorder(const IR::Type_Typedef *t) override;
164 bool preorder(const IR::Type_Newtype *t) override;
165 bool preorder(const IR::Type_Extern *t) override;
166 bool preorder(const IR::Type_Unknown *t) override;
167 bool preorder(const IR::Type_BaseList *t) override;
168 bool preorder(const IR::Type *t) override {
169 builder.append(t->toString());
170 return false;
171 }
172 bool preorder(const IR::Type_SpecializedCanonical *t) override {
173 BUG("%1%: specialized canonical type in IR tree", t);
174 return false;
175 }
176
177 // declarations
178 bool preorder(const IR::Declaration_Constant *cst) override;
179 bool preorder(const IR::Declaration_Variable *v) override;
180 bool preorder(const IR::Declaration_Instance *t) override;
181 bool preorder(const IR::Declaration_MatchKind *d) override;
182
183 // expressions
184 bool preorder(const IR::Dots *e) override;
185 bool preorder(const IR::NamedDots *e) override;
186 bool preorder(const IR::Constant *c) override;
187 bool preorder(const IR::Slice *slice) override;
188 bool preorder(const IR::BoolLiteral *b) override;
189 bool preorder(const IR::StringLiteral *s) override;
190 bool preorder(const IR::PathExpression *p) override;
191 bool preorder(const IR::Cast *c) override;
192 bool preorder(const IR::Operation_Binary *b) override;
193 bool preorder(const IR::Operation_Unary *u) override;
194 bool preorder(const IR::ArrayIndex *a) override;
195 bool preorder(const IR::TypeNameExpression *e) override;
196 bool preorder(const IR::Mux *a) override;
197 bool preorder(const IR::ConstructorCallExpression *e) override;
198 bool preorder(const IR::Member *e) override;
199 bool preorder(const IR::SelectCase *e) override;
200 bool preorder(const IR::SelectExpression *e) override;
201 bool preorder(const IR::ListExpression *e) override;
202 bool preorder(const IR::P4ListExpression *e) override;
203 bool preorder(const IR::StructExpression *e) override;
204 bool preorder(const IR::Invalid *e) override;
205 bool preorder(const IR::InvalidHeader *e) override;
206 bool preorder(const IR::InvalidHeaderUnion *e) override;
207 bool preorder(const IR::HeaderStackExpression *e) override;
208 bool preorder(const IR::MethodCallExpression *e) override;
209 bool preorder(const IR::DefaultExpression *e) override;
210 bool preorder(const IR::This *e) override;
211
212 // vectors
213 bool preorder(const IR::Vector<IR::ActionListElement> *v) override;
214 bool preorder(const IR::Vector<IR::Annotation> *v) override;
215 bool preorder(const IR::Vector<IR::Entry> *v) override;
216 bool preorder(const IR::Vector<IR::Expression> *v) override;
217 bool preorder(const IR::Vector<IR::Argument> *v) override;
218 bool preorder(const IR::Vector<IR::KeyElement> *v) override;
219 bool preorder(const IR::Vector<IR::Method> *v) override;
220 bool preorder(const IR::Vector<IR::Node> *v) override;
221 bool preorder(const IR::Vector<IR::SelectCase> *v) override;
222 bool preorder(const IR::Vector<IR::SwitchCase> *v) override;
223 bool preorder(const IR::Vector<IR::Type> *v) override;
224 bool preorder(const IR::IndexedVector<IR::Declaration_ID> *v) override;
225 bool preorder(const IR::IndexedVector<IR::Declaration> *v) override;
226 bool preorder(const IR::IndexedVector<IR::Node> *v) override;
227 bool preorder(const IR::IndexedVector<IR::ParserState> *v) override;
228 bool preorder(const IR::IndexedVector<IR::StatOrDecl> *v) override;
229
230 // statements
231 bool preorder(const IR::AssignmentStatement *s) override;
232 bool preorder(const IR::BlockStatement *s) override;
233 bool preorder(const IR::MethodCallStatement *s) override;
234 bool preorder(const IR::EmptyStatement *s) override;
235 bool preorder(const IR::ReturnStatement *s) override;
236 bool preorder(const IR::BreakStatement *s) override;
237 bool preorder(const IR::ContinueStatement *s) override;
238 bool preorder(const IR::ExitStatement *s) override;
239 bool preorder(const IR::SwitchCase *s) override;
240 bool preorder(const IR::SwitchStatement *s) override;
241 bool preorder(const IR::IfStatement *s) override;
242 bool preorder(const IR::ForStatement *s) override;
243 bool preorder(const IR::ForInStatement *s) override;
244
245 // misc
246 bool preorder(const IR::NamedExpression *ne) override;
247 bool preorder(const IR::Argument *arg) override;
248 bool preorder(const IR::Path *p) override;
249 bool preorder(const IR::Parameter *p) override;
250 bool preorder(const IR::Annotations *a) override;
251 bool preorder(const IR::Annotation *a) override;
252 bool preorder(const IR::P4Program *program) override;
253 bool preorder(const IR::P4Control *c) override;
254 bool preorder(const IR::P4Action *c) override;
255 bool preorder(const IR::ParserState *s) override;
256 bool preorder(const IR::P4Parser *c) override;
257 bool preorder(const IR::TypeParameters *p) override;
258 bool preorder(const IR::ParameterList *p) override;
259 bool preorder(const IR::Method *p) override;
260 bool preorder(const IR::Function *function) override;
261
262 bool preorder(const IR::ExpressionValue *v) override;
263 bool preorder(const IR::ActionListElement *ale) override;
264 bool preorder(const IR::ActionList *v) override;
265 bool preorder(const IR::Key *v) override;
266 bool preorder(const IR::Property *p) override;
267 bool preorder(const IR::TableProperties *t) override;
268 bool preorder(const IR::EntriesList *l) override;
269 bool preorder(const IR::Entry *e) override;
270 bool preorder(const IR::P4Table *c) override;
271 bool preorder(const IR::P4ValueSet *c) override;
272
273 // in case it is accidentally called on a V1Program
274 bool preorder(const IR::V1Program *) override { return false; }
275};
276
277std::string toP4(const IR::INode *node);
278void dumpP4(const IR::INode *node);
279
280} // namespace P4
281
282#endif /* P4_TOP4_TOP4_H_ */
P4::IR::Node
Definition node.h:95
P4::Inspector
Definition visitor.h:400
P4::ResolutionContext
Visitor mixin for looking up names in enclosing scopes from the Visitor::Context.
Definition resolveReferences.h:33
P4::ToP4
Definition toP4.h:33
P4::ToP4::mainFile
cstring mainFile
Definition toP4.h:94
P4::Util::SourceCodeBuilder
Definition sourceCodeBuilder.h:29
P4::cstring
Definition cstring.h:85
P4
TODO: this is not really specific to BMV2, it should reside somewhere else.
Definition applyOptionsPragmas.cpp:24
std
STL namespace.