eliminateTuples.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_ELIMINATETUPLES_H_
#define MIDEND_ELIMINATETUPLES_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {

class ReplacementMap {
    ordered_map<const IR::Type *, const IR::Type_Struct *> replacement;
    std::set<const IR::Type_Struct *> inserted;
    const IR::Type *convertType(const IR::Type *type);
 
 public:
    NameGenerator &ng;
    P4::TypeMap *typeMap;
 
    ReplacementMap(NameGenerator &ng, TypeMap *typeMap) : ng(ng), typeMap(typeMap) {
        CHECK_NULL(typeMap);
    }
    const IR::Type_Struct *getReplacement(const IR::Type_BaseList *tt);
    IR::IndexedVector<IR::Node> *getNewReplacements();
};

class DoReplaceTuples final : public Transform {
    ReplacementMap repl;
    MinimalNameGenerator ng;
 
 public:
    explicit DoReplaceTuples(TypeMap *typeMap) : repl(ng, typeMap) { setName("DoReplaceTuples"); }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(ng);
 
        return rv;
    }
    const IR::Node *skip(const IR::Node *node) {
        prune();
        return node;
    }
    const IR::Node *postorder(IR::Type_BaseList *type) override;
    const IR::Node *insertReplacements(const IR::Node *before);
    const IR::Node *postorder(IR::Type_Struct *type) override { return insertReplacements(type); }
    const IR::Node *postorder(IR::ArrayIndex *expression) override;
    const IR::Node *postorder(IR::Type_Typedef *type) override { return insertReplacements(type); }
    const IR::Node *postorder(IR::Type_Newtype *type) override { return insertReplacements(type); }
    const IR::Node *postorder(IR::P4Parser *parser) override { return insertReplacements(parser); }
    const IR::Node *postorder(IR::P4Control *control) override {
        return insertReplacements(control);
    }
    const IR::Node *postorder(IR::Method *method) override { return insertReplacements(method); }
    const IR::Node *postorder(IR::Type_Extern *ext) override { return insertReplacements(ext); }
    const IR::Node *postorder(IR::Declaration_Instance *decl) override {
        return insertReplacements(decl);
    }
    const IR::Node *preorder(IR::P4ValueSet *set) override {
        // Disable substitution of type parameters for value sets.
        // We want to keep these as tuples.
        return skip(set);
    }
    const IR::Node *preorder(IR::P4ListExpression *expression) override { return skip(expression); }
    const IR::Node *preorder(IR::Type_P4List *list) override { return skip(list); }
};
 
class EliminateTuples final : public PassManager {
 public:
    explicit EliminateTuples(TypeMap *typeMap, TypeChecking *typeChecking = nullptr,
                             TypeInference *typeInference = nullptr) {
        passes.push_back(typeChecking ? typeChecking : new TypeChecking(nullptr, typeMap));
        passes.push_back(new DoReplaceTuples(typeMap));
        passes.push_back(new ClearTypeMap(typeMap));
        // We do a round of type-checking which may mutate the program.
        // This will convert some ListExpressions
        // into StructExpression where tuples were converted
        // to structs.
        passes.push_back(typeInference ? typeInference : new TypeInference(typeMap, false));
        setName("EliminateTuples");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_ELIMINATETUPLES_H_ */