check_parser_multi_write.h

 
#ifndef BF_P4C_PARDE_CHECK_PARSER_MULTI_WRITE_H_
#define BF_P4C_PARDE_CHECK_PARSER_MULTI_WRITE_H_
 
#include <ir/ir.h>
 
#include "bf-p4c/parde/parde_visitor.h"
#include "bf-p4c/parde/parser_info.h"
#include "bf-p4c/parde/parser_query.h"
#include "ir/pass_manager.h"
 
using namespace P4;
 
struct CheckParserMultiWrite : public PassManager {
    const PhvInfo &phv;
 
    explicit CheckParserMultiWrite(const PhvInfo &phv);
};
 
class PhvInfo;
class MapFieldToParserStates;
 
struct CheckWriteModeConsistency : public ParserTransform {
 protected:
    const PhvInfo &phv;
    const MapFieldToParserStates &field_to_states;
    const ParserQuery pq;
 
    std::map<const IR::BFN::ParserPrimitive *, IR::BFN::ParserWriteMode> extract_to_write_mode;
    std::map<std::pair<PHV::FieldSlice, PHV::FieldSlice>, bool> compatability;
 
    bool check(const std::vector<const IR::BFN::Extract *> extracts) const;
 
    void check_and_adjust(const std::vector<const IR::BFN::Extract *> extracts);
 
    void check_pre_alloc(const ordered_set<const IR::BFN::ParserPrimitive *> &state_writes);
 
    void check_post_alloc();
 
    profile_t init_apply(const IR::Node *root) override;
    IR::Node *preorder(IR::BFN::Extract *extract) override;
    IR::Node *preorder(IR::BFN::ParserChecksumWritePrimitive *pcw) override;
 
    template <typename T>
    IR::Node *set_write_mode(T *write);
 
 public:
    CheckWriteModeConsistency(const PhvInfo &p, const MapFieldToParserStates &fs,
                              const CollectParserInfo &pi)
        : phv(p), field_to_states(fs), pq(pi, fs) {}
 
    bool check_compatability(const PHV::FieldSlice &slice_a, const PHV::FieldSlice &slice_b);
};
 
#endif /*BF_P4C_PARDE_CHECK_PARSER_MULTI_WRITE_H_*/