nestedStructs.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_NESTEDSTRUCTS_H_
#define MIDEND_NESTEDSTRUCTS_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
 
class ComplexValues final {
 public:
    struct Component : public IHasDbPrint {
        virtual const IR::Expression *convertToExpression() = 0;
        virtual Component *getComponent(cstring name) = 0;
        virtual void dbprint(std::ostream &out) const = 0;
    };
 
    struct FinalName : public Component {
        cstring newName;
        explicit FinalName(cstring name) : newName(name) {}
        const IR::Expression *convertToExpression() override {
            return new IR::PathExpression(IR::ID(newName));
        }
        Component *getComponent(cstring) override { return nullptr; }
        void dbprint(std::ostream &out) const override { out << newName << Log::endl; }
    };
 
    struct FieldsMap : public Component {
        ordered_map<cstring, Component *> members;
        const IR::Type *type;
        explicit FieldsMap(const IR::Type *type) : type(type) {
            CHECK_NULL(type);
            BUG_CHECK(type->is<IR::Type_Struct>(), "%1%: expected a struct", type);
        }
        const IR::Expression *convertToExpression() override {
            IR::IndexedVector<IR::NamedExpression> vec;
            for (auto m : members) {
                auto e = m.second->convertToExpression();
                vec.push_back(new IR::NamedExpression(m.first, e));
            }
            return new IR::StructExpression(type->getP4Type(), vec);
        }
        Component *getComponent(cstring name) override { return ::P4::get(members, name); }
        void dbprint(std::ostream &out) const override {
            out << Log::indent;
            for (auto m : members) out << m.first << "=>" << m.second;
            out << Log::unindent;
        }
    };
 
    std::map<const IR::Declaration_Variable *, Component *> values;
    std::map<const IR::Expression *, Component *> translation;
 
    TypeMap *typeMap;
    NameGenerator &nameGen;
 
    ComplexValues(TypeMap *typeMap, NameGenerator &nameGen) : typeMap(typeMap), nameGen(nameGen) {
        CHECK_NULL(typeMap);
    }
    bool isNestedStruct(const IR::Type *type) const;
    template <class T>
    void explode(std::string_view prefix, const IR::Type_Struct *type, FieldsMap *map,
                 IR::Vector<T> *result);
    Component *getTranslation(const IR::IDeclaration *decl) const {
        auto dv = decl->to<IR::Declaration_Variable>();
        if (dv == nullptr) return nullptr;
        return ::P4::get(values, dv);
    }
    Component *getTranslation(const IR::Expression *expression) const {
        LOG2("Check translation " << dbp(expression));
        return ::P4::get(translation, expression);
    }
    void setTranslation(const IR::Expression *expression, Component *comp) {
        translation.emplace(expression, comp);
        LOG2("Translated " << dbp(expression) << " to " << comp);
    }
};

class RemoveNestedStructs final : public Transform, public ResolutionContext {
    ComplexValues values;
    MinimalNameGenerator nameGen;
 
 public:
    explicit RemoveNestedStructs(TypeMap *typeMap) : values(typeMap, nameGen) {
        setName("RemoveNestedStructs");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(nameGen);
 
        return rv;
    }

    const IR::Node *postorder(IR::Declaration_Variable *decl) override;
    const IR::Node *postorder(IR::Member *expression) override;
    const IR::Node *postorder(IR::PathExpression *expression) override;
    const IR::Node *postorder(IR::MethodCallExpression *expression) override;
};
 
class NestedStructs final : public PassManager {
 public:
    explicit NestedStructs(TypeMap *typeMap, TypeChecking *typeChecking = nullptr) {
        if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(new RemoveNestedStructs(typeMap));
        passes.push_back(new ClearTypeMap(typeMap));
        setName("NestedStructs");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_NESTEDSTRUCTS_H_ */