finalize_physical_liverange.h

 
#ifndef BF_P4C_PHV_FINALIZE_PHYSICAL_LIVERANGE_H_
#define BF_P4C_PHV_FINALIZE_PHYSICAL_LIVERANGE_H_
 
#include "backends/tofino/bf-p4c/common/field_defuse.h"
#include "backends/tofino/bf-p4c/ir/tofino_write_context.h"
#include "backends/tofino/bf-p4c/mau/table_mutex.h"
#include "backends/tofino/bf-p4c/parde/clot/clot_info.h"
#include "backends/tofino/bf-p4c/phv/phv.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "backends/tofino/bf-p4c/phv/pragma/pa_no_init.h"
#include "ir/ir.h"
 
namespace PHV {
 
class FinalizePhysicalLiverange : public Inspector, TofinoWriteContext {
 private:
    PhvInfo &phv_i;
    const ClotInfo &clot_i;
    // used to verify overlapped live ranges for overlaying but non-mutex fields.
    const TablesMutuallyExclusive &tb_mutex_i;
    const FieldDefUse &defuse_i;
    const BFN::HeaderStackInfo *headerStacks = nullptr;
 
    ordered_map<AllocSlice, LiveRange> live_ranges_i;
    ordered_set<const IR::MAU::Table *> tables_i;
    ordered_map<cstring, std::set<int>> table_stages_i;
    ordered_map<const PHV::Field *, LiveRange> temp_var_live_ranges_i;
 
    const PragmaNoInit &pa_no_init;
 
    void mark_access(const PHV::Field *f, le_bitrange bits, const IR::BFN::Unit *unit,
                     bool is_write, bool allow_unallocated = false);
 
    void update_liverange(const safe_vector<AllocSlice> &slices, const StageAndAccess &op);
 
 protected:
    profile_t init_apply(const IR::Node *root) override {
        live_ranges_i.clear();
        tables_i.clear();
        table_stages_i.clear();
        temp_var_live_ranges_i.clear();
 
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::BFN::Pipe *pipe) override;
 
    bool preorder(const IR::BFN::ParserState *) override {
        visitOnce();
        return true;
    }
 
    bool preorder(const IR::BFN::Extract *extract) override;
 
    bool preorder(const IR::MAU::Table *t) override;
 
    bool preorder(const IR::Expression *e) override;
 
    void end_apply() override;
 
 public:
    explicit FinalizePhysicalLiverange(PhvInfo &phv, const ClotInfo &clot,
                                       const TablesMutuallyExclusive &tb_mutex,
                                       const FieldDefUse &defuse, const PragmaNoInit &pa_no_init)
        : phv_i(phv), clot_i(clot), tb_mutex_i(tb_mutex), defuse_i(defuse), pa_no_init(pa_no_init) {
        visitDagOnce = false;
    }
 
    const ordered_map<const PHV::Field *, LiveRange> &unallocated_temp_var_live_ranges() const {
        return temp_var_live_ranges_i;
    }
};
 
}  // namespace PHV
 
#endif /* BF_P4C_PHV_FINALIZE_PHYSICAL_LIVERANGE_H_ */