unusedDeclarations.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#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_ */