referenceMap.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_COMMON_RESOLVEREFERENCES_REFERENCEMAP_H_
#define FRONTENDS_COMMON_RESOLVEREFERENCES_REFERENCEMAP_H_
 
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "frontends/common/programMap.h"
#include "ir/ir.h"
#include "ir/visitor.h"
#include "lib/cstring.h"
 
namespace P4 {
 
class NameGenerator {
 public:
    virtual cstring newName(std::string_view base) = 0;
    virtual ~NameGenerator() = default;
};
 
// replacement for ReferenceMap NameGenerator to make it easier to remove uses of refMap
class MinimalNameGenerator : public NameGenerator, public Inspector {
    absl::flat_hash_map<cstring, int, Util::Hash> usedNames;
    void postorder(const IR::Path *p) override { usedName(p->name.name); }
    void postorder(const IR::Type_Declaration *t) override { usedName(t->name.name); }
    void postorder(const IR::Declaration *d) override { usedName(d->name.name); }
 
 public:
    MinimalNameGenerator();
    void usedName(cstring name) { usedNames.emplace(name, 0); }
    explicit MinimalNameGenerator(const IR::Node *root) : MinimalNameGenerator() {
        root->apply(*this);
    }

    cstring newName(std::string_view base) override;
};
 
// FIXME -- temp common base class to allow use of ReferenceMap or ResolutionContext
// interchangeably when looking up declarations.  This should go away once the refMap does
class DeclarationLookup {
 public:
    virtual ~DeclarationLookup() = default;
    virtual const IR::IDeclaration *getDeclaration(const IR::Path *,
                                                   bool notNull = false) const = 0;
    virtual const IR::IDeclaration *getDeclaration(const IR::This *,
                                                   bool notNull = false) const = 0;
};

class ReferenceMap final : public ProgramMap, public NameGenerator, public DeclarationLookup {
    bool isv1;

    absl::flat_hash_map<const IR::Path *, const IR::IDeclaration *, Util::Hash> pathToDeclaration;

    absl::flat_hash_set<const IR::IDeclaration *, Util::Hash> used;

    absl::flat_hash_map<const IR::This *, const IR::IDeclaration *, Util::Hash> thisToDeclaration;

    absl::flat_hash_map<cstring, int, Util::Hash> usedNames;
 
 public:
    ReferenceMap();
    const IR::IDeclaration *getDeclaration(const IR::Path *path,
                                           bool notNull = false) const override;

    void setDeclaration(const IR::Path *path, const IR::IDeclaration *decl);

    const IR::IDeclaration *getDeclaration(const IR::This *pointer,
                                           bool notNull = false) const override;

    void setDeclaration(const IR::This *pointer, const IR::IDeclaration *decl);
 
    void dbprint(std::ostream &cout) const override;

    void setIsV1(bool isv1) { this->isv1 = isv1; }
    void setAnyOrder(bool anyOrder) { this->isv1 = anyOrder; }

    cstring newName(std::string_view base) override;

    void clear();

    bool isV1() const { return isv1; }

    bool isUsed(const IR::IDeclaration *decl) const { return used.count(decl) > 0; }

    void usedName(cstring name) { usedNames.emplace(name, 0); }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_COMMON_RESOLVEREFERENCES_REFERENCEMAP_H_ */