hsIndexSimplify.h

#ifndef MIDEND_HSINDEXSIMPLIFY_H_
#define MIDEND_HSINDEXSIMPLIFY_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {
 
using GeneratedVariablesMap = std::map<cstring, const IR::PathExpression *>;
 
class HSIndexFinder : public Inspector {
    friend class HSIndexTransform;
    friend class HSIndexContretizer;
    IR::IndexedVector<IR::Declaration> *locals;
    ReferenceMap *refMap;
    TypeMap *typeMap;
    const IR::ArrayIndex *arrayIndex = nullptr;
    const IR::PathExpression *newVariable = nullptr;
    GeneratedVariablesMap *generatedVariables;
    std::set<cstring> storedMember;
    std::list<IR::Member *> dependedMembers;
 
 public:
    HSIndexFinder(IR::IndexedVector<IR::Declaration> *locals, ReferenceMap *refMap,
                  TypeMap *typeMap, GeneratedVariablesMap *generatedVariables)
        : locals(locals),
          refMap(refMap),
          typeMap(typeMap),
          generatedVariables(generatedVariables) {}
    void postorder(const IR::ArrayIndex *curArrayIndex) override;
 
 protected:
    void addNewVariable();
};
 
class HSIndexTransform : public Transform {
    friend class HSIndexContretizer;
    size_t index;
    HSIndexFinder &hsIndexFinder;
 
 public:
    HSIndexTransform(HSIndexFinder &finder, size_t index) : index(index), hsIndexFinder(finder) {}
    const IR::Node *postorder(IR::ArrayIndex *curArrayIndex) override;
};
 
class HSIndexContretizer : public Transform {
    ReferenceMap *refMap;
    TypeMap *typeMap;
    IR::IndexedVector<IR::Declaration> *locals;
    GeneratedVariablesMap *generatedVariables;
 
 public:
    HSIndexContretizer(ReferenceMap *refMap, TypeMap *typeMap,
                       IR::IndexedVector<IR::Declaration> *locals = nullptr,
                       GeneratedVariablesMap *generatedVariables = nullptr)
        : refMap(refMap), typeMap(typeMap), locals(locals), generatedVariables(generatedVariables) {
        if (generatedVariables == nullptr) {
            generatedVariables = new GeneratedVariablesMap();
        }
    }
    IR::Node *preorder(IR::IfStatement *ifStatement) override;
    IR::Node *preorder(IR::AssignmentStatement *assignmentStatement) override;
    IR::Node *preorder(IR::BlockStatement *blockStatement) override;
    IR::Node *preorder(IR::MethodCallStatement *methodCallStatement) override;
    IR::Node *preorder(IR::P4Control *control) override;
    IR::Node *preorder(IR::P4Parser *parser) override;
    IR::Node *preorder(IR::SwitchStatement *switchStatement) override;
 
 protected:
    IR::Node *eliminateArrayIndexes(HSIndexFinder &aiFinder, IR::Statement *statement,
                                    const IR::Expression *expr);
};
 
class HSIndexSimplifier : public PassManager {
 public:
    HSIndexSimplifier(ReferenceMap *refMap, TypeMap *typeMap) {
        // remove block statements
        passes.push_back(new TypeChecking(refMap, typeMap, true));
        passes.push_back(new HSIndexContretizer(refMap, typeMap));
        setName("HSIndexSimplifier");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_HSINDEXSIMPLIFY_H_ */