specializeGenericTypes.h

/*
 * Copyright 2020 VMware, Inc.
 * SPDX-FileCopyrightText: 2020 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_SPECIALIZEGENERICTYPES_H_
#define FRONTENDS_P4_SPECIALIZEGENERICTYPES_H_
 
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {

using InsertionSet = absl::flat_hash_set<P4::cstring>;
 
struct TypeSpecialization : public IHasDbPrint {
    cstring name;
    const IR::Type_Specialized *specialized;
    const IR::Type_Declaration *declaration;
    const IR::Type_StructLike *replacement;
    InsertionSet insertion;
    const IR::Vector<IR::Type> *argumentTypes;
    bool inserted = false;
 
    TypeSpecialization(cstring name, const IR::Type_Specialized *specialized,
                       const IR::Type_Declaration *decl, const InsertionSet &insertion,
                       const IR::Vector<IR::Type> *argTypes)
        : name(name),
          specialized(specialized),
          declaration(decl),
          replacement(nullptr),
          insertion(insertion),
          argumentTypes(argTypes) {
        CHECK_NULL(specialized);
        CHECK_NULL(decl);
        CHECK_NULL(argTypes);
    }
    void dbprint(std::ostream &out) const override {
        out << "Specializing:" << dbp(specialized) << " from " << dbp(declaration) << " as "
            << dbp(replacement) << " inserted at ";
        format_container(out, insertion, '(', ')');
    }
};

struct SpecSignature {
    cstring baseType;
    safe_vector<cstring> arguments;

    std::string name() const;

    bool operator<(const SpecSignature &other) const {
        // Using pointer comparison to speed up baseType comparation as we don't care about what
        // that order is. Note that for pointers we have to use `std::less` to make the comparison
        // defined for pointers into different objects.
        return std::less<>()(std::forward_as_tuple(baseType.c_str(), arguments),
                             std::forward_as_tuple(other.baseType.c_str(), other.arguments));
    }

    static std::optional<SpecSignature> get(const IR::Type_Specialized *spec);
};
 
std::string toString(const SpecSignature &);
 
struct TypeSpecializationMap : IHasDbPrint {
    TypeMap *typeMap;
    ordered_map<SpecSignature, TypeSpecialization> map;
 
    void add(const IR::Type_Specialized *t, const IR::Type_StructLike *decl,
             NameGenerator *nameGen);
    const TypeSpecialization *get(const IR::Type_Specialized *t) const;
    TypeSpecialization *get(const IR::Type_Specialized *t);
    void dbprint(std::ostream &out) const override {
        for (auto it : map) {
            out << toString(it.first) << " => " << it.second << std::endl;
        }
    }

    [[nodiscard]] const IR::Type_Declaration *nextAvailable();
    void markDefined(const IR::Type_Declaration *tdec);
 
 private:
    friend class CreateSpecializedTypes;
    void fillInsertionSet(const IR::Type_StructLike *decl, InsertionSet &insertion);
};

class FindTypeSpecializations : public Inspector, ResolutionContext {
    TypeSpecializationMap *specMap;
    MinimalNameGenerator nameGen;
 
 public:
    explicit FindTypeSpecializations(TypeSpecializationMap *specMap) : specMap(specMap) {
        CHECK_NULL(specMap);
        setName("FindTypeSpecializations");
    }
 
    void postorder(const IR::Type_Specialized *type) override;
    profile_t init_apply(const IR::Node *node) override;
};

class CreateSpecializedTypes : public Modifier, public ResolutionContext {
    TypeSpecializationMap *specMap;
 
 public:
    explicit CreateSpecializedTypes(TypeSpecializationMap *specMap) : specMap(specMap) {
        CHECK_NULL(specMap);
        setName("CreateSpecializedTypes");
    }
 
    void postorder(IR::Type_Specialized *type) override;
    void postorder(IR::P4Program *prog) override;
};

class ReplaceTypeUses : public Transform {
    TypeSpecializationMap *specMap;
 
 public:
    explicit ReplaceTypeUses(TypeSpecializationMap *specMap) : specMap(specMap) {
        setName("ReplaceTypeUses");
        CHECK_NULL(specMap);
    }
    const IR::Node *postorder(IR::Type_Specialized *type) override;
    const IR::Node *postorder(IR::StructExpression *expresison) override;
};

class SpecializeGenericTypes : public PassRepeated {
    TypeSpecializationMap specMap;
 
 public:
    explicit SpecializeGenericTypes(TypeMap *typeMap) {
        passes.emplace_back(new PassRepeated({
            new TypeChecking(nullptr, typeMap),
            new FindTypeSpecializations(&specMap),
            new CreateSpecializedTypes(&specMap),
            // The previous pass has mutated some struct types
            new ClearTypeMap(typeMap, true),
        }));
        passes.emplace_back(new TypeChecking(nullptr, typeMap));
        passes.emplace_back(new ReplaceTypeUses(&specMap));
        // The previous pass has invalidated the types of struct expressions
        passes.emplace_back(new ClearTypeMap(typeMap, true));
        specMap.typeMap = typeMap;
        setName("SpecializeGenericTypes");
        setStopOnError(true);
    }
};

//  Note: this pass is currently not used, but some
//  back-ends may find it useful.
class RemoveGenericTypes : public Transform {
 public:
    const IR::Node *postorder(IR::Type_StructLike *type) override {
        if (!type->typeParameters->empty()) return nullptr;
        return type;
    }
    const IR::Node *postorder(IR::Type_Array *type) override {
        if (type->elementType->is<IR::Type_Specialized>()) return nullptr;
        return type;
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_SPECIALIZEGENERICTYPES_H_ */