unusedDeclarations.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_UNUSEDDECLARATIONS_H_
#define FRONTENDS_P4_UNUSEDDECLARATIONS_H_
 
#include "../common/resolveReferences/resolveReferences.h"
#include "ir/ir.h"
#include "ir/pass_manager.h"
#include "lib/stringify.h"
 
namespace P4 {
 
class UnusedDeclarations;
 
class UsedDeclSet : public IHasDbPrint {
    absl::flat_hash_set<const IR::IDeclaration *, Util::Hash> usedDecls;
 
 public:
    bool setUsed(const IR::IDeclaration *decl) { return usedDecls.emplace(decl).second; }
 
    [[nodiscard]] auto begin() const { return usedDecls.begin(); }
 
    [[nodiscard]] auto end() const { return usedDecls.end(); }
 
    void clear() { usedDecls.clear(); }
 
    void dbprint(std::ostream &cout) const override;

    bool isUsed(const IR::IDeclaration *decl) const { return usedDecls.contains(decl); }
};
 
class RemoveUnusedPolicy {
 public:
    virtual ~RemoveUnusedPolicy() = default;
    virtual UnusedDeclarations *getUnusedDeclarationsPass(const UsedDeclSet &used,
                                                          bool removeUnused, bool warnUnused,
                                                          bool infoRemoved) const;
};

class CollectUsedDeclarations : public Inspector, ResolutionContext {
    UsedDeclSet &used;
 
 public:
    explicit CollectUsedDeclarations(UsedDeclSet &used) : used(used) {}
 
    // We might be invoked in PassRepeated scenario, so the used set should be
    // force cleared.
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Inspector::init_apply(node);
        used.clear();
 
        return rv;
    }
 
    bool preorder(const IR::KeyElement *ke) override;
    bool preorder(const IR::PathExpression *path) override;
    bool preorder(const IR::Type_Name *type) override;
};

class UnusedDeclarations : public Transform, ResolutionContext {
 protected:
    const UsedDeclSet &used;

    bool removeUnused;

    bool warnUnused;

    bool infoRemoved;

    std::set<const IR::Node *> warned;

    bool giveWarning(const IR::Node *node);
    const IR::Node *process(const IR::IDeclaration *decl, bool skipWarn = false);
    const IR::Node *warnIfUnused(const IR::Node *node);
 
    // Prevent direct instantiations of this class.
    friend class RemoveUnusedPolicy;
    UnusedDeclarations(const UsedDeclSet &used, bool removeUnused, bool warnUnused,
                       bool infoRemoved)
        : used(used), removeUnused(removeUnused), warnUnused(warnUnused), infoRemoved(infoRemoved) {
        setName("UnusedDeclarations");
    }
 
 public:
    using Transform::init_apply;
    using Transform::postorder;
    using Transform::preorder;
 
    Visitor::profile_t init_apply(const IR::Node *root) override;
 
    const IR::Node *preorder(IR::P4Control *cont) override;
    const IR::Node *preorder(IR::P4Parser *cont) override;
    const IR::Node *preorder(IR::P4Table *cont) override;
    const IR::Node *preorder(IR::ParserState *state) override;
    const IR::Node *preorder(IR::Type_Enum *type) override;
    const IR::Node *preorder(IR::Type_SerEnum *type) override;
 
    const IR::Node *preorder(IR::Declaration_Instance *decl) override;
    const IR::Node *preorder(IR::Method *decl) override;
 
    // The following kinds of nodes are not deleted even if they are unreferenced
    const IR::Node *preorder(IR::Type_Error *type) override {
        prune();
        return type;
    }
    const IR::Node *preorder(IR::Declaration_MatchKind *decl) override {
        prune();
        return decl;
    }
    const IR::Node *preorder(IR::Type_StructLike *type) override {
        visit(type->typeParameters);
        prune();
        return type;
    }
    const IR::Node *preorder(IR::Type_Extern *type) override {
        visit(type->typeParameters);
        prune();
        return type;
    }
    const IR::Node *preorder(IR::Type_Method *type) override {
        visit(type->typeParameters);
        prune();
        return type;
    }
    const IR::Node *preorder(IR::Parameter *param) override;
    const IR::Node *preorder(IR::NamedExpression *ne) override { return ne; }  // never dead
    const IR::Node *preorder(IR::Type_Var *p) override {
        prune();
        return warnIfUnused(p);
    }
 
    const IR::Node *preorder(IR::Declaration_Variable *decl) override;
    const IR::Node *preorder(IR::Declaration_Constant *decl) override;
    const IR::Node *preorder(IR::Declaration *decl) override { return process(decl); }
    const IR::Node *preorder(IR::Type_Declaration *decl) override { return process(decl); }
};

class RemoveAllUnusedDeclarations : public PassManager {
    UsedDeclSet used;
 
 public:
    explicit RemoveAllUnusedDeclarations(const RemoveUnusedPolicy &policy,
                                         bool infoRemoved = false) {
        setName("RemoveAllUnusedDeclarations");
        addPasses(
            {new PassRepeated({new CollectUsedDeclarations(used),
                               policy.getUnusedDeclarationsPass(used, true, false, infoRemoved)})});
        setStopOnError(true);
    }
};

class WarnAboutUnusedDeclarations : public PassManager {
    UsedDeclSet used;
 
 public:
    explicit WarnAboutUnusedDeclarations(const RemoveUnusedPolicy &policy) {
        setName("WarnAboutUnusedDeclarations");
        addPasses({new CollectUsedDeclarations(used),
                   policy.getUnusedDeclarationsPass(used, false, true, false)});
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_UNUSEDDECLARATIONS_H_ */