specializeGenericTypes.h

/*
Copyright 2020 VMware, 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 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 TypeSpecialization : public IHasDbPrint {…};

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));
    }
    bool operator<(const SpecSignature &other) const  {…}

    static std::optional<SpecSignature> get(const IR::Type_Specialized *spec);
};
struct SpecSignature {…};
 
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);
};
struct TypeSpecializationMap : IHasDbPrint {…};

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 FindTypeSpecializations : public Inspector, ResolutionContext {…};

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 CreateSpecializedTypes : public Modifier, public ResolutionContext {…};

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 ReplaceTypeUses : public Transform {…};

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);
    }
};
class SpecializeGenericTypes : public PassRepeated {…};

//  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_Stack *type) override {
        if (type->elementType->is<IR::Type_Specialized>()) return nullptr;
        return type;
    }
};
class RemoveGenericTypes : public Transform {…};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_SPECIALIZEGENERICTYPES_H_ */