referenceMap.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 COMMON_RESOLVEREFERENCES_REFERENCEMAP_H_
#define 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(cstring base) = 0;
};
 
// 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.insert({name, 0}); }
    explicit MinimalNameGenerator(const IR::Node *root) : MinimalNameGenerator() {
        root->apply(*this);
    }
 
    cstring newName(cstring 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 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(cstring 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 /* COMMON_RESOLVEREFERENCES_REFERENCEMAP_H_ */