specialize.h

/*
Copyright 2016 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_SPECIALIZE_H_
#define FRONTENDS_P4_SPECIALIZE_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "ir/pass_manager.h"
 
namespace P4 {
 
class FrontEndPolicy;  // full definition not needed here

struct SpecializationInfo {
    cstring name;
    const IR::IContainer *specialized;
    const IR::Vector<IR::Type> *typeArguments;
    IR::Vector<IR::Argument> *constructorArguments;
    IR::IndexedVector<IR::Declaration> *declarations;
    const IR::Node *invocation;
    const IR::Node *insertBefore;
 
    SpecializationInfo(const IR::Node *invocation, const IR::IContainer *cont,
                       const IR::Node *insertion)
        : specialized(cont),
          typeArguments(nullptr),
          constructorArguments(new IR::Vector<IR::Argument>()),
          declarations(new IR::IndexedVector<IR::Declaration>()),
          invocation(invocation),
          insertBefore(insertion) {
        CHECK_NULL(cont);
        CHECK_NULL(invocation);
        CHECK_NULL(insertion);
    }
    const IR::Type_Declaration *synthesize(const Visitor::Context *ctxt) const;
};

class SpecializationMap {
    ordered_map<const IR::Node *, SpecializationInfo *> specializations;
 
 public:
    TypeMap *typeMap = nullptr;
    void addSpecialization(const IR::ConstructorCallExpression *invocation,
                           const IR::IContainer *container, const IR::Node *insertion,
                           DeclarationLookup *declLookup, NameGenerator *nameGen);
    void addSpecialization(const IR::Declaration_Instance *invocation,
                           const IR::IContainer *container, const IR::Node *insertion,
                           DeclarationLookup *declLookup, NameGenerator *nameGen);
    IR::Vector<IR::Node> *getSpecializations(const IR::Node *insertion,
                                             const Visitor::Context *ctxt) const;
    cstring getName(const IR::Node *insertion) const {
        auto s = ::P4::get(specializations, insertion);
        if (s == nullptr) return nullptr;
        return s->name;
    }
    void clear() { specializations.clear(); }
};

class FindSpecializations : public Inspector, public ResolutionContext {
    SpecializationMap *specMap;
    MinimalNameGenerator nameGen;
 
 public:
    explicit FindSpecializations(SpecializationMap *specMap) : specMap(specMap) {
        CHECK_NULL(specMap);
        setName("FindSpecializations");
    }
 
    const IR::Node *findInsertionPoint() const;
    bool isSimpleConstant(const IR::Expression *expression) const;
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Inspector::init_apply(node);
 
        specMap->clear();
        node->apply(nameGen);
 
        return rv;
    }
    bool noParameters(const IR::IContainer *container);
 
    bool preorder(const IR::P4Parser *parser) override { return noParameters(parser); }
    bool preorder(const IR::P4Control *control) override { return noParameters(control); }
    void postorder(const IR::ConstructorCallExpression *expression) override;
    void postorder(const IR::Declaration_Instance *decl) override;
 
    bool preorder(const IR::Parameter *) override {
        // This prevents specialization of the default values of
        // parameters; we don't care to specialize these, we only need
        // to specialize them if they appear in a call.
        return false;
    }
};

class Specialize : public Transform {
    SpecializationMap *specMap;
    const IR::Node *instantiate(const IR::Node *node, const Visitor::Context *ctxt);
 
 public:
    explicit Specialize(SpecializationMap *specMap) : specMap(specMap) {
        CHECK_NULL(specMap);
        setName("Specialize");
    }
    const IR::Node *postorder(IR::P4Parser *parser) override {
        return instantiate(parser, getContext());
    }
    // skip packages
    const IR::Node *preorder(IR::Type_Package *package) override {
        prune();
        return package;
    }
    const IR::Node *postorder(IR::P4Control *control) override {
        return instantiate(control, getContext());
    }
    const IR::Node *postorder(IR::ConstructorCallExpression *expression) override;
    const IR::Node *postorder(IR::Declaration_Instance *) override;
};

class SpecializeAll : public PassRepeated {
    SpecializationMap specMap;
 
 public:
    SpecializeAll(ReferenceMap *refMap, TypeMap *typeMap, FrontEndPolicy *policy);
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_SPECIALIZE_H_ */