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 P4_UNUSEDDECLARATIONS_H_
#define P4_UNUSEDDECLARATIONS_H_
 
#include "../common/resolveReferences/resolveReferences.h"
#include "ir/ir.h"
#include "ir/pass_manager.h"
#include "lib/stringify.h"
 
namespace P4 {
 
class RemoveUnusedDeclarations;
 
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 RemoveUnusedDeclarations *getRemoveUnusedDeclarationsPass(const UsedDeclSet &used,
                                                                      bool warn = false) 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 RemoveUnusedDeclarations : public Transform, ResolutionContext {
 protected:
    const UsedDeclSet &used;

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

    bool giveWarning(const IR::Node *node);
    const IR::Node *process(const IR::IDeclaration *decl);
    const IR::Node *warnIfUnused(const IR::Node *node);
 
    // Prevent direct instantiations of this class.
    friend class RemoveUnusedPolicy;
    RemoveUnusedDeclarations(const UsedDeclSet &used, bool warn)
        : used(used), warned(warn ? new std::set<const IR::Node *> : nullptr) {
        setName("RemoveUnusedDeclarations");
    }
 
 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 *decl) override { return process(decl); }
    const IR::Node *preorder(IR::Type_Declaration *decl) override { return process(decl); }
};

class RemoveAllUnusedDeclarations : public PassRepeated {
    UsedDeclSet used;
 
 public:
    explicit RemoveAllUnusedDeclarations(const RemoveUnusedPolicy &policy, bool warn = false)
        : PassManager({new CollectUsedDeclarations(used),
                       policy.getRemoveUnusedDeclarationsPass(used, warn)}) {
        setName("RemoveAllUnusedDeclarations");
        setStopOnError(true);
    }
};
 
}  // namespace P4
 
#endif /* P4_UNUSEDDECLARATIONS_H_ */