bridged_packing.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_COMMON_BRIDGED_PACKING_H_
#define BACKENDS_TOFINO_BF_P4C_COMMON_BRIDGED_PACKING_H_
 
#include "backends/tofino/bf-p4c/bf-p4c-options.h"
#include "backends/tofino/bf-p4c/common/extract_maupipe.h"
#include "backends/tofino/bf-p4c/common/field_defuse.h"
#include "backends/tofino/bf-p4c/common/pragma/collect_global_pragma.h"
#include "backends/tofino/bf-p4c/logging/source_info_logging.h"
#include "backends/tofino/bf-p4c/midend/blockmap.h"
#include "backends/tofino/bf-p4c/midend/normalize_params.h"
#include "backends/tofino/bf-p4c/midend/param_binding.h"
#include "backends/tofino/bf-p4c/midend/simplify_references.h"
#include "backends/tofino/bf-p4c/midend/type_checker.h"
#include "backends/tofino/bf-p4c/phv/action_phv_constraints.h"
#include "backends/tofino/bf-p4c/phv/constraints/constraints.h"
#include "backends/tofino/bf-p4c/phv/phv.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeMap.h"
#include "z3++.h"
 
using namespace P4;
 
// Collection of bridge metadata constraints across all pipelines
// in the program.
struct AllConstraints {
    ordered_set<const Constraints::AlignmentConstraint *> alignedConstraints;
    ordered_set<const Constraints::CopackConstraint *> copackConstraints;
    ordered_set<const Constraints::SolitaryConstraint *> solitaryConstraints;
    ordered_set<const Constraints::NoPackConstraint *> nopackConstraints;
    ordered_set<const Constraints::NoOverlapConstraint *> nooverlapConstraints;
    ordered_set<const Constraints::MutuallyAlignedConstraint *> mutuallyAlignedConstraints;
    ordered_set<const Constraints::DeparsedToTMConstraint *> deparseToTMConstraints;
    ordered_set<const Constraints::NoSplitConstraint *> noSplitConstraints;
};
 
using FieldListEntry = std::pair<int, const IR::Type *>;
using AlignmentConstraint = Constraints::AlignmentConstraint;
using SolitaryConstraint = Constraints::SolitaryConstraint;
using RepackedHeaders = std::vector<std::pair<const IR::HeaderOrMetadata *, std::string>>;
using ExtractedTogether = ordered_map<cstring, ordered_set<cstring>>;
using PackingCandidateFields = ordered_map<cstring, ordered_set<cstring>>;
using PackedFields = ordered_map<cstring, std::vector<cstring>>;
using PackingConstraints = ordered_map<cstring, std::vector<z3::expr>>;
 
using DebugInfo = ordered_map<cstring, ordered_map<cstring, ordered_set<cstring>>>;
 
using RepackedHeaderTypes = ordered_map<cstring, const IR::Type_StructLike *>;
 
class CollectIngressBridgedFields : public Inspector {
 private:
    const PhvInfo &phv;
 
    bool preorder(const IR::BFN::Unit *unit) override {
        if (unit->thread() == EGRESS) return false;
        return true;
    }
 
    profile_t init_apply(const IR::Node *root) override;
    void postorder(const IR::BFN::AliasMember *mem) override;
    void end_apply() override;
 
 public:
    explicit CollectIngressBridgedFields(const PhvInfo &phv) : phv(phv) {}
 
    ordered_map<cstring, cstring> bridged_to_orig;
};
 
class CollectEgressBridgedFields : public Inspector {
    const PhvInfo &phv;
    ordered_map<const PHV::Field *,
                ordered_map<const PHV::Field *, ordered_set<const IR::BFN::ParserState *>>>
        candidateSourcesInParser;
 
 public:
    explicit CollectEgressBridgedFields(const PhvInfo &p) : phv(p) {}
 
    ordered_map<cstring, cstring> bridged_to_orig;
 
    Visitor::profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::BFN::Extract *extract) override;
    void end_apply() override;
};
 
class GatherParserExtracts : public Inspector {
 public:
    using FieldToFieldSet = ordered_map<const PHV::Field *, ordered_set<const PHV::Field *>>;
 
 private:
    const PhvInfo &phv;
    FieldToFieldSet parserAlignedFields;
    FieldToFieldSet reverseParserAlignMap;
 
    profile_t init_apply(const IR::Node *root) override {
        parserAlignedFields.clear();
        reverseParserAlignMap.clear();
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::BFN::Extract *e) override;
 
 public:
    explicit GatherParserExtracts(const PhvInfo &p) : phv(p) {}
 
    bool count(const PHV::Field *f) const { return parserAlignedFields.count(f); }
 
    const ordered_set<const PHV::Field *> &at(const PHV::Field *f) const {
        static ordered_set<const PHV::Field *> emptySet;
        if (!parserAlignedFields.count(f)) return emptySet;
        return parserAlignedFields.at(f);
    }
 
    bool revCount(const PHV::Field *f) const { return reverseParserAlignMap.count(f); }
 
    const ordered_set<const PHV::Field *> &revAt(const PHV::Field *f) const {
        static ordered_set<const PHV::Field *> emptySet;
        if (!reverseParserAlignMap.count(f)) return emptySet;
        return reverseParserAlignMap.at(f);
    }
 
    const FieldToFieldSet &getAlignedMap() const { return parserAlignedFields; }
    const FieldToFieldSet &getReverseMap() const { return reverseParserAlignMap; }
};
 
template <typename NodeType, typename Func, typename Func2>
void forAllMatchingDoPreAndPostOrder(const IR::Node *root, Func &&function, Func2 &&function2) {
    struct NodeVisitor : public Inspector {
        explicit NodeVisitor(Func &&function, Func2 &&function2)
            : function(function), function2(function2) {}
        Func function;
        Func2 function2;
        bool preorder(const NodeType *node) override {
            function(node);
            return true;
        }
        void postorder(const NodeType *node) override { function2(node); }
    };
    root->apply(NodeVisitor(std::forward<Func>(function), std::forward<Func2>(function2)));
}
 
template <typename NodeType, typename Func>
void forAllMatchingDoPostOrder(const IR::Node *root, Func &&function) {
    struct NodeVisitor : public Inspector {
        explicit NodeVisitor(Func &&function) : function(function) {}
        Func function;
        void postorder(const NodeType *node) override { function(node); }
    };
    root->apply(NodeVisitor(std::forward<Func>(function)));
}
 
class GatherDigestFields : public Inspector {
 public:
    using FieldToFieldSet = ordered_map<const PHV::Field *, ordered_set<const PHV::Field *>>;
 
 private:
    const PhvInfo &phv;
    ordered_map<cstring, ordered_set<std::vector<const PHV::Field *>>> headers;
    ordered_map<cstring, ordered_set<std::vector<const PHV::Field *>>> digests;
    FieldToFieldSet digestFieldMap;
    FieldToFieldSet reverseDigestFieldMap;
 
    const FieldToFieldSet &getDigestMap() const { return digestFieldMap; }
    const FieldToFieldSet &getReverseDigestMap() const { return reverseDigestFieldMap; }
 
 public:
    explicit GatherDigestFields(const PhvInfo &p) : phv(p) {}
    bool preorder(const IR::BFN::DigestFieldList *fl) override;
    bool preorder(const IR::HeaderOrMetadata *hdr) override;
    void end_apply() override;
};
 
class CollectConstraints : public Inspector {
    PhvInfo &phv;
 
    struct Constraints {
        // collected alignment constraints;
        ordered_map<const PHV::Field *, ordered_set<AlignmentConstraint>> alignment;
        // two field must have the same constraint, exact value to be determined by solver.
        ordered_map<const PHV::Field *, std::vector<const PHV::Field *>> mutualAlignment;
 
        ordered_set<std::pair<const PHV::Field *, const PHV::Field *>> mustPack;
        ordered_set<std::pair<const PHV::Field *, SolitaryConstraint::SolitaryReason>> noPack;
    };
    Constraints constraints;
 
    const CollectIngressBridgedFields &ingressBridgedFields;
    const CollectEgressBridgedFields &egressBridgedFields;
    const GatherParserExtracts &parserAlignedFields;
    const GatherDigestFields &digestFields;
    const ActionPhvConstraints &actionConstraints;
 
    // determine alignment constraint on a single field.
    cstring getOppositeGressFieldName(cstring);
    cstring getEgressFieldName(cstring);
 
    ordered_set<const PHV::Field *> findAllRelatedFields(const PHV::Field *f);
    ordered_set<const PHV::Field *> findAllReachingFields(const PHV::Field *f);
    ordered_set<const PHV::Field *> findAllSourcingFields(const PHV::Field *f);
    ordered_set<const PHV::Field *> findAllRelatedFieldsOfCopackedFields(const PHV::Field *f);
    void computeAlignmentConstraint(const ordered_set<const PHV::Field *> &, bool);
 
    bool mustPack(const ordered_set<const PHV::Field *> &, const ordered_set<const PHV::Field *> &,
                  const ordered_set<const IR::MAU::Action *> &);
    void computeMustPackConstraints(const ordered_set<const PHV::Field *> &, bool);
 
    void computeNoPackIfIntrinsicMeta(const ordered_set<const PHV::Field *> &, bool);
    void computeNoPackIfActionDataWrite(const ordered_set<const PHV::Field *> &, bool);
    void computeNoPackIfSpecialityRead(const ordered_set<const PHV::Field *> &, bool);
    void computeNoPackIfDigestUse(const ordered_set<const PHV::Field *> &, bool);
    void computeNoSplitConstraints(const ordered_set<const PHV::Field *> &, bool);
 
    bool preorder(const IR::HeaderOrMetadata *) override;
    bool preorder(const IR::BFN::DigestFieldList *) override;
    profile_t init_apply(const IR::Node *root) override;
    void end_apply() override;
 
    template <typename NodeType, typename Func, typename Func2>
    void forAllMatching(const IR::Node *root, Func &&function, Func2 &&function2) {
        struct NodeVisitor : public Inspector {
            explicit NodeVisitor(Func &&function, Func2 &&function2)
                : function(function), function2(function2) {}
            Func function;
            Func2 function2;
            bool preorder(const NodeType *node) override {
                function(node);
                return true;
            }
            void postorder(const NodeType *node) override { function2(node); }
        };
        root->apply(NodeVisitor(std::forward<Func>(function), std::forward<Func2>(function2)));
    }
 
 public:
    explicit CollectConstraints(PhvInfo &p, const CollectIngressBridgedFields &b,
                                const CollectEgressBridgedFields &e, const GatherParserExtracts &g,
                                const GatherDigestFields &d, const ActionPhvConstraints &a)
        : phv(p),
          ingressBridgedFields(b),
          egressBridgedFields(e),
          parserAlignedFields(g),
          digestFields(d),
          actionConstraints(a) {}
};
 
class GatherAlignmentConstraints : public PassManager {
 private:
    CollectIngressBridgedFields collectIngressBridgedFields;
    CollectEgressBridgedFields collectEgressBridgedFields;
    GatherParserExtracts collectParserAlignedFields;
    GatherDigestFields collectDigestFields;  // Outputs currently not used
 
 public:
    GatherAlignmentConstraints(PhvInfo &p, const ActionPhvConstraints &a)
        : collectIngressBridgedFields(p),
          collectEgressBridgedFields(p),
          collectParserAlignedFields(p),
          collectDigestFields(p) {
        addPasses({
            &collectIngressBridgedFields,
            &collectEgressBridgedFields,
            &collectParserAlignedFields,
            &collectDigestFields,
            new CollectConstraints(p, collectIngressBridgedFields, collectEgressBridgedFields,
                                   collectParserAlignedFields, collectDigestFields, a),
        });
    }
};
 
class ConstraintSolver {
    const PhvInfo &phv;
    z3::context &context;
    z3::optimize &solver;
    PackingConstraints &packingConstraints;
    AllConstraints &constraints;
    DebugInfo &debug_info;
 
    void add_field_alignment_constraints(cstring, const PHV::Field *, int);
    void add_non_overlap_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_extract_together_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_solitary_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_deparsed_to_tm_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_no_pack_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_no_split_constraints(cstring, ordered_set<const PHV::Field *> &);
 
    const PHV::Field *create_padding(int size);
    std::vector<const PHV::Field *> insert_padding(std::vector<std::pair<unsigned, std::string>> &);
 
    void dump_unsat_core();
 
 public:
    explicit ConstraintSolver(const PhvInfo &p, z3::context &context, z3::optimize &solver,
                              PackingConstraints &pc, AllConstraints &constraints, DebugInfo &dbg)
        : phv(p),
          context(context),
          solver(solver),
          packingConstraints(pc),
          constraints(constraints),
          debug_info(dbg) {}
 
    void add_constraints(cstring, ordered_set<const PHV::Field *> &);
    void add_mutually_aligned_constraints(ordered_set<const PHV::Field *> &);
    ordered_map<cstring, std::vector<const PHV::Field *>> solve(
        ordered_map<cstring, ordered_set<const PHV::Field *>> &);
 
    void print_assertions();
};
 
class PackWithConstraintSolver : public Inspector {
    const PhvInfo &phv;
    ConstraintSolver &solver;
    const ordered_set<cstring> &candidates;
 
    ordered_map<cstring, const IR::Type_StructLike *> &repackedTypes;
 
    ordered_map<cstring, ordered_set<const PHV::Field *>> nonByteAlignedFieldsMap;
    ordered_map<cstring, ordered_set<const PHV::Field *>> byteAlignedFieldsMap;
    // XXX: make this a ordered_map<cstring, IR::StructField>
    ordered_map<cstring, ordered_map<const PHV::Field *, const IR::StructField *>>
        phvFieldToStructFieldMap;
 
    ordered_map<cstring, ordered_map<cstring, const IR::StructField *>> pathToStructFieldMap;
 
    PackingCandidateFields &packingCandidateFields;
    PackingConstraints &packingConstraints;
 
    ordered_map<cstring, const IR::Type_StructLike *> headerMap;
 
    // Pipeline name for printing debug messages
    cstring pipelineName;
 
 public:
    explicit PackWithConstraintSolver(const PhvInfo &p, ConstraintSolver &solver,
                                      const ordered_set<cstring> &c,
                                      ordered_map<cstring, const IR::Type_StructLike *> &r,
                                      PackingCandidateFields &pcf, PackingConstraints &pc)
        : phv(p),
          solver(solver),
          candidates(c),
          repackedTypes(r),
          packingCandidateFields(pcf),
          packingConstraints(pc) {}
 
    Visitor::profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::HeaderOrMetadata *hdr) override;
    bool preorder(const IR::BFN::DigestFieldList *dfl) override;
    void end_apply() override;
 
    void set_pipeline_name(cstring name) { pipelineName = name; }
    void optimize();
    void solve();
};
 
class PadFixedSizeHeaders : public Inspector {
    ordered_map<cstring, const IR::Type_StructLike *> &repackedTypes;
 
 public:
    explicit PadFixedSizeHeaders(ordered_map<cstring, const IR::Type_StructLike *> &r)
        : repackedTypes(r) {}
 
    bool preorder(const IR::BFN::Type_FixedSizeHeader *h) override {
        auto width = [&](const IR::Type_StructLike *s) -> int {
            int rv = 0;
            for (auto f : s->fields) rv += f->type->width_bits();
            return rv;
        };
 
        auto countPadding = [&](const IR::IndexedVector<IR::StructField> &fields) -> int {
            int count = 0;
            for (auto f : fields)
                if (f->hasAnnotation("padding"_cs)) count++;
 
            return count;
        };
 
        auto genPadding = [&](int size, int id) {
            cstring padFieldName = "__pad_" + cstring::to_cstring(id);
            const IR::StructField *padField =
                new IR::StructField(padFieldName,
                                    {new IR::Annotation(IR::ID("padding"), {}),
                                     new IR::Annotation(IR::ID("overlayable"), {})},
                                    IR::Type::Bits::get(size));
            return padField;
        };
 
        size_t bits = static_cast<size_t>(width(h));
        ERROR_CHECK(bits <= Device::pardeSpec().bitResubmitSize(), "%1% digest limited to %2% bits",
                    h->name, Device::pardeSpec().bitResubmitSize());
        auto pad_size = h->fixed_size - bits;
 
        auto fields = new IR::IndexedVector<IR::StructField>();
        fields->append(h->fields);
        auto index = countPadding(h->fields);
        if (pad_size != 0) {
            auto padding = genPadding(pad_size, index++);
            fields->push_back(padding);
        }
 
        auto newType = new IR::Type_Header(h->name, *fields);
        repackedTypes.emplace(h->name, newType);
        return false;
    }
};
 
class ReplaceFlexibleType : public Transform {
    const RepackedHeaderTypes &repackedTypes;
 
 public:
    explicit ReplaceFlexibleType(const RepackedHeaderTypes &m) : repackedTypes(m) {}
 
    // if used in backend
    const IR::Node *postorder(IR::HeaderOrMetadata *h) override;
    const IR::Node *postorder(IR::BFN::DigestFieldList *d) override;
    const IR::BFN::DigestFieldList *repackFieldList(
        cstring digest, std::vector<FieldListEntry> repackedFieldIndices,
        const IR::Type_StructLike *repackedHeaderType,
        const IR::BFN::DigestFieldList *origFieldList) const;
 
    // if used in midend
    const IR::Node *postorder(IR::Type_StructLike *h) override;
    const IR::Node *postorder(IR::StructExpression *h) override;
};
 
bool findFlexibleAnnotation(const IR::Type_StructLike *);
 
class GatherDeparserParameters : public Inspector {
 private:
    const PhvInfo &phv;
    ordered_set<const PHV::Field *> &params;
 
    profile_t init_apply(const IR::Node *root) override {
        params.clear();
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::BFN::DeparserParameter *p) override;
 
 public:
    explicit GatherDeparserParameters(const PhvInfo &p, ordered_set<const PHV::Field *> &f)
        : phv(p), params(f) {}
};
 
class GatherPhase0Fields : public Inspector {
 private:
    const PhvInfo &phv;
    ordered_set<const PHV::Field *> &noPackFields;
    static constexpr char const *PHASE0_PARSER_STATE_NAME = "ingress::$phase0";
 
    profile_t init_apply(const IR::Node *root) override {
        noPackFields.clear();
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::BFN::ParserState *p) override;
 
    bool preorder(const IR::BFN::DigestFieldList *d) override;
 
 public:
    explicit GatherPhase0Fields(const PhvInfo &p, ordered_set<const PHV::Field *> &f)
        : phv(p), noPackFields(f) {}
};
 
// set of variables for bridged fields (pretty print)
// set of constraints for bridged fields
// helper function to convert between PHV::Field to z3::expr
// constraints are objects on PHV fields
// constraints can be pretty_printed, encoded to z3
class LogRepackedHeaders : public Inspector {
 private:
    // Need this for field names
    const PhvInfo &phv;
    // Contains all of the (potentially) repacked headers
    RepackedHeaders repacked;
    // All headers we have seen before, but with "egress" or "ingress" removed (avoid duplication)
    std::unordered_set<std::string> hdrs;
 
    // Collects all headers/metadatas that may have been repacked (i.e. have a field that is
    // flexible)
    bool preorder(const IR::HeaderOrMetadata *h) override;
 
    // Pretty print all of the flexible headers
    void end_apply() override;
 
    // Returns the full field name
    std::string getFieldName(std::string hdr, const IR::StructField *field) const;
 
    // Pretty prints a single header/metadata
    std::string pretty_print(const IR::HeaderOrMetadata *h, std::string hdr) const;
 
    // Strips the given prefix from the front of the cstring, returns as string
    std::string strip_prefix(cstring str, std::string pre);
 
 public:
    explicit LogRepackedHeaders(const PhvInfo &p) : phv(p) {}
 
    std::string asm_output() const;
};
 
class LogFlexiblePacking : public Logging::PassManager {
    LogRepackedHeaders *flexibleLogging;
 
 public:
    explicit LogFlexiblePacking(const PhvInfo &phv)
        : Logging::PassManager("flexible_packing"_cs, Logging::Mode::AUTO) {
        flexibleLogging = new LogRepackedHeaders(phv);
        addPasses({
            flexibleLogging,
        });
    }
 
    const LogRepackedHeaders *get_flexible_logging() const { return flexibleLogging; }
};
 
class GatherPackingConstraintFromSinglePipeline : public PassManager {
 private:
    const BFN_Options &options;
    MauBacktracker table_alloc;
    PragmaNoPack pa_no_pack;
    PackConflicts packConflicts;
    MapTablesToActions tableActionsMap;
    ActionPhvConstraints actionConstraints;
    SymBitMatrix doNotPack;
    TablesMutuallyExclusive tMutex;
    ActionMutuallyExclusive aMutex;
    ordered_set<const PHV::Field *> noPackFields;
    ordered_set<const PHV::Field *> deparserParams;
 
    // used by solver-based packing
    ordered_set<const PHV::Field *> fieldsToPack;
    PackWithConstraintSolver &packWithConstraintSolver;
 
 public:
    explicit GatherPackingConstraintFromSinglePipeline(PhvInfo &p, const PhvUse &u,
                                                       DependencyGraph &dg, const BFN_Options &o,
                                                       PackWithConstraintSolver &sol);
 
    // Return a Json representation of flexible headers to be saved in .bfa/context.json
    // must be called after the pass is applied
    std::string asm_output() const;
};
 
// PackFlexibleHeader manages the global context for packing bridge metadata
// The global context includes:
// - instance of z3 solver and its context
//
// We need to manage the global context at this level is because bridge
// metadata can be used across multiple pipelines in folded pipeline. To
// support folded pipeline, we first collect bridge metadata constraints across
// each pair of ingress/egress, and run z3 solver over the global set of
// constraints over all pairs of ingress&egress pipelines. Therefore, it
// is necessary to maintain z3 context as this level.
class PackFlexibleHeaders : public PassManager {
    std::vector<const IR::BFN::Pipe *> pipe;
    PhvInfo phv;
    PhvUse uses;
    FieldDefUse defuse;
    DependencyGraph deps;
 
    z3::context context;
    z3::optimize solver;
    ConstraintSolver constraint_solver;
    PackWithConstraintSolver packWithConstraintSolver;
    PackingCandidateFields packingCandidateFields;
    PackingConstraints packingConstraints;
    PackedFields packedFields;
    AllConstraints constraints;
 
    cstring pipelineName;
    /* storage for debug log */
    DebugInfo debug_info;
 
    GatherPackingConstraintFromSinglePipeline *flexiblePacking;
 
 public:
    explicit PackFlexibleHeaders(const BFN_Options &options, ordered_set<cstring> &,
                                 RepackedHeaderTypes &repackedTypes);
 
    void set_pipeline_name(cstring name) { pipelineName = name; }
    // encode constraints to z3 expressions
    void optimize() {
        packWithConstraintSolver.set_pipeline_name(pipelineName);
        packWithConstraintSolver.optimize();
    }
    // execute z3 solver to find a solution
    void solve() { packWithConstraintSolver.solve(); }
    // convert the solution to P4 header format
    void end_apply() override;
 
    void print_packing_candidate_fields() const {
        for (auto &[hdr_type, fields] : packingCandidateFields) {
            LOG3("Packing candidate fields for " << hdr_type << ":");
            for (auto f : fields) {
                LOG3("  " << f);
            }
        }
    }
    void check_conflicting_constraints();
};
 
using PipeAndGress = std::pair<std::pair<cstring, gress_t>, std::pair<cstring, gress_t>>;
 
using BridgeLocs = ordered_map<std::pair<cstring, gress_t>, IR::HeaderRef *>;
 
class CollectBridgedFieldsUse : public Inspector {
 public:
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
 
    struct Use {
        const IR::Type *type;
        cstring name;
        cstring method;
        gress_t thread;
 
        bool operator<(const Use &other) const {
            return std::tie(type, name, method, thread) <
                   std::tie(other.type, other.name, other.method, other.thread);
        }
 
        bool operator==(const Use &other) const {
            return std::tie(type, name, method, thread) ==
                   std::tie(other.type, other.name, other.method, other.thread);
        }
    };
 
    ordered_set<Use> bridge_uses;
 
    friend std::ostream &operator<<(std::ostream &, const Use &u);
 
 public:
    CollectBridgedFieldsUse(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {}
 
    void postorder(const IR::MethodCallExpression *mc) override;
};
 
struct BridgeContext {
    int pipe_id;
    CollectBridgedFieldsUse::Use use;
    IR::BFN::Pipe::thread_t thread;
};
 
class ExtractBridgeInfo : public Inspector {
    const BFN_Options &options;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    BFN::BackendConverter *conv;
    ParamBinding *bindings;
    RepackedHeaderTypes &map;
    CollectGlobalPragma collect_pragma;
 
 public:
    ordered_map<int, ordered_set<CollectBridgedFieldsUse::Use>> all_uses;
 
    ExtractBridgeInfo(BFN_Options &options, P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                      BFN::BackendConverter *conv, ParamBinding *bindings, RepackedHeaderTypes &ht)
        : options(options),
          refMap(refMap),
          typeMap(typeMap),
          conv(conv),
          bindings(bindings),
          map(ht) {}
 
    std::vector<const IR::BFN::Pipe *> *generate_bridge_pairs(std::vector<BridgeContext> &);
 
    bool preorder(const IR::P4Program *program) override;
    void end_apply(const IR::Node *) override;
};
 
class BridgedPacking : public PassManager {
    ParamBinding *bindings;
    BFN::ApplyEvaluator *evaluator;
    BFN::BackendConverter *conv;
    RepackedHeaderTypes &map;
    ExtractBridgeInfo *extractBridgeInfo;
 
 public:
    P4::ReferenceMap refMap;
    P4::TypeMap typeMap;
 
 public:
    BridgedPacking(BFN_Options &options, RepackedHeaderTypes &repackMap,
                   CollectSourceInfoLogging &sourceInfoLogging);
 
    IR::Vector<IR::BFN::Pipe> pipe;
    ordered_map<int, const IR::BFN::Pipe *> pipes;
};
 
class SubstitutePackedHeaders : public PassManager {
    ParamBinding *bindings;
    BFN::ApplyEvaluator *evaluator;
    BFN::BackendConverter *conv;
 
 public:
    P4::ReferenceMap refMap;
    P4::TypeMap typeMap;
    IR::Vector<IR::BFN::Pipe> pipe;
    ordered_map<int, const IR::BFN::Pipe *> pipes;
 
 public:
    SubstitutePackedHeaders(BFN_Options &options, const RepackedHeaderTypes &repackedMap,
                            CollectSourceInfoLogging &sourceInfoLogging);
    const BFN::ProgramPipelines &getPipelines() const { return conv->getPipelines(); }
    const IR::ToplevelBlock *getToplevelBlock() const { return evaluator->toplevel; }
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_COMMON_BRIDGED_PACKING_H_ */