8#ifndef FRONTENDS_P4_INLINING_H_
9#define FRONTENDS_P4_INLINING_H_
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"
19#include "lib/ordered_map.h"
29 const IR::IContainer *caller;
30 const IR::IContainer *callee;
31 const IR::Declaration_Instance *instantiation;
33 std::set<const IR::MethodCallStatement *> invocations;
35 CallInfo(
const IR::IContainer *caller,
const IR::IContainer *callee,
36 const IR::Declaration_Instance *instantiation)
37 : caller(caller), callee(callee), instantiation(instantiation) {
40 CHECK_NULL(instantiation);
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()
50 std::map<const IR::IDeclaration *, IR::ID> internalName;
51 std::map<const IR::IDeclaration *, cstring> externalName;
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);
60 auto original = decl->
getName();
61 internalName.emplace(decl,
IR::ID(original.srcInfo, name, original.originalName));
62 externalName.emplace(decl, extName);
66 BUG_CHECK(internalName.find(decl) != internalName.end(),
"%1%: no new name", decl);
67 auto result = ::P4::get(internalName, decl);
72 BUG_CHECK(externalName.find(decl) != externalName.end(),
"%1%: no external name", decl);
73 auto result = ::P4::get(externalName, decl);
78 return internalName.find(decl) != internalName.end();
82struct PerInstanceSubstitutions {
86 PerInstanceSubstitutions() =
default;
87 PerInstanceSubstitutions(
const PerInstanceSubstitutions &other)
88 : paramSubst(other.paramSubst), tvs(other.tvs), renameMap(other.renameMap) {}
125 typedef std::pair<const IR::MethodCallStatement *, const IR::PathExpression *>
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());
150 return std::get<0>(v0)->equiv(*std::get<0>(v1)) &&
151 std::get<1>(v0)->equiv(*std::get<1>(v1));
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;
270 std::unordered_map<const InlinedInvocationInfo, const IR::ID, key_hash, key_equal>
276 const IR::Declaration_Instance *instance)
const {
277 const IR::MethodCallStatement *call =
nullptr;
279 if (m.second == instance) {
289 std::map<const IR::IContainer *, PerCaller> callerToWork;
292 callerToWork[cci->caller].declToCallee[cci->instantiation] = cci->callee;
293 for (
auto mcs : cci->invocations)
294 callerToWork[cci->caller].callToInstance[mcs] = cci->instantiation;
296 void dbprint(std::ostream &out)
const {
297 out <<
"Inline " << callerToWork.size() <<
" call sites";
305 std::vector<CallInfo *> toInline;
306 const bool allowMultipleCalls =
true;
309 void addInstantiation(
const IR::IContainer *caller,
const IR::IContainer *callee,
310 const IR::Declaration_Instance *instantiation) {
313 CHECK_NULL(instantiation);
314 LOG3(
"Inline instantiation " << dbp(instantiation));
315 auto inst =
new CallInfo(caller, callee, instantiation);
316 inlineMap[instantiation] = inst;
319 size_t size()
const {
return inlineMap.size(); }
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);
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;
351 IR::ToplevelBlock *toplevel;
354 bool allowParsers =
true;
355 bool allowControls =
true;
359 : inlineList(inlineList),
362 evaluator(evaluator),
364 CHECK_NULL(inlineList);
367 CHECK_NULL(evaluator);
368 setName(
"DiscoverInlining");
369 visitDagOnce =
false;
372 toplevel = evaluator->getToplevelBlock();
373 CHECK_NULL(toplevel);
374 return Inspector::init_apply(node);
376 void visit_all(
const IR::Block *block);
377 bool preorder(
const IR::Block *block)
override {
381 bool preorder(
const IR::ControlBlock *block)
override;
382 bool preorder(
const IR::ParserBlock *block)
override;
383 void postorder(
const IR::MethodCallStatement *statement)
override;
385 bool preorder(
const IR::P4Program *)
override {
392class GeneralInliner :
public AbstractInliner<InlineList, InlineSummary> {
396 bool optimizeParserInlining;
399 explicit GeneralInliner(
ReferenceMap *refMap,
bool _optimizeParserInlining)
403 optimizeParserInlining(_optimizeParserInlining) {
404 setName(
"GeneralInliner");
405 visitDagOnce =
false;
408 const IR::Node *preorder(IR::MethodCallStatement *statement)
override;
413 template <
class P4Block,
class P4BlockType>
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;
423class InlinePass :
public PassManager {
434 setName(
"InlinePass");
443class Inline :
public PassManager {
444 static std::set<cstring> noPropagateAnnotations;
453 auto *evInstance = evaluator ? evaluator :
new EvaluatorPass(&refMap, typeMap);
457 {
new InlinePass(&refMap, typeMap, evInstance, policy, optimizeParserInlining),
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 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
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 typeChecker.h:46
Definition typeSubstitution.h:64
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 inlining.h:147
Definition inlining.h:133
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