typeMap.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_TYPEMAP_H_
#define FRONTENDS_P4_TYPEMAP_H_
 
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "frontends/common/programMap.h"
#include "frontends/p4/typeChecking/typeSubstitution.h"
 
namespace P4 {
class TypeMap final : public ProgramMap {
    // We want to have the same canonical type for two
    // different tuples, lists, stacks, or p4lists with the same signature.
    std::vector<const IR::Type *> canonicalTuples;
    std::vector<const IR::Type *> canonicalStacks;
    std::vector<const IR::Type *> canonicalP4lists;
    std::vector<const IR::Type *> canonicalLists;
 
    // Map each node to its canonical type
    absl::flat_hash_map<const IR::Node *, const IR::Type *, Util::Hash> typeMap;
    // All left-values in the program.
    absl::flat_hash_set<const IR::Expression *, Util::Hash> leftValues;
    // All compile-time constants.  A compile-time constant
    // is not necessarily a constant - it could be a directionless
    // parameter as well.
    absl::flat_hash_set<const IR::Expression *, Util::Hash> constants;
    // For each type variable in the program the actual
    // type that is substituted for it.
    TypeVariableSubstitution allTypeVariables;
 
    // checks some preconditions before setting the type
    void checkPrecondition(const IR::Node *element, const IR::Type *type) const;
 
 public:
    TypeMap() : ProgramMap("TypeMap"), strictStruct(false) {}

    bool strictStruct;
    void setStrictStruct(bool value) { strictStruct = value; }
    bool contains(const IR::Node *element) { return typeMap.count(element) != 0; }
    void setType(const IR::Node *element, const IR::Type *type);
    const IR::Type *getType(const IR::Node *element, bool notNull = false) const;
    // unwraps a TypeType into its contents
    const IR::Type *getTypeType(const IR::Node *element, bool notNull) const;
    void dbprint(std::ostream &out) const override;
    void clear();
    bool isLeftValue(const IR::Expression *expression) const {
        return leftValues.count(expression) > 0;
    }
    bool isCompileTimeConstant(const IR::Expression *expression) const;
    size_t size() const { return typeMap.size(); }
 
    void setLeftValue(const IR::Expression *expression);
    void cloneExpressionProperties(const IR::Expression *to, const IR::Expression *from);
    void setCompileTimeConstant(const IR::Expression *expression);
    void addSubstitutions(const TypeVariableSubstitution *tvs);
    const IR::Type *getSubstitution(const IR::ITypeVar *var) {
        return allTypeVariables.lookup(var);
    }
    const TypeVariableSubstitution *getSubstitutions() const { return &allTypeVariables; }

    bool equivalent(const IR::Type *left, const IR::Type *right, bool strict = false) const;
    bool implicitlyConvertibleTo(const IR::Type *from, const IR::Type *to) const;
 
    // Used for tuples and stacks only
    const IR::Type *getCanonical(const IR::Type *type);
    int widthBits(const IR::Type *type, const IR::Node *errorPosition, bool max) const;

    bool typeIsEmpty(const IR::Type *type) const;
};
}  // namespace P4
 
#endif /* FRONTENDS_P4_TYPEMAP_H_ */