actionsInlining.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_ACTIONSINLINING_H_
#define FRONTENDS_P4_ACTIONSINLINING_H_
 
#include "commonInlining.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/unusedDeclarations.h"
#include "ir/ir.h"
 
namespace P4 {
 
using ActionCallInfo = SimpleCallInfo<IR::P4Action, IR::MethodCallStatement>;
using AInlineWorkList = SimpleInlineWorkList<ActionCallInfo>;
using ActionsInlineList = SimpleInlineList<IR::P4Action, ActionCallInfo, AInlineWorkList>;
 
class DiscoverActionsInlining : public Inspector, public ResolutionContext {
    ActionsInlineList *toInline;  // output
    P4::TypeMap *typeMap;         // input
 public:
    DiscoverActionsInlining(ActionsInlineList *toInline, P4::TypeMap *typeMap)
        : toInline(toInline), typeMap(typeMap) {
        CHECK_NULL(toInline);
        CHECK_NULL(typeMap);
        setName("DiscoverActionsInlining");
    }
    bool preorder(const IR::P4Parser *) override { return false; }  // skip
    void postorder(const IR::MethodCallStatement *mcs) override;
};
 
// General-purpose actions inliner.
class ActionsInliner : public AbstractInliner<ActionsInlineList, AInlineWorkList> {
    std::unique_ptr<MinimalNameGenerator> nameGen;
    AInlineWorkList::ReplacementMap *replMap;
 
 public:
    ActionsInliner() : replMap(nullptr) {}
    Visitor::profile_t init_apply(const IR::Node *node) override;
    const IR::Node *preorder(IR::P4Parser *cont) override {
        prune();
        return cont;
    }  // skip
    const IR::Node *preorder(IR::P4Action *action) override;
    const IR::Node *postorder(IR::P4Action *action) override;
    const IR::Node *preorder(IR::MethodCallStatement *statement) override;
};
 
typedef InlineDriver<ActionsInlineList, AInlineWorkList> InlineActionsDriver;
 
class InlineActions : public PassManager {
    ActionsInlineList actionsToInline;
 
 public:
    InlineActions(TypeMap *typeMap, const RemoveUnusedPolicy &policy) {
        passes.push_back(new TypeChecking(nullptr, typeMap));
        passes.push_back(new DiscoverActionsInlining(&actionsToInline, typeMap));
        passes.push_back(new InlineActionsDriver(&actionsToInline, new ActionsInliner()));
        passes.push_back(new RemoveAllUnusedDeclarations(policy));
        setName("InlineActions");
    }
};
 
}  // namespace P4
 
namespace P4::P4_14 {

class InlineActions : public Transform {
    const IR::V1Program *global;
    class SubstActionArgs : public Transform {
        const IR::ActionFunction *function;
        const IR::Primitive *callsite;
        const IR::Node *postorder(IR::ActionArg *arg) override {
            for (unsigned i = 0; i < function->args.size(); ++i)
                if (function->args[i] == getOriginal()) return callsite->operands[i];
            BUG("Action arg not argument of action");
            return arg;
        }
 
     public:
        SubstActionArgs(const IR::ActionFunction *f, const IR::Primitive *c)
            : function(f), callsite(c) {}
    };
    const IR::V1Program *preorder(IR::V1Program *gl) override { return global = gl; }
    const IR::Node *preorder(IR::Primitive *p) override {
        if (auto af = global->get<IR::ActionFunction>(p->name)) {
            SubstActionArgs saa(af, p);
            saa.setCalledBy(this);
            return af->action.clone()->apply(saa);
        }
        return p;
    }
};
 
}  // namespace P4::P4_14
 
#endif /* FRONTENDS_P4_ACTIONSINLINING_H_ */