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