phv_parde_mau_use.h

 
#ifndef BF_P4C_PHV_PHV_PARDE_MAU_USE_H_
#define BF_P4C_PHV_PHV_PARDE_MAU_USE_H_
 
#include "backends/tofino/bf-p4c/common/header_stack.h"
#include "backends/tofino/bf-p4c/ir/bitrange.h"
#include "backends/tofino/bf-p4c/ir/gress.h"
#include "backends/tofino/bf-p4c/ir/thread_visitor.h"
#include "backends/tofino/bf-p4c/ir/tofino_write_context.h"
#include "backends/tofino/bf-p4c/phv/phv.h"
#include "ir/ir.h"
 
using namespace P4;
 
namespace PHV {
class Field;
}  // namespace PHV
 
class PhvInfo;
 
class Phv_Parde_Mau_Use : public Inspector, public TofinoWriteContext {
    using FieldToRangeMap = ordered_map<const PHV::Field *, ordered_set<le_bitrange>>;
    using FieldIdToRangeMap = ordered_map<int, ordered_set<le_bitrange>>;
 
    FieldIdToRangeMap written_i;
 
    FieldIdToRangeMap used_alu_i;
 
    ordered_map<
        const PHV::Field *,
        ordered_map<le_bitrange,
                    ordered_set<std::pair<const IR::MAU::Table *, const IR::MAU::TableKey *>>>>
        ixbar_read_i;
 
    ordered_set<const PHV::Field *> learning_reads_i;
 
    bitvec extracted_i[GRESS_T_COUNT];
 
    bitvec extracted_from_pkt_i[GRESS_T_COUNT];
 
    bitvec extracted_from_const_i[GRESS_T_COUNT];
 
    enum { PARDE = 0, MAU = 1 };
 
 public:
    ordered_map<int, ordered_map<unsigned, ordered_set<le_bitrange>>> use_i;
 
    bitvec deparser_i[GRESS_T_COUNT];
    /*                |    ^- gress               */
    /*                 == use in deparser         */
 
    explicit Phv_Parde_Mau_Use(const PhvInfo &p) : phv(p) {}
 
    bool is_referenced(const PHV::Field *f) const;
 
    bool is_deparsed(const PHV::Field *f) const;
 
    bool is_used_mau(const PHV::Field *f) const;
    bool is_used_mau(const PHV::Field *f, le_bitrange range) const;
 
    bool is_written_mau(const PHV::Field *f) const;
 
    bool is_used_alu(const PHV::Field *f) const;
 
    bool is_used_parde(const PHV::Field *f) const;
 
    bool is_extracted(const PHV::Field *f, std::optional<gress_t> gress = std::nullopt) const;
 
    bool is_extracted_from_pkt(const PHV::Field *f,
                               std::optional<gress_t> gress = std::nullopt) const;
 
    bool is_extracted_from_constant(const PHV::Field *f,
                                    std::optional<gress_t> gress = std::nullopt) const;
 
    bool is_allocation_required(const PHV::Field *f) const;
 
    bool is_learning(const PHV::Field *f) const { return learning_reads_i.count(f); };
 
    ordered_set<std::pair<const IR::MAU::Table *, const IR::MAU::TableKey *>> ixbar_read(
        const PHV::Field *f, le_bitrange range) const;
 
 protected:
    const PhvInfo &phv;
    gress_t thread = INGRESS;
    bool in_mau = false;
    bool in_dep = false;
 
 protected:
    profile_t init_apply(const IR::Node *) override;
    bool preorder(const IR::BFN::Parser *) override;
    bool preorder(const IR::BFN::Extract *) override;
    bool preorder(const IR::BFN::ParserChecksumWritePrimitive *) override;
    bool preorder(const IR::BFN::Deparser *) override;
    bool preorder(const IR::BFN::Digest *) override;
    bool preorder(const IR::MAU::TableSeq *) override;
    bool preorder(const IR::MAU::TableKey *) override;
    bool preorder(const IR::Expression *) override;
};
 
class PhvUse : public Phv_Parde_Mau_Use {
 public:
    explicit PhvUse(const PhvInfo &p) : Phv_Parde_Mau_Use(p) {}
 
 private:
    bool preorder(const IR::BFN::Deparser *d) override;
    bool preorder(const IR::BFN::DeparserParameter *param) override;
    void postorder(const IR::BFN::DeparserParameter *param) override;
    bool preorder(const IR::BFN::Digest *digest) override;
    void postorder(const IR::BFN::Digest *digest) override;
};
 
#endif /* BF_P4C_PHV_PHV_PARDE_MAU_USE_H_ */