uniqueNames.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_UNIQUENAMES_H_
#define FRONTENDS_P4_UNIQUENAMES_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "ir/pass_manager.h"
#include "ir/visitor.h"
 
namespace P4 {
 
class RenameMap {
    std::map<const IR::IDeclaration *, cstring> newName;
    std::map<const IR::MethodCallExpression *, const IR::P4Action *> actionCall;
 
 public:
    void setNewName(const IR::IDeclaration *decl, cstring name, bool allowOverride = false);

    cstring getName(const IR::IDeclaration *decl) const {
        auto n = get(decl);
        BUG_CHECK(n.has_value(), "%1%: no new name", decl);
        return *n;
    }

    bool toRename(const IR::IDeclaration *decl) const {
        CHECK_NULL(decl);
        return newName.find(decl) != newName.end();
    }

    std::optional<cstring> get(const IR::IDeclaration *decl) const {
        CHECK_NULL(decl);
        if (auto it = newName.find(decl); it != newName.end()) {
            return it->second;
        }
        return {};
    }
 
    void foundInTable(const IR::P4Action *action);
    void markActionCall(const IR::P4Action *action, const IR::MethodCallExpression *call);
    const IR::P4Action *actionCalled(const IR::MethodCallExpression *expression) const;
};

class UniqueNames : public PassManager {
 private:
    RenameMap *renameMap;
 
 public:
    UniqueNames();
};

class FindSymbols : public Inspector {
    MinimalNameGenerator nameGen;  // used to generate new names
    RenameMap *renameMap;
 
 public:
    bool isTopLevel() const {
        return !isInContext<IR::P4Parser>() && !isInContext<IR::P4Control>();
    }
    explicit FindSymbols(RenameMap *renameMap) : renameMap(renameMap) {
        CHECK_NULL(renameMap);
        setName("FindSymbols");
    }
    profile_t init_apply(const IR::Node *node) override {
        auto rv = Inspector::init_apply(node);
        node->apply(nameGen);
        return rv;
    }
 
    void doDecl(const IR::Declaration *decl) {
        cstring newName = nameGen.newName(decl->getName().string_view());
        renameMap->setNewName(decl, newName);
    }
    void postorder(const IR::Declaration_Variable *decl) override { doDecl(decl); }
    void postorder(const IR::Declaration_Constant *decl) override {
        // Skip toplevel constants with names like __
        // We assume that these do not clash and no new symbols with
        // these names will be added.
        if (decl->getName().name.startsWith("__") && getParent<IR::P4Program>()) return;
        doDecl(decl);
    }
    void postorder(const IR::Declaration_Instance *decl) override {
        if (!isTopLevel()) doDecl(decl);
    }
    void postorder(const IR::P4Table *decl) override { doDecl(decl); }
    void postorder(const IR::P4Action *decl) override {
        if (!isTopLevel()) doDecl(decl);
    }
    void postorder(const IR::P4ValueSet *decl) override {
        if (!isTopLevel()) doDecl(decl);
    }
};
 
class RenameSymbols : public Transform, public ResolutionContext {
 protected:
    RenameMap *renameMap;

    IR::ID *getName() const;
    IR::ID *getName(const IR::IDeclaration *decl) const;

    template <typename D>
    const IR::Node *renameDeclWithNameAnnotation(D *decl) {
        auto name = getName();
        if (name != nullptr && *name != decl->name) {
            decl->addAnnotationIfNew(IR::Annotation::nameAnnotation,
                                     new IR::StringLiteral(decl->name));
            decl->name = *name;
        }
        return decl;
    }
 
 public:
    explicit RenameSymbols(RenameMap *renameMap) : renameMap(renameMap) {
        CHECK_NULL(renameMap);
        visitDagOnce = false;
        setName("RenameSymbols");
    }
    const IR::Node *postorder(IR::Declaration_Variable *decl) override;
    const IR::Node *postorder(IR::Declaration_Constant *decl) override;
    const IR::Node *postorder(IR::PathExpression *expression) override;
    const IR::Node *postorder(IR::Declaration_Instance *decl) override;
    const IR::Node *postorder(IR::P4Table *decl) override;
    const IR::Node *postorder(IR::P4Action *decl) override;
    const IR::Node *postorder(IR::P4ValueSet *decl) override;
    const IR::Node *postorder(IR::Parameter *param) override;
    const IR::Node *postorder(IR::Argument *argument) override;
};

class FindParameters : public Inspector {
    MinimalNameGenerator nameGen;
    RenameMap *renameMap;
 
    void doParameters(const IR::ParameterList *pl) {
        for (auto p : pl->parameters) {
            cstring newName = nameGen.newName(p->name.string_view());
            renameMap->setNewName(p, newName);
        }
    }
 
 public:
    explicit FindParameters(RenameMap *renameMap) : renameMap(renameMap) {
        CHECK_NULL(renameMap);
        setName("FindParameters");
    }
    void postorder(const IR::P4Action *action) override { doParameters(action->parameters); }
    profile_t init_apply(const IR::Node *node) override;
};

class UniqueParameters : public PassManager {
 private:
    RenameMap *renameMap;
 
 public:
    explicit UniqueParameters(TypeMap *typeMap);
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_UNIQUENAMES_H_ */