deparser_zero.h

 
#ifndef BF_P4C_PHV_ANALYSIS_DEPARSER_ZERO_H_
#define BF_P4C_PHV_ANALYSIS_DEPARSER_ZERO_H_
 
#include <optional>
 
#include "backends/tofino/bf-p4c/common/field_defuse.h"
#include "backends/tofino/bf-p4c/mau/action_analysis.h"
#include "backends/tofino/bf-p4c/parde/clot/clot_info.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "backends/tofino/bf-p4c/phv/pragma/pa_deparser_zero.h"
#include "backends/tofino/bf-p4c/phv/utils/utils.h"
#include "ir/ir.h"

class IdentifyDeparserZeroCandidates : public Inspector {
 private:
    PhvInfo &phv;
    const FieldDefUse &defuse;
    const ReductionOrInfo &red_info;
    const PragmaDeparserZero &pragmaFields;
    ordered_set<const PHV::Field *> &candidateFields;

    bitvec mauReadFields;
    bitvec mauWrittenFields;
    bitvec mauWrittenToZeroFields;
    bitvec mauWrittenToNonZeroFields;
    bitvec mauWrittenByNonSets;

    void eliminateNonByteAlignedFields();
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::MAU::Action *act) override;
    bool preorder(const IR::BFN::DigestFieldList *) override;
    void end_apply() override;
 
 public:
    explicit IdentifyDeparserZeroCandidates(PhvInfo &p, const FieldDefUse &d,
                                            const ReductionOrInfo &ri, const PragmaDeparserZero &f,
                                            ordered_set<const PHV::Field *> &c)
        : phv(p), defuse(d), red_info(ri), pragmaFields(f), candidateFields(c) {}
};
class IdentifyDeparserZeroCandidates : public Inspector {…};

class ImplementDeparserZero : public Transform {
 private:
    PhvInfo &phv;
    const ordered_set<const PHV::Field *> &candidateFields;
    const ClotInfo &clots;
 
    IR::Node *preorder(IR::BFN::Extract *extract) override;
    IR::Node *preorder(IR::MAU::Instruction *inst) override;
 
 public:
    explicit ImplementDeparserZero(PhvInfo &p, const ordered_set<const PHV::Field *> &c,
                                   const ClotInfo &ci)
        : phv(p), candidateFields(c), clots(ci) {}
};
class ImplementDeparserZero : public Transform {…};
 
class DeparserZeroOptimization : public PassManager {
 private:
    ordered_set<const PHV::Field *> candidateFields;
 
 public:
    explicit DeparserZeroOptimization(PhvInfo &p, const FieldDefUse &d, const ReductionOrInfo &ri,
                                      const PragmaDeparserZero &pf, const ClotInfo &c);
};
class DeparserZeroOptimization : public PassManager {…};
 
#endif /* BF_P4C_PHV_ANALYSIS_DEPARSER_ZERO_H_ */