P4C
The P4 Compiler
Loading...
Searching...
No Matches
inlining.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_INLINING_H_
9#define FRONTENDS_P4_INLINING_H_
10
11#include "commonInlining.h"
12#include "frontends/common/parser_options.h"
13#include "frontends/common/resolveReferences/referenceMap.h"
14#include "frontends/p4/evaluator/evaluator.h"
15#include "frontends/p4/evaluator/substituteParameters.h"
16#include "frontends/p4/typeChecking/typeChecker.h"
17#include "frontends/p4/unusedDeclarations.h"
18#include "ir/ir.h"
19#include "lib/ordered_map.h"
20
21// These are various data structures needed by the parser/parser and control/control inliners.
22// This only works correctly after local variable initializers have been removed,
23// and after the SideEffectOrdering pass has been executed.
24
25namespace P4 {
26
28struct CallInfo : public IHasDbPrint {
29 const IR::IContainer *caller;
30 const IR::IContainer *callee;
31 const IR::Declaration_Instance *instantiation; // callee instantiation
32 // Each instantiation may be invoked multiple times.
33 std::set<const IR::MethodCallStatement *> invocations; // all invocations within the caller
34
35 CallInfo(const IR::IContainer *caller, const IR::IContainer *callee,
36 const IR::Declaration_Instance *instantiation)
37 : caller(caller), callee(callee), instantiation(instantiation) {
38 CHECK_NULL(caller);
39 CHECK_NULL(callee);
40 CHECK_NULL(instantiation);
41 }
42 void addInvocation(const IR::MethodCallStatement *statement) { invocations.emplace(statement); }
43 void dbprint(std::ostream &out) const {
44 out << "Inline " << callee << " into " << caller << " with " << invocations.size()
45 << " invocations";
46 }
47};
48
50 std::map<const IR::IDeclaration *, IR::ID> internalName;
51 std::map<const IR::IDeclaration *, cstring> externalName;
52
53 public:
54 void setNewName(const IR::IDeclaration *decl, cstring name, cstring extName) {
55 CHECK_NULL(decl);
56 BUG_CHECK(!name.isNullOrEmpty() && !extName.isNullOrEmpty(), "Empty name");
57 LOG3("setNewName " << dbp(decl) << " to " << name);
58 if (internalName.find(decl) != internalName.end()) BUG("%1%: already renamed", decl);
59 // Keep the source spelling and location even when the declaration is inlined again.
60 auto original = decl->getName();
61 internalName.emplace(decl, IR::ID(original.srcInfo, name, original.originalName));
62 externalName.emplace(decl, extName);
63 }
64 IR::ID getName(const IR::IDeclaration *decl) const {
65 CHECK_NULL(decl);
66 BUG_CHECK(internalName.find(decl) != internalName.end(), "%1%: no new name", decl);
67 auto result = ::P4::get(internalName, decl);
68 return result;
69 }
70 cstring getExtName(const IR::IDeclaration *decl) const {
71 CHECK_NULL(decl);
72 BUG_CHECK(externalName.find(decl) != externalName.end(), "%1%: no external name", decl);
73 auto result = ::P4::get(externalName, decl);
74 return result;
75 }
76 bool isRenamed(const IR::IDeclaration *decl) const {
77 CHECK_NULL(decl);
78 return internalName.find(decl) != internalName.end();
79 }
80};
81
82struct PerInstanceSubstitutions {
83 ParameterSubstitution paramSubst;
85 SymRenameMap renameMap;
86 PerInstanceSubstitutions() = default;
87 PerInstanceSubstitutions(const PerInstanceSubstitutions &other)
88 : paramSubst(other.paramSubst), tvs(other.tvs), renameMap(other.renameMap) {}
89 template <class T>
90 const T *rename(ReferenceMap *refMap, const IR::Node *node);
91};
92
94struct InlineSummary : public IHasDbPrint {
96 struct PerCaller { // information for each caller
125 typedef std::pair<const IR::MethodCallStatement *, const IR::PathExpression *>
127
133 struct key_hash {
134 std::size_t operator()(const InlinedInvocationInfo &k) const {
135 std::ostringstream oss;
136 std::get<0>(k)->dbprint(oss);
137 std::get<1>(k)->dbprint(oss);
138 return std::hash<std::string>{}(oss.str());
139 }
140 };
141
147 struct key_equal {
148 bool operator()(const InlinedInvocationInfo &v0,
149 const InlinedInvocationInfo &v1) const {
150 return std::get<0>(v0)->equiv(*std::get<0>(v1)) &&
151 std::get<1>(v0)->equiv(*std::get<1>(v1));
152 }
153 };
154
156 std::map<const IR::Declaration_Instance *, const IR::IContainer *> declToCallee;
158 std::map<const IR::Declaration_Instance *, PerInstanceSubstitutions *> substitutions;
160 std::map<const IR::MethodCallStatement *, const IR::Declaration_Instance *> callToInstance;
161
270 std::unordered_map<const InlinedInvocationInfo, const IR::ID, key_hash, key_equal>
272
275 const IR::MethodCallStatement *uniqueCaller(
276 const IR::Declaration_Instance *instance) const {
277 const IR::MethodCallStatement *call = nullptr;
278 for (auto m : callToInstance) {
279 if (m.second == instance) {
280 if (call == nullptr)
281 call = m.first;
282 else
283 return nullptr;
284 }
285 }
286 return call;
287 }
288 };
289 std::map<const IR::IContainer *, PerCaller> callerToWork;
290
291 void add(const CallInfo *cci) {
292 callerToWork[cci->caller].declToCallee[cci->instantiation] = cci->callee;
293 for (auto mcs : cci->invocations)
294 callerToWork[cci->caller].callToInstance[mcs] = cci->instantiation;
295 }
296 void dbprint(std::ostream &out) const {
297 out << "Inline " << callerToWork.size() << " call sites";
298 }
299};
300
301// Inling information constructed here.
303 // We use an ordered map to make the iterator deterministic
305 std::vector<CallInfo *> toInline; // sorted in order of inlining
306 const bool allowMultipleCalls = true;
307
308 public:
309 void addInstantiation(const IR::IContainer *caller, const IR::IContainer *callee,
310 const IR::Declaration_Instance *instantiation) {
311 CHECK_NULL(caller);
312 CHECK_NULL(callee);
313 CHECK_NULL(instantiation);
314 LOG3("Inline instantiation " << dbp(instantiation));
315 auto inst = new CallInfo(caller, callee, instantiation);
316 inlineMap[instantiation] = inst;
317 }
318
319 size_t size() const { return inlineMap.size(); }
320
321 void addInvocation(const IR::Declaration_Instance *instance,
322 const IR::MethodCallStatement *statement) {
323 CHECK_NULL(instance);
324 CHECK_NULL(statement);
325 LOG3("Inline invocation " << dbp(instance) << " at " << dbp(statement));
326 auto info = inlineMap[instance];
327 BUG_CHECK(info, "Could not locate instance %1% invoked by %2%", instance, statement);
328 info->addInvocation(statement);
329 }
330
331 void replace(const IR::IContainer *container, const IR::IContainer *replacement) {
332 CHECK_NULL(container);
333 CHECK_NULL(replacement);
334 LOG3("Replacing " << dbp(container) << " with " << dbp(replacement));
335 for (auto e : toInline) {
336 if (e->callee == container) e->callee = replacement;
337 if (e->caller == container) e->caller = replacement;
338 }
339 }
340
341 void analyze();
342 InlineSummary *next();
343};
344
346class DiscoverInlining : public Inspector {
347 InlineList *inlineList; // output: result is here
348 ReferenceMap *refMap; // input
349 TypeMap *typeMap; // input
350 IHasBlock *evaluator; // used to obtain the toplevel block
351 IR::ToplevelBlock *toplevel;
352
353 public:
354 bool allowParsers = true;
355 bool allowControls = true;
356
357 DiscoverInlining(InlineList *inlineList, ReferenceMap *refMap, TypeMap *typeMap,
358 IHasBlock *evaluator)
359 : inlineList(inlineList),
360 refMap(refMap),
361 typeMap(typeMap),
362 evaluator(evaluator),
363 toplevel(nullptr) {
364 CHECK_NULL(inlineList);
365 CHECK_NULL(refMap);
366 CHECK_NULL(typeMap);
367 CHECK_NULL(evaluator);
368 setName("DiscoverInlining");
369 visitDagOnce = false;
370 }
371 Visitor::profile_t init_apply(const IR::Node *node) override {
372 toplevel = evaluator->getToplevelBlock();
373 CHECK_NULL(toplevel);
374 return Inspector::init_apply(node);
375 }
376 void visit_all(const IR::Block *block);
377 bool preorder(const IR::Block *block) override {
378 visit_all(block);
379 return false;
380 }
381 bool preorder(const IR::ControlBlock *block) override;
382 bool preorder(const IR::ParserBlock *block) override;
383 void postorder(const IR::MethodCallStatement *statement) override;
384 // We don't care to visit the program, we just visit the blocks.
385 bool preorder(const IR::P4Program *) override {
386 visit_all(toplevel);
387 return false;
388 }
389};
390
392class GeneralInliner : public AbstractInliner<InlineList, InlineSummary> {
393 ReferenceMap *refMap;
394 TypeMap *typeMap;
395 InlineSummary::PerCaller *workToDo;
396 bool optimizeParserInlining;
397
398 public:
399 explicit GeneralInliner(ReferenceMap *refMap, bool _optimizeParserInlining)
400 : refMap(refMap),
401 typeMap(new TypeMap()),
402 workToDo(nullptr),
403 optimizeParserInlining(_optimizeParserInlining) {
404 setName("GeneralInliner");
405 visitDagOnce = false;
406 }
407 // controlled visiting order
408 const IR::Node *preorder(IR::MethodCallStatement *statement) override;
413 template <class P4Block, class P4BlockType>
414 void inline_subst(P4Block *caller, IR::IndexedVector<IR::Declaration> P4Block::*blockLocals,
415 const P4BlockType *P4Block::*blockType);
416 const IR::Node *preorder(IR::P4Control *caller) override;
417 const IR::Node *preorder(IR::P4Parser *caller) override;
418 const IR::Node *preorder(IR::ParserState *state) override;
419 Visitor::profile_t init_apply(const IR::Node *node) override;
420};
421
423class InlinePass : public PassManager {
424 InlineList toInline;
425
426 public:
427 InlinePass(ReferenceMap *refMap, TypeMap *typeMap, EvaluatorPass *evaluator,
428 const RemoveUnusedPolicy &policy, bool optimizeParserInlining)
429 : PassManager({new TypeChecking(refMap, typeMap),
430 new DiscoverInlining(&toInline, refMap, typeMap, evaluator),
432 &toInline, new GeneralInliner(refMap, optimizeParserInlining)),
433 new RemoveAllUnusedDeclarations(policy)}) {
434 setName("InlinePass");
435 }
436};
437
443class Inline : public PassManager {
444 static std::set<cstring> noPropagateAnnotations;
445 ReferenceMap refMap;
446
447 public:
448 Inline(TypeMap *typeMap, const RemoveUnusedPolicy &policy, bool optimizeParserInlining,
449 EvaluatorPass *evaluator = nullptr) {
450#ifdef SUPPORT_P4_14
451 refMap.setIsV1(P4CContext::get().options().isv1());
452#endif
453 auto *evInstance = evaluator ? evaluator : new EvaluatorPass(&refMap, typeMap);
454 addPasses({
455 evInstance,
456 new PassRepeated(
457 {new InlinePass(&refMap, typeMap, evInstance, policy, optimizeParserInlining),
458 // After inlining the output of the evaluator changes, so we have to
459 // run it again
460 evInstance}),
461 });
462 setName("Inline");
463 }
464
466 static void setAnnotationNoPropagate(cstring name) { noPropagateAnnotations.emplace(name); }
467
469 static bool isAnnotationNoPropagate(cstring name) { return noPropagateAnnotations.count(name); }
470};
471
472} // namespace P4
473
474#endif /* FRONTENDS_P4_INLINING_H_ */
Must be run after an evaluator; uses the blocks to discover caller/callee relationships.
Definition inlining.h:346
Definition evaluator.h:106
Performs actual inlining work.
Definition inlining.h:392
void inline_subst(P4Block *caller, IR::IndexedVector< IR::Declaration > P4Block::*blockLocals, const P4BlockType *P4Block::*blockType)
Definition inlining.cpp:458
Definition evaluator.h:19
Definition stringify.h:24
The Declaration interface, representing objects with names.
Definition declaration.h:17
virtual ID getName() const =0
Definition indexed_vector.h:31
Definition node.h:44
Definition commonInlining.h:169
static bool isAnnotationNoPropagate(cstring name)
Is annotation name excluded from inline propagation?
Definition inlining.h:469
static void setAnnotationNoPropagate(cstring name)
Do not propagate annotation name during inlining.
Definition inlining.h:466
Definition inlining.h:302
Performs one round of inlining bottoms-up.
Definition inlining.h:423
Definition visitor.h:409
static P4CContext & get()
Definition parser_options.cpp:559
Definition parameterSubstitution.h:21
Definition ir/pass_manager.h:137
Class used to encode maps from paths to declarations.
Definition referenceMap.h:58
Iterates UnusedDeclarations until convergence.
Definition unusedDeclarations.h:187
Definition unusedDeclarations.h:39
Definition inlining.h:49
Definition typeChecker.h:46
Definition typeMap.h:32
Definition typeSubstitution.h:64
Definition visitor.h:69
Definition cstring.h:76
Definition ordered_map.h:23
TODO: this is not really specific to BMV2, it should reside somewhere else.
Definition applyOptionsPragmas.cpp:13
void info(const int kind, const char *format, const T *node, Args &&...args)
Report info messages of type kind. Requires that the node argument have source info.
Definition lib/error.h:157
Describes information about a caller-callee pair.
Definition inlining.h:28
Definition id.h:19
Various substitutions that must be applied for each instance.
Definition inlining.h:96
const IR::MethodCallStatement * uniqueCaller(const IR::Declaration_Instance *instance) const
Definition inlining.h:275
std::map< const IR::Declaration_Instance *, const IR::IContainer * > declToCallee
For each instance (key) the container that is intantiated.
Definition inlining.h:156
std::unordered_map< const InlinedInvocationInfo, const IR::ID, key_hash, key_equal > invocationToState
Definition inlining.h:271
std::map< const IR::MethodCallStatement *, const IR::Declaration_Instance * > callToInstance
For each invocation (key) call the instance that is invoked.
Definition inlining.h:160
std::map< const IR::Declaration_Instance *, PerInstanceSubstitutions * > substitutions
For each instance (key) we must apply a bunch of substitutions.
Definition inlining.h:158
std::pair< const IR::MethodCallStatement *, const IR::PathExpression * > InlinedInvocationInfo
Definition inlining.h:126
Summarizes all inline operations to be performed.
Definition inlining.h:94