flattenLogMsg.h

#ifndef MIDEND_FLATTENLOGMSG_H_
#define MIDEND_FLATTENLOGMSG_H_
 
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
 
using TypeLogMsgParams = std::pair<IR::IndexedVector<IR::NamedExpression>, std::string>;
 
/*
   Find types in log_msg function for replace.
*/
class FindTypesInLogMsgInvocationToReplace : public Inspector {
    P4::TypeMap *typeMap;
    ordered_map<cstring, const IR::Type_StructLike *> replacement;
    // Map with new log_msg methods where is each key is a original identifier of IR::Node.
    ordered_map<unsigned, const IR::MethodCallStatement *> logMsgReplacement;
    size_t index;
 
 public:
    explicit FindTypesInLogMsgInvocationToReplace(P4::TypeMap *typeMap) : typeMap(typeMap) {
        setName("FindTypesInLogMsgInvocationToReplace");
        CHECK_NULL(typeMap);
    }
    bool preorder(const IR::MethodCallStatement *methodCallStatement) override;
    void createReplacement(const IR::Type_StructLike *type);
    const IR::MethodCallStatement *prepareLogMsgStatement(
        const IR::MethodCallStatement *methodCallStatement);
    const IR::Type_StructLike *getReplacement(const cstring name) const {
        return ::P4::get(replacement, name);
    }
    const IR::MethodCallStatement *getReplacementMethodCall(unsigned id) const {
        return ::P4::get(logMsgReplacement, id);
    }
    bool empty() const { return replacement.empty(); }
    bool hasStructInParameter(const IR::MethodCallStatement *methodCallStatement);
 
 protected:
    TypeLogMsgParams unfoldStruct(const IR::Expression *expr, std::string strParam,
                                  std::string curName = "");
    const IR::Type_StructLike *generateNewStructType(const IR::Type_StructLike *structType,
                                                     IR::IndexedVector<IR::NamedExpression> &v);
    IR::ID newName();
};
 
class ReplaceLogMsg : public Transform, P4WriteContext {
    P4::TypeMap *typeMap;
    FindTypesInLogMsgInvocationToReplace *findTypesInLogMsgInvocationToReplace;
 
 public:
    explicit ReplaceLogMsg(
        P4::TypeMap *typeMap,
        FindTypesInLogMsgInvocationToReplace *findTypesInLogMsgInvocationToReplace)
        : typeMap(typeMap),
          findTypesInLogMsgInvocationToReplace(findTypesInLogMsgInvocationToReplace) {
        CHECK_NULL(typeMap);
        CHECK_NULL(findTypesInLogMsgInvocationToReplace);
        setName("ReplaceLogMsg");
    }
    const IR::Node *preorder(IR::P4Program *program) override;
    const IR::Node *postorder(IR::MethodCallStatement *methodCallStatement) override;
    const IR::Node *postorder(IR::Type_Struct *typeStruct) override;
};
 
class FlattenLogMsg final : public PassManager {
 public:
    FlattenLogMsg(P4::ReferenceMap *refMap, P4::TypeMap *typeMap) {
        auto findTypesInLogMsgInvocationToReplace =
            new FindTypesInLogMsgInvocationToReplace(typeMap);
        passes.push_back(new TypeChecking(refMap, typeMap));
        passes.push_back(findTypesInLogMsgInvocationToReplace);
        passes.push_back(new ReplaceLogMsg(typeMap, findTypesInLogMsgInvocationToReplace));
        passes.push_back(new ClearTypeMap(typeMap));
        setName("FlattenLogMsg");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_FLATTENLOGMSG_H_ */