P4C
The P4 Compiler
Loading...
Searching...
No Matches
toP4.h
1/*
2 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
3 * Copyright 2013-present Barefoot Networks, Inc.
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8#ifndef FRONTENDS_P4_TOP4_TOP4_H_
9#define FRONTENDS_P4_TOP4_TOP4_H_
10
11#include <filesystem>
12#include <iostream>
13#include <optional>
14#include <vector>
15
16#include "frontends/common/resolveReferences/resolveReferences.h"
17#include "ir/ir.h"
18#include "ir/visitor.h"
19#include "lib/sourceCodeBuilder.h"
20
21namespace P4 {
22
27class ToP4 : public Inspector, ResolutionContext {
28 protected:
30 int expressionPrecedence = DBPrint::Prec_Low;
31 bool isDeclaration = true;
32 std::shared_ptr<Util::SourceCodeBuilder> ownedBuilder;
33 bool showIR;
34 bool withinArgument = false;
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 }
75 std::optional<cstring> ifSystemFile(const IR::Node *node);
77 void dump(unsigned depth, const IR::Node *node = nullptr, unsigned adjDepth = 0);
78 unsigned curDepth() const;
79 bool printAnnotations(const IR::IAnnotated *ann);
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 = nullptr;
92 std::optional<std::filesystem::path> mainFile;
93
94 ToP4(Util::SourceCodeBuilder &builder, bool showIR) : showIR(showIR), builder(builder) {
95 visitDagOnce = false;
96 setName("ToP4");
97 }
98
99 ToP4(std::ostream *outStream, bool showIR)
100 : ownedBuilder(std::make_shared<Util::SourceCodeBuilder>()),
101 showIR(showIR),
102 builder(*ownedBuilder),
103 outStream(outStream) {
104 visitDagOnce = false;
105 setName("ToP4");
106 }
107
108 ToP4(Util::SourceCodeBuilder &builder, bool showIR, std::filesystem::path mainFile)
109 : ToP4(builder, showIR) {
110 this->mainFile = mainFile;
111 }
112 ToP4(std::ostream *outStream, bool showIR, std::filesystem::path mainFile)
113 : ToP4(outStream, showIR) {
114 this->mainFile = mainFile;
115 }
116
117 ToP4() : ToP4(nullptr, false) {}
118
119 using Inspector::preorder;
120
121 void setnoIncludesArg(bool condition) { noIncludes = condition; }
122
123 void setListTerm(const char *start, const char *end) {
124 listTerminators.push_back(ListPrint(start, end));
125 }
126 Visitor::profile_t init_apply(const IR::Node *node) override;
127 void end_apply(const IR::Node *node) override;
128
129 bool process(const IR::Type_StructLike *t, const char *name);
130 // types
131 bool preorder(const IR::Type_Boolean *t) override;
132 bool preorder(const IR::Type_Varbits *t) override;
133 bool preorder(const IR::Type_Bits *t) override;
134 bool preorder(const IR::Type_InfInt *t) override;
135 bool preorder(const IR::Type_String *t) override;
136 bool preorder(const IR::Type_Var *t) override;
137 bool preorder(const IR::Type_Dontcare *t) override;
138 bool preorder(const IR::Type_Void *t) override;
139 bool preorder(const IR::Type_Error *t) override;
140 bool preorder(const IR::Type_Struct *t) override { return process(t, "struct"); }
141 bool preorder(const IR::Type_Header *t) override { return process(t, "header"); }
142 bool preorder(const IR::Type_HeaderUnion *t) override { return process(t, "header_union"); }
143 bool preorder(const IR::Type_Package *t) override;
144 bool preorder(const IR::Type_Parser *t) override;
145 bool preorder(const IR::Type_Control *t) override;
146 bool preorder(const IR::Type_Name *t) override;
147 bool preorder(const IR::Type_Array *t) override;
148 bool preorder(const IR::Type_Specialized *t) override;
149 bool preorder(const IR::Type_Enum *t) override;
150 bool preorder(const IR::Type_SerEnum *t) override;
151 bool preorder(const IR::Type_Typedef *t) override;
152 bool preorder(const IR::Type_Newtype *t) override;
153 bool preorder(const IR::Type_Extern *t) override;
154 bool preorder(const IR::Type_Unknown *t) override;
155 bool preorder(const IR::Type_BaseList *t) override;
156 bool preorder(const IR::Type *t) override {
157 builder.append(t->toString());
158 return false;
159 }
160 bool preorder(const IR::Type_SpecializedCanonical *t) override {
161 BUG("%1%: specialized canonical type in IR tree", t);
162 return false;
163 }
164
165 // declarations
166 bool preorder(const IR::Declaration_Constant *cst) override;
167 bool preorder(const IR::Declaration_Variable *v) override;
168 bool preorder(const IR::Declaration_Instance *t) override;
169 bool preorder(const IR::Declaration_MatchKind *d) override;
170
171 // expressions
172 bool preorder(const IR::Dots *e) override;
173 bool preorder(const IR::NamedDots *e) override;
174 bool preorder(const IR::Constant *c) override;
175 bool preorder(const IR::AbstractSlice *slice) override;
176 bool preorder(const IR::BoolLiteral *b) override;
177 bool preorder(const IR::StringLiteral *s) override;
178 bool preorder(const IR::PathExpression *p) override;
179 bool preorder(const IR::Cast *c) override;
180 bool preorder(const IR::Operation_Binary *b) override;
181 bool preorder(const IR::Operation_Unary *u) override;
182 bool preorder(const IR::ArrayIndex *a) override;
183 bool preorder(const IR::TypeNameExpression *e) override;
184 bool preorder(const IR::Mux *a) override;
185 bool preorder(const IR::ConstructorCallExpression *e) override;
186 bool preorder(const IR::Member *e) override;
187 bool preorder(const IR::SelectCase *e) override;
188 bool preorder(const IR::SelectExpression *e) override;
189 bool preorder(const IR::ListExpression *e) override;
190 bool preorder(const IR::P4ListExpression *e) override;
191 bool preorder(const IR::StructExpression *e) override;
192 bool preorder(const IR::Invalid *e) override;
193 bool preorder(const IR::InvalidHeader *e) override;
194 bool preorder(const IR::InvalidHeaderUnion *e) override;
195 bool preorder(const IR::ArrayExpression *e) override;
196 bool preorder(const IR::MethodCallExpression *e) override;
197 bool preorder(const IR::DefaultExpression *e) override;
198 bool preorder(const IR::This *e) override;
199
200 // vectors
201 bool preorder(const IR::Vector<IR::ActionListElement> *v) override;
202 bool preorder(const IR::Vector<IR::Annotation> *v) override;
203 bool preorder(const IR::Vector<IR::Entry> *v) override;
204 bool preorder(const IR::Vector<IR::Expression> *v) override;
205 bool preorder(const IR::Vector<IR::Argument> *v) override;
206 bool preorder(const IR::Vector<IR::KeyElement> *v) override;
207 bool preorder(const IR::Vector<IR::Method> *v) override;
208 bool preorder(const IR::Vector<IR::Node> *v) override;
209 bool preorder(const IR::Vector<IR::SelectCase> *v) override;
210 bool preorder(const IR::Vector<IR::SwitchCase> *v) override;
211 bool preorder(const IR::Vector<IR::Type> *v) override;
212 bool preorder(const IR::IndexedVector<IR::Declaration_ID> *v) override;
213 bool preorder(const IR::IndexedVector<IR::Declaration> *v) override;
214 bool preorder(const IR::IndexedVector<IR::Node> *v) override;
215 bool preorder(const IR::IndexedVector<IR::ParserState> *v) override;
216 bool preorder(const IR::IndexedVector<IR::StatOrDecl> *v) override;
217
218 // statements
219 bool preorder(const IR::AssignmentStatement *s) override;
220 bool preorder(const IR::OpAssignmentStatement *s) override;
221 bool preorder(const IR::BlockStatement *s) override;
222 bool preorder(const IR::MethodCallStatement *s) override;
223 bool preorder(const IR::EmptyStatement *s) override;
224 bool preorder(const IR::ReturnStatement *s) override;
225 bool preorder(const IR::BreakStatement *s) override;
226 bool preorder(const IR::ContinueStatement *s) override;
227 bool preorder(const IR::ExitStatement *s) override;
228 bool preorder(const IR::SwitchCase *s) override;
229 bool preorder(const IR::SwitchStatement *s) override;
230 bool preorder(const IR::IfStatement *s) override;
231 bool preorder(const IR::ForStatement *s) override;
232 bool preorder(const IR::ForInStatement *s) override;
233
234 // misc
235 bool preorder(const IR::NamedExpression *ne) override;
236 bool preorder(const IR::Argument *arg) override;
237 bool preorder(const IR::Path *p) override;
238 bool preorder(const IR::Parameter *p) override;
239 bool preorder(const IR::Annotation *a) override;
240 bool preorder(const IR::P4Program *program) override;
241 bool preorder(const IR::P4Control *c) override;
242 bool preorder(const IR::P4Action *c) override;
243 bool preorder(const IR::ParserState *s) override;
244 bool preorder(const IR::P4Parser *c) override;
245 bool preorder(const IR::TypeParameters *p) override;
246 bool preorder(const IR::ParameterList *p) override;
247 bool preorder(const IR::Method *p) override;
248 bool preorder(const IR::Function *function) override;
249
250 bool preorder(const IR::ExpressionValue *v) override;
251 bool preorder(const IR::ActionListElement *ale) override;
252 bool preorder(const IR::ActionList *v) override;
253 bool preorder(const IR::Key *v) override;
254 bool preorder(const IR::Property *p) override;
255 bool preorder(const IR::TableProperties *t) override;
256 bool preorder(const IR::EntriesList *l) override;
257 bool preorder(const IR::Entry *e) override;
258 bool preorder(const IR::P4Table *c) override;
259 bool preorder(const IR::P4ValueSet *c) override;
260
261#ifdef SUPPORT_P4_14
262 // in case it is accidentally called on a V1Program
263 bool preorder(const IR::V1Program *) override { return false; }
264#endif
265};
266
267std::string toP4(const IR::INode *node);
268void dumpP4(const IR::INode *node);
269
270} // namespace P4
271
272#endif /* FRONTENDS_P4_TOP4_TOP4_H_ */
Definition inode.h:42
Definition visitor.h:409
Definition toP4.h:27
void dump(unsigned depth, const IR::Node *node=nullptr, unsigned adjDepth=0)
dump node IR tree up to depth - in the form of a comment
Definition toP4.cpp:121
bool noIncludes
if true we are within a method call argument
Definition toP4.h:35
std::shared_ptr< Util::SourceCodeBuilder > ownedBuilder
current type is a declaration
Definition toP4.h:32
bool withinArgument
if true dump IR as comments
Definition toP4.h:34
std::optional< cstring > ifSystemFile(const IR::Node *node)
Definition toP4.cpp:39
int expressionPrecedence
precedence of current IR::Operation
Definition toP4.h:30
std::optional< std::filesystem::path > mainFile
Definition toP4.h:92
Definition sourceCodeBuilder.h:20
Definition cstring.h:76
TODO: this is not really specific to BMV2, it should reside somewhere else.
Definition applyOptionsPragmas.cpp:13
STL namespace.
Definition toP4.h:45
Definition toP4.h:38