extract_maupipe.h

 
#ifndef BF_P4C_COMMON_EXTRACT_MAUPIPE_H_
#define BF_P4C_COMMON_EXTRACT_MAUPIPE_H_
 
#include <optional>
 
#include "bf-p4c/arch/arch.h"
#include "bf-p4c/arch/fromv1.0/mirror.h"
#include "bf-p4c/arch/fromv1.0/resubmit.h"
#include "bf-p4c/device.h"
#include "bf-p4c/lib/assoc.h"
#include "bf-p4c/logging/source_info_logging.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/midend/param_binding.h"
#include "frontends/common/options.h"
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/externInstance.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
class BFN_Options;
class CreateSaluInstruction;
 
namespace BFN {
 
using namespace P4;
 
const IR::BFN::Pipe *extract_maupipe(const IR::P4Program *, BFN_Options &options);
 
typedef assoc::map<const IR::Declaration_Instance *, const IR::MAU::AttachedMemory *>
    DeclarationConversions;
// a mapping from Registers to the (converted) ActionSelectors that are bound to them
typedef assoc::map<const IR::Declaration_Instance *, const IR::MAU::Selector *> StatefulSelectors;
 
class AttachTables : public PassManager {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    // Have to keep all non StatefulAlus separate from other Declaration_Instances, because
    // selectors and StatefulAlus may have the same Declaration
    DeclarationConversions &converted;
    assoc::map<const IR::Declaration_Instance *,
               IR::MAU::StatefulAlu *>
        salu_inits;  // Register -> StatefulAlu
    StatefulSelectors stateful_selectors;
 
    class InitializeStatefulAlus : public MauInspector {
        AttachTables &self;
        void postorder(const IR::Expression *) override { visitAgain(); }
        void postorder(const IR::GlobalRef *) override;
        void updateAttachedSalu(const IR::Declaration_Instance *, const IR::GlobalRef *);
 
     public:
        explicit InitializeStatefulAlus(AttachTables &s) : self(s) {}
    };
 
    class InitializeRegisterParams : public MauInspector {
        AttachTables &self;
        ordered_map<const IR::Declaration_Instance *,
                    IR::MAU::StatefulAlu *>
            param_salus;  // RegisterParam -> StatefulAlu
        bool preorder(const IR::MAU::Primitive *prim) override;
        void end_apply() override;
 
     public:
        explicit InitializeRegisterParams(AttachTables &s) : self(s) {}
    };
 
    class InitializeStatefulInstructions : public MauInspector {
        AttachTables &self;
        assoc::set<const IR::Declaration_Instance *> register_actions;
        assoc::map<const IR::MAU::StatefulAlu *, CreateSaluInstruction *> inst_ctor;
 
        void postorder(const IR::Expression *) override { visitAgain(); }
        void postorder(const IR::GlobalRef *gref) override;
 
     public:
        explicit InitializeStatefulInstructions(AttachTables &s) : self(s) {}
    };
 
    class DefineGlobalRefs : public MauModifier {
        AttachTables &self;
        P4::ReferenceMap *refMap;
        P4::TypeMap *typeMap;
 
        assoc::map<cstring, safe_vector<const IR::MAU::BackendAttached *>> attached;
        bool preorder(IR::MAU::Table *) override;
        bool preorder(IR::MAU::Action *) override;
        void postorder(IR::MAU::Table *) override;
        void postorder(IR::Expression *) override { visitAgain(); }
        void postorder(IR::GlobalRef *) override;
 
        const IR::MAU::StatefulAlu *findAttachedSalu(const IR::Declaration_Instance *ext);
 
     public:
        explicit DefineGlobalRefs(AttachTables &s, P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
            : self(s), refMap(refMap), typeMap(typeMap) {}
    };
    bool findSaluDeclarations(const IR::Declaration_Instance *ext,
                              const IR::Declaration_Instance **reg_ptr,
                              const IR::Type_Specialized **regtype_ptr = nullptr,
                              const IR::Type_Extern **seltype_ptr = nullptr);
    profile_t init_apply(const IR::Node *root) override;
 
    static bool isSaluActionType(const IR::Type *);
 
 public:
    AttachTables(P4::ReferenceMap *rm, P4::TypeMap *tm, DeclarationConversions &con,
                 StatefulSelectors ss)
        : refMap(rm), typeMap(tm), converted(con), stateful_selectors(ss) {
        addPasses({new InitializeStatefulAlus(*this), new InitializeRegisterParams(*this),
                   new InitializeStatefulInstructions(*this),
                   new DefineGlobalRefs(*this, refMap, typeMap)});
        stop_on_error = false;
    }
};
 
class ProcessBackendPipe : public PassManager {
 public:
    ProcessBackendPipe(P4::ReferenceMap *refMap, P4::TypeMap *typeMap, IR::BFN::Pipe *rv,
                       DeclarationConversions &converted, StatefulSelectors ss,
                       ParamBinding *bindings);
};
 
class BackendConverter : public Inspector {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    ParamBinding *bindings;
    ParseTna *arch;
    const IR::ToplevelBlock *toplevel = nullptr;
    StatefulSelectors stateful_selectors;
    IR::Vector<IR::BFN::Pipe> &pipe;
    ordered_map<int, const IR::BFN::Pipe *> &pipes;
    CollectSourceInfoLogging &sourceInfoLogging;
 
 public:
    BackendConverter(P4::ReferenceMap *refMap, P4::TypeMap *typeMap, ParamBinding *bindings,
                     IR::Vector<IR::BFN::Pipe> &pipe,
                     ordered_map<int, const IR::BFN::Pipe *> &pipes,
                     CollectSourceInfoLogging &sourceInfoLogging)
        : refMap(refMap),
          typeMap(typeMap),
          bindings(bindings),
          pipe(pipe),
          pipes(pipes),
          sourceInfoLogging(sourceInfoLogging) {
        arch = new ParseTna(refMap, typeMap);
    }
 
    ordered_map<int, const IR::BFN::Pipe *> &getPipes() { return pipes; }
    cstring getPipelineName(const IR::P4Program *program, int index);
    const ProgramPipelines &getPipelines() const { return arch->pipelines; }
    bool preorder(const IR::P4Program *program) override;
};
 
}  // namespace BFN
 
#endif /* BF_P4C_COMMON_EXTRACT_MAUPIPE_H_ */