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