functionsInlining.h

/*
 * Copyright 2018 VMware, Inc.
 * SPDX-FileCopyrightText: 2018 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_FUNCTIONSINLINING_H_
#define FRONTENDS_P4_FUNCTIONSINLINING_H_
 
#include "commonInlining.h"
#include "frontends/common/resolveReferences/referenceMap.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 FunctionCallInfo = SimpleCallInfo<IR::Node, IR::Statement>;
using FunctionsInlineWorkList = SimpleInlineWorkList<FunctionCallInfo>;
using FunctionsInlineList = SimpleInlineList<IR::Node, FunctionCallInfo, FunctionsInlineWorkList>;
 
class DiscoverFunctionsInlining : public Inspector, public ResolutionContext {
    FunctionsInlineList *toInline;  // output
    P4::TypeMap *typeMap;           // input
 
 public:
    DiscoverFunctionsInlining(FunctionsInlineList *toInline, P4::TypeMap *typeMap)
        : toInline(toInline), typeMap(typeMap) {
        CHECK_NULL(toInline);
        CHECK_NULL(typeMap);
        setName("DiscoverFunctionsInlining");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override;
    void postorder(const IR::MethodCallExpression *mce) override;
};

class FunctionsInliner : public AbstractInliner<FunctionsInlineList, FunctionsInlineWorkList> {
    std::unique_ptr<MinimalNameGenerator> nameGen;
 
    // All elements in the replacement map are actually IR::Function objects
    using ReplacementMap = FunctionsInlineWorkList::ReplacementMap;
    std::vector<ReplacementMap *> replacementStack;
    std::unordered_map<const IR::MethodCallExpression *, const IR::Expression *>
        pendingReplacements;

    const IR::Expression *cloneBody(const IR::IndexedVector<IR::StatOrDecl> &src,
                                    IR::IndexedVector<IR::StatOrDecl> &dest);
    const IR::Statement *inlineBefore(const IR::Node *calleeNode,
                                      const IR::MethodCallExpression *call,
                                      const IR::Statement *before);
    bool preCaller();
    const IR::Node *postCaller(const IR::Node *caller);
    const ReplacementMap *getReplacementMap() const;
    void dumpReplacementMap() const;
    class isLocalExpression;  // functor to test actual arguments scope use
 
 public:
    FunctionsInliner() = default;
    Visitor::profile_t init_apply(const IR::Node *node) override;
    void end_apply(const IR::Node *node) override;
    const IR::Node *preorder(IR::Function *function) override;
    const IR::Node *preorder(IR::P4Control *control) override;
    const IR::Node *preorder(IR::P4Parser *parser) override;
    const IR::Node *preorder(IR::P4Action *action) override;
    const IR::Node *preorder(IR::MethodCallStatement *statement) override;
    const IR::Node *preorder(IR::MethodCallExpression *expr) override;
    const IR::Node *preorder(IR::BaseAssignmentStatement *statement) override;
    const IR::Node *preorder(IR::IfStatement *statement) override;
};
 
typedef InlineDriver<FunctionsInlineList, FunctionsInlineWorkList> InlineFunctionsDriver;

class CloneVariableDeclarations : public Transform {
 public:
    CloneVariableDeclarations() {
        setName("CloneVariableDeclarations");
        visitDagOnce = false;
    }
    const IR::Node *postorder(IR::Declaration_Variable *declaration) override {
        // this will have a different declid
        auto result = new IR::Declaration_Variable(declaration->srcInfo, declaration->getName(),
                                                   declaration->annotations, declaration->type,
                                                   declaration->initializer);
        LOG3("Cloned " << dbp(result));
        return result;
    }
};
 
class InlineFunctions : public PassManager {
    FunctionsInlineList functionsToInline;
 
 public:
    InlineFunctions(TypeMap *typeMap, const RemoveUnusedPolicy &policy) {
        passes.push_back(
            new PassRepeated({new TypeChecking(nullptr, typeMap),
                              new DiscoverFunctionsInlining(&functionsToInline, typeMap),
                              new InlineFunctionsDriver(&functionsToInline, new FunctionsInliner()),
                              new RemoveAllUnusedDeclarations(policy)}));
        passes.push_back(new CloneVariableDeclarations());
        setName("InlineFunctions");
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_FUNCTIONSINLINING_H_ */