global_copyprop.h

#ifndef MIDEND_GLOBAL_COPYPROP_H_
#define MIDEND_GLOBAL_COPYPROP_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
class FindVariableValues final : public Inspector {
    ReferenceMap *refMap;
    TypeMap *typeMap;
    // Container for storing constant values for variables, is used as a representation of
    // the current state of the variables in the program. Keys are variable names and values
    // are pointers to 'Expression' nodes that represent a literal value for that variable.
    std::map<cstring, const IR::Expression *> &vars;
    // Container used to store information needed for later propagating by the Transformer pass.
    // Keys for outer map are pointers to action nodes whose bodies need to be rewritten by the
    // Transformer pass and values are maps that store literal values for variables.
    // This inner map uses the name of the variable as a key and the pointer to the 'Expression'
    // node, that represents a literal, as a value.
    std::map<const IR::Node *, std::map<cstring, const IR::Expression *> *> *actions;
    // Flag for controlling which IR nodes this pass operates on
    bool working = false;
 
    bool preorder(const IR::IfStatement *) override;
    bool preorder(const IR::SwitchStatement *) override;
    bool preorder(const IR::ForStatement *) override;
    bool preorder(const IR::ForInStatement *) override;
    void postorder(const IR::P4Control *) override;
    bool preorder(const IR::P4Control *) override;
    bool preorder(const IR::P4Table *) override;
    bool preorder(const IR::P4Action *) override;
    bool preorder(const IR::AssignmentStatement *) override;
    void postorder(const IR::MethodCallExpression *) override;
 
 public:
    FindVariableValues(
        ReferenceMap *refMap, TypeMap *typeMap,
        std::map<const IR::Node *, std::map<cstring, const IR::Expression *> *> *acts)
        : refMap(refMap),
          typeMap(typeMap),
          vars(*new std::map<cstring, const IR::Expression *>),
          actions(acts) {}
};
 
class DoGlobalCopyPropagation final : public Transform {
    ReferenceMap *refMap;
    TypeMap *typeMap;
    // Container for storing constant values for variables, used as a representation of
    // the current state of the variables in the program. Keys are variable names and values
    // are pointers to 'Expression' nodes that represent a literal value for that variable.
    std::map<cstring, const IR::Expression *> *vars = nullptr;
    // Container used to store information needed for propagating.
    // Keys for outer map are pointers to action nodes whose bodies need to be rewritten by this
    // pass and values represent maps that store literal values for variables. This inner map uses
    // the name of the variable as a key and the pointer to the 'Expression' node, that represents a
    // literal, as a value.
    std::map<const IR::Node *, std::map<cstring, const IR::Expression *> *> *actions;
    // Flag for controlling which IR nodes this pass operates on
    bool performRewrite = false;
 
 public:
    explicit DoGlobalCopyPropagation(
        ReferenceMap *rM, TypeMap *tM,
        std::map<const IR::Node *, std::map<cstring, const IR::Expression *> *> *acts)
        : refMap(rM), typeMap(tM), actions(acts) {}
 
    // Returns the stored value for the used variable
    const IR::Expression *copyprop_name(cstring name);
 
    IR::IfStatement *preorder(IR::IfStatement *) override;
    IR::ForStatement *preorder(IR::ForStatement *) override;
    IR::ForInStatement *preorder(IR::ForInStatement *) override;
    const IR::Expression *postorder(IR::PathExpression *) override;
    const IR::Expression *preorder(IR::ArrayIndex *) override;
    const IR::Expression *preorder(IR::Member *) override;
    const IR::Node *preorder(IR::AssignmentStatement *) override;
    const IR::P4Action *preorder(IR::P4Action *) override;
    const IR::P4Action *postorder(IR::P4Action *) override;
    IR::MethodCallExpression *postorder(IR::MethodCallExpression *) override;
};
 
class GlobalCopyPropagation : public PassManager {
 public:
    GlobalCopyPropagation(ReferenceMap *rM, TypeMap *tM) {
        passes.push_back(new TypeChecking(rM, tM, true));
        auto acts = new std::map<const IR::Node *, std::map<cstring, const IR::Expression *> *>;
        passes.push_back(new FindVariableValues(rM, tM, acts));
        passes.push_back(new DoGlobalCopyPropagation(rM, tM, acts));
        setName("GlobalCopyPropagation");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_GLOBAL_COPYPROP_H_ */