action_phv_constraints.h

 
#ifndef BF_P4C_PHV_ACTION_PHV_CONSTRAINTS_H_
#define BF_P4C_PHV_ACTION_PHV_CONSTRAINTS_H_
 
#include <optional>
 
#include "backends/tofino/bf-p4c/common/map_tables_to_actions.h"
#include "backends/tofino/bf-p4c/ir/bitrange.h"
#include "backends/tofino/bf-p4c/lib/union_find.hpp"
#include "backends/tofino/bf-p4c/mau/action_analysis.h"
#include "backends/tofino/bf-p4c/mau/table_dependency_graph.h"
#include "backends/tofino/bf-p4c/phv/analysis/pack_conflicts.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "backends/tofino/bf-p4c/phv/phv_parde_mau_use.h"
#include "backends/tofino/bf-p4c/phv/utils/utils.h"
#include "ir/ir.h"
#include "lib/safe_vector.h"
 
using ::P4::operator<<;
 
struct ActionPhvConstraintLogging {
    int error;
};

struct ActionPhvConstraintCanPack {
    std::optional<ActionPhvConstraintLogging> logging;
    std::optional<PHV::Allocation::ConditionalConstraint> conditional_constraints;
};
 
enum class CanPackErrorCode : unsigned {
    NO_ERROR = 0,
    SLICE_EMPTY = 1,
    PACK_CONSTRAINT_PRESENT = 2,
    STATEFUL_DEST_CONSTRAINT = 3,
    BITMASK_CONSTRAINT = 4,
    SPECIALTY_DATA = 5,
    MIXED_OPERAND = 6,
    NONE_ADJACENT_FIELD = 7,
    COMPLEX_AD_PACKING = 8,
    BITWISE_MIXED_AD = 9,
    TF2_MORE_THAN_ONE_SOURCE = 10,
    TF2_ALL_WRITTEN_TOGETHER = 11,
    MORE_THAN_TWO_SOURCES = 12,
    TWO_SOURCES_AND_CONSTANT = 13,
    MOVE_AND_UNALLOCATED_SOURCE = 14,
    BITWISE_AND_UNALLOCATED_SOURCE = 15,
    SLICE_ALIGNMENT = 16,
    PACK_AND_ALIGNED = 17,
    INVALID_MASK = 18,
    SLICE_DIFF_OFFSET = 19,
    COPACK_UNSATISFIED = 20,
    MULTIPLE_ALIGNMENTS = 21,
    OVERLAPPING_SLICES = 22,
    CONSTRAINT_CHECKER_FAILED = 23,
};
 
std::ostream &operator<<(std::ostream &out, const CanPackErrorCode &info);
 
using CanPackReturnType =
    std::tuple<CanPackErrorCode, std::optional<PHV::Allocation::ConditionalConstraints>>;

struct CanPackErrorV2 {
    CanPackErrorCode code;
    cstring msg;
    bool remove_align_req = false;
    const std::vector<PHV::AllocSlice> *invalid_dest_packing = nullptr;
    CanPackErrorV2(CanPackErrorCode code) : code(code) {}  // NOLINT
    CanPackErrorV2(CanPackErrorCode code, bool clear_align)
        : code(code), remove_align_req(clear_align) {}
    CanPackErrorV2(CanPackErrorCode code, cstring msg) : code(code), msg(msg) {}
    CanPackErrorV2(CanPackErrorCode code, cstring msg,
                   const std::vector<PHV::AllocSlice> *dest_cont)
        : code(code), msg(msg), invalid_dest_packing(dest_cont) {}
    bool ok() const { return code == CanPackErrorCode::NO_ERROR; }
};

class ActionPhvConstraints : public Inspector {
 private:
    const PhvInfo &phv;
    const PhvUse &uses;
    const PackConflicts &conflicts;
    const MapTablesToActions &tableActionsMap;
    const DependencyGraph &dg;
 
    ordered_map<const PHV::Field *, ordered_set<const PHV::Field *>> same_byte_fields;
 
    bool prelim_constraints_ok = true;
 
    struct ClassifiedSource {
        bool exist = false;
        PHV::Container container;
        ordered_set<PHV::AllocSlice> slices = {};
        bool aligned = true;
        int offset = 0;
    };
    friend std::ostream &operator<<(std::ostream &out,
                                    const ActionPhvConstraints::ClassifiedSource &src);
 
    using ClassifiedSources = std::array<ClassifiedSource, 2>;
 
    using PackingConstraints = ordered_map<const IR::MAU::Action *, UnionFind<PHV::FieldSlice>>;
    struct NumContainers {
        size_t num_allocated;
        size_t num_unallocated;
        bool double_unallocated = false;
 
        explicit NumContainers(const size_t numAlloc, const size_t numUnalloc)
            : num_allocated(numAlloc), num_unallocated(numUnalloc) {}
 
        NumContainers() : num_allocated(0), num_unallocated(0) {}
    };
 
    typedef enum action_data_uses_t {
        SOME_AD_CONSTANT = 0,
        ALL_AD_CONSTANT = 1,
        COMPLEX_AD_PACKING_REQ = 2,
        NO_AD_CONSTANT = 3
    } ActionDataUses;

    // TODO: Will we ever need a boolean indicating read or write in this
    // struct?
    struct OperandInfo {
        int unique_action_id = -1;
        enum field_read_flags_t {
            MOVE = 1,
            BITWISE = (1 << 1),
            WHOLE_CONTAINER = (1 << 2),
            ANOTHER_OPERAND = (1 << 3),
            MIXED = (1 << 4),
            WHOLE_CONTAINER_SAME_FIELD = (1 << 5),
            PART_OF_CONTAINER = (1 << 6),
        };
        uint8_t flags = 0;
 
        // An operand is either action data (ad), a constant (constant), or
        // drawn from a PHV container (phv_used).
        bool ad = false;
        unsigned special_ad = ActionAnalysis::ActionParam::NO_SPECIAL;
        bool constant = false;
        int64_t const_value = 0;
        std::optional<PHV::FieldSlice> phv_used = std::nullopt;
        cstring action_name;
        cstring operation;
 
        bool operator<(OperandInfo other) const {
            // TODO: What if ad == other.ad?
            if (ad && !other.ad)
                return true;
            else if (!ad && other.ad)
                return false;
            else if (constant && !other.constant)
                return true;
            else if (!constant && other.constant)
                return false;
            else if (constant && other.constant)
                return const_value < other.const_value;
            else if (phv_used && !other.phv_used)
                return true;
            else if (!phv_used && other.phv_used)
                return false;
            else if (!phv_used && !other.phv_used)
                return false;
            else if (phv_used->field()->id != other.phv_used->field()->id)
                return phv_used->field()->id < other.phv_used->field()->id;
            else if (phv_used->range().lo != other.phv_used->range().lo)
                return phv_used->range().lo < other.phv_used->range().lo;
            else
                return phv_used->range().hi < other.phv_used->range().hi;
        }
 
        bool operator==(OperandInfo other) const {
            return phv_used == other.phv_used && ad == other.ad && constant == other.constant &&
                   const_value == other.const_value;
        }
 
        bool operator==(const PHV::Field *field) const {
            return phv_used && phv_used->field()->id == field->id;
        }
 
        std::string toString() const {
            std::stringstream ss;
            ss << *this;
            return ss.str();
        }
 
        explicit OperandInfo(PHV::FieldSlice slice, int id = -1)
            : unique_action_id(id), phv_used(slice) {}
 
        OperandInfo() {}
    };
 
    friend std::ostream &operator<<(std::ostream &out,
                                    const ActionPhvConstraints::OperandInfo &info);
 
    friend std::ostream &operator<<(std::ostream &out,
                                    const safe_vector<ActionPhvConstraints::OperandInfo> &info);
 
    class ConstraintTracker {
        const PhvInfo &phv;
        ActionPhvConstraints &self;

        ordered_map<const PHV::Field *,
                    ordered_map<le_bitrange, ordered_set<const IR::MAU::Action *>>>
            field_writes_to_actions;

        ordered_map<const IR::MAU::Action *, ordered_set<OperandInfo>> action_to_writes;

        ordered_map<const IR::MAU::Action *, ordered_set<PHV::FieldSlice>> action_to_reads;

        ordered_map<const IR::MAU::Action *, const IR::MAU::Table *> action_to_table;

        ordered_map<const PHV::Field *,
                    ordered_map<const IR::MAU::Action *,
                                ordered_map<le_bitrange, std::vector<OperandInfo>>>>
            write_to_reads_per_action;
 
        ordered_map<const PHV::Field *,
                    ordered_map<const IR::MAU::Action *,
                                ordered_map<le_bitrange, ordered_set<PHV::FieldSlice>>>>
            read_to_writes_per_action;

        ordered_map<const PHV::Field *,
                    ordered_map<le_bitrange, ordered_map<const IR::MAU::Action *,
                                                         ordered_set<std::pair<int, int>>>>>
            statefulWrites;

        static int current_action;
 
     public:
        ConstraintTracker(const PhvInfo &phv, ActionPhvConstraints &self) : phv(phv), self(self) {}

        void clear();

        void add_action(const IR::MAU::Action *act,
                        const ActionAnalysis::FieldActionsMap field_actions_map,
                        const IR::MAU::Table *tbl);

        std::optional<bool> hasPHVSource(const PHV::Field *field, const IR::MAU::Action *act) const;

        std::optional<bool> hasActionDataOrConstantSource(const PHV::Field *field,
                                                          const IR::MAU::Action *act) const;

        std::vector<OperandInfo> sources(const PHV::FieldSlice &dst,
                                         const IR::MAU::Action *act) const;

        std::vector<OperandInfo> sources(const PHV::AllocSlice &dst,
                                         const IR::MAU::Action *act) const {
            return sources(PHV::FieldSlice(dst.field(), dst.field_slice()), act);
        }

        ordered_set<PHV::FieldSlice> destinations(PHV::FieldSlice src,
                                                  const IR::MAU::Action *act) const;

        ordered_set<PHV::FieldSlice> destinations(PHV::AllocSlice src,
                                                  const IR::MAU::Action *act) const {
            return destinations(PHV::FieldSlice(src.field(), src.field_slice()), act);
        }

        ordered_set<const IR::MAU::Action *> read_in(PHV::FieldSlice src) const;

        ordered_set<const IR::MAU::Action *> read_in(PHV::AllocSlice src) const {
            return read_in(PHV::FieldSlice(src.field(), src.field_slice()));
        }

        ordered_set<const IR::MAU::Action *> written_in(PHV::FieldSlice dst) const;

        ordered_set<const IR::MAU::Action *> written_in(PHV::AllocSlice dst) const {
            return written_in(PHV::FieldSlice(dst.field(), dst.field_slice()));
        }

        const ordered_set<OperandInfo> &writes(const IR::MAU::Action *act) const;

        const ordered_set<PHV::FieldSlice> &reads(const IR::MAU::Action *act) const;

        std::optional<OperandInfo> is_written(PHV::FieldSlice slice,
                                              const IR::MAU::Action *act) const;

        std::optional<OperandInfo> is_written(PHV::AllocSlice slice,
                                              const IR::MAU::Action *act) const {
            return is_written(PHV::FieldSlice(slice.field(), slice.field_slice()), act);
        }

        ordered_set<int> source_alignment(PHV::AllocSlice dst, PHV::FieldSlice src) const;
 
        std::optional<int> can_be_both_sources(const std::vector<PHV::AllocSlice> &slices,
                                               ordered_set<PHV::FieldSlice> &packing_slices,
                                               PHV::FieldSlice src) const;

        void printMapStates() const;

        void print_field_ordering(const std::vector<PHV::AllocSlice> &slices) const;

        const ordered_map<const PHV::Field *,
                          ordered_map<le_bitrange, ordered_map<const IR::MAU::Action *,
                                                               ordered_set<std::pair<int, int>>>>> &
        getStatefulWrites() const {
            return statefulWrites;
        }

        const IR::MAU::Table *action_table(const IR::MAU::Action *) const;
    };
 
    ConstraintTracker constraint_tracker;

    struct ActionContainerProperty {
        unsigned op_type;
        NumContainers sources;
        bool must_be_aligned;  // a phv source must be aligned
        int num_sources;       // the number of allocated container sources.
        int num_unallocated;   // the number of unallocated slices.
        bool use_ad;           // true if action data is used.

        bool aligned_one_unallocated = false;
        bool aligned_two_unallocated = false;
        bool aligned_unallocated_requires_aligment = false;
    };
 
    using ActionPropertyMap =
        ordered_map<const IR::MAU::Action *, ActionPhvConstraints::ActionContainerProperty>;

    profile_t init_apply(const IR::Node *root) override;

    bool preorder(const IR::MAU::Action *act) override;

    void end_apply() override;
 
    void determine_same_byte_fields();
 
    const ordered_set<PHV::FieldSlice> get_slices_in_same_byte(const PHV::FieldSlice &slice) const;

    bool early_check_ok(const IR::MAU::Action *action);

    UnionFind<PHV::FieldSlice> classify_PHV_sources(
        const ordered_set<PHV::FieldSlice> &phvSlices,
        const ordered_map<PHV::FieldSlice, const PHV::SuperCluster::SliceList *> &lists_map) const;

    bool diagnoseInvalidPacking(
        const IR::MAU::Action *action, const PHV::SuperCluster::SliceList *list,
        const ordered_map<PHV::FieldSlice, unsigned> &fieldAlignments,
        const ordered_map<PHV::FieldSlice, const PHV::SuperCluster::SliceList *> &lists_map,
        std::stringstream &ss) const;

    void throw_too_many_sources_error(
        const ordered_set<PHV::FieldSlice> &actionDataWrittenSlices,
        const ordered_set<PHV::FieldSlice> &notWrittenSlices,
        const UnionFind<PHV::FieldSlice> &phvSources,
        const ordered_map<PHV::FieldSlice, std::pair<int, int>> &phvAlignedSlices,
        const IR::MAU::Action *action, std::stringstream &ss) const;

    void throw_non_contiguous_mask_error(
        const ordered_set<PHV::FieldSlice> &notWrittenSlices,
        const ordered_map<PHV::FieldSlice, ordered_set<PHV::FieldSlice>> &destToSource,
        const ordered_map<PHV::FieldSlice, unsigned> &fieldAlignments, cstring action_name,
        std::stringstream &ss) const;


    NumContainers num_container_sources(const PHV::Allocation &alloc,
                                        const PHV::Allocation::MutuallyLiveSlices &container_state,
                                        const IR::MAU::Action *action) const;

    std::optional<PHV::AllocSlice> getSourcePHVSlice(const PHV::Allocation &alloc,
                                                     const std::vector<PHV::AllocSlice> &slices,
                                                     const PHV::AllocSlice &dst,
                                                     const IR::MAU::Action *action,
                                                     const int stage) const;

    bool has_ad_or_constant_sources(
        const PHV::Allocation::MutuallyLiveSlices &slices, const IR::MAU::Action *action,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    ActionDataUses all_or_none_constant_sources(
        const PHV::Allocation::MutuallyLiveSlices &slices, const IR::MAU::Action *act,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    bool fields_share_container(const PHV::Field *, const PHV::Field *);

    int unallocated_bits(PHV::Allocation::MutuallyLiveSlices, const PHV::Container) const;

    bool are_adjacent_field_slices(const PHV::Allocation::MutuallyLiveSlices &state) const;

    unsigned count_container_holes(const PHV::Allocation::MutuallyLiveSlices &state) const;

    bool valid_container_operation_type(const IR::MAU::Action *act,
                                        const ordered_set<PHV::FieldSlice> &slices,
                                        std::stringstream &ss) const;

    unsigned container_operation_type(const IR::MAU::Action *,
                                      const PHV::Allocation::MutuallyLiveSlices &,
                                      const PHV::Allocation::LiveRangeShrinkingMap &) const;

    bool pack_slices_together(const PHV::Allocation &alloc,
                              const PHV::Allocation::MutuallyLiveSlices &container_state,
                              PackingConstraints *packing_constraints,
                              const IR::MAU::Action *action, bool pack_unallocated_only,
                              bool has_ad_source = false) const;

    std::optional<ClassifiedSources> verify_two_container_alignment(
        const PHV::Allocation &alloc, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const IR::MAU::Action *action, const PHV::Container destination,
        ActionContainerProperty *action_prop) const;

    inline int getOffset(le_bitrange a, le_bitrange b, PHV::Container c) const;

    bool masks_valid(const ClassifiedSources &sources) const;

    bool is_aligned(const PHV::Allocation::MutuallyLiveSlices &container_state,
                    const IR::MAU::Action *act, const PHV::Allocation &alloc) const;

    bool masks_valid(const PHV::Allocation::MutuallyLiveSlices &container_state,
                     const IR::MAU::Action *action, bool actionDataOnly,
                     const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    bool masks_valid(const PHV::Allocation::MutuallyLiveSlices &container_state,
                     const IR::MAU::Action *action) const;

    bool assign_containers_to_unallocated_sources(
        const PHV::Allocation &alloc, const UnionFind<PHV::FieldSlice> &copacking_constraints,
        ordered_map<PHV::FieldSlice, PHV::Container> &req_container) const;
 
    //  (xxx)Deep [Specific Case Alert]: This will probably be subsumed by another function that
    //  handles the general case of producing conditional constraints for n unallocated sources
    //  packed into 2 containers.
    std::optional<PHV::FieldSlice> get_smaller_source_slice(
        const PHV::Allocation &alloc, const UnionFind<PHV::FieldSlice> &copacking_constraints,
        const ordered_set<PHV::FieldSlice> &container_state) const;
 
    std::optional<PHV::FieldSlice> get_unallocated_slice(
        const PHV::Allocation &alloc, const UnionFind<PHV::FieldSlice> &copacking_constraints,
        const ordered_set<PHV::FieldSlice> &container_state) const;

    ordered_set<const PHV::Field *> meter_color_destinations;

    ordered_set<const PHV::Field *> meter_color_destinations_8bit;

    ordered_map<const PHV::Field *, ordered_set<const IR::MAU::Action *>> special_no_pack;

    bool check_speciality_packing(const PHV::Allocation::MutuallyLiveSlices &container_state) const;

    bool check_and_generate_constraints_for_move_with_unallocated_sources(
        const PHV::Allocation &alloc, const IR::MAU::Action *action, const PHV::Container &c,
        const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions,
        ActionContainerProperty *action_props, PackingConstraints *copacking_constraints) const;

    bool generate_conditional_constraints_for_bitwise_op(
        const PHV::Allocation::MutuallyLiveSlices &container_state, const IR::MAU::Action *action,
        const ordered_set<PHV::FieldSlice> &sources,
        PackingConstraints *copacking_constraints) const;

    bool check_and_generate_constraints_for_bitwise_op_with_unallocated_sources(
        const IR::MAU::Action *action, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const NumContainers &sources, PackingConstraints *copacking_constraints) const;

    CanPackErrorCode check_and_generate_constraints_for_bitwise_or_move(
        const PHV::Allocation &alloc, const PHV::ActionSet &actions,
        const PHV::Allocation::MutuallyLiveSlices &container_state, const PHV::Container &c,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions, ActionPropertyMap *action_props,
        PackingConstraints *copack_constraints) const;

    CanPackErrorCode check_and_generate_rotational_alignment_constraints(
        const PHV::Allocation &alloc, const std::vector<PHV::AllocSlice> &slices,
        const PHV::ActionSet &actions, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Container &c, ActionPropertyMap *action_props) const;

    CanPackErrorCode check_and_generate_copack_set(
        const PHV::Allocation &alloc, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PackingConstraints &copack_constraints, const ActionPropertyMap &action_props,
        ordered_map<int, ordered_set<PHV::FieldSlice>> *copacking_set,
        ordered_map<PHV::FieldSlice, PHV::Container> *req_container) const;

    CanPackReturnType check_and_generate_conditional_constraints(
        const PHV::Allocation &alloc, const std::vector<PHV::AllocSlice> &slices,
        const PHV::Allocation::MutuallyLiveSlices &container_state,
        const ordered_map<int, ordered_set<PHV::FieldSlice>> &copacking_set,
        const ordered_map<PHV::FieldSlice, PHV::Container> &req_container) const;

    bool stateful_destinations_constraints_violated(
        const PHV::Allocation::MutuallyLiveSlices &container_state) const;

    bool check_speciality_read_and_bitmask(
        const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    PHV::ActionSet make_writing_action_set(
        const PHV::Allocation &alloc, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    ActionPropertyMap make_action_container_properties(
        const PHV::Allocation &alloc, const PHV::ActionSet &actions,
        const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions, bool is_mocha_or_dark) const;

    PackingConstraints make_initial_copack_constraints(
        const PHV::ActionSet &actions,
        const PHV::Allocation::MutuallyLiveSlices &container_state) const;

    std::set<int> stages(const IR::MAU::Action *action, bool physical_stage) const;
 
 public:
    // Summary of sources for an action
    struct ActionSources {
        bool has_ad = false;
        bool has_const = false;
 
        // Allocated sources
        ordered_set<PHV::Container> phv;
 
        // Number of unallocated sources
        int unalloc = 0;
 
        // Destinations
        bitvec dest_bits;
    };
 
    explicit ActionPhvConstraints(const PhvInfo &p, const PhvUse &u, const PackConflicts &c,
                                  const MapTablesToActions &m, const DependencyGraph &d)
        : phv(p),
          uses(u),
          conflicts(c),
          tableActionsMap(m),
          dg(d),
          constraint_tracker(ConstraintTracker(p, *this)) {}

    bool is_meter_color_destination(const PHV::Field *f) const {
        return meter_color_destinations.count(f) > 0;
    }

    bool is_meter_color_destination_8bit(const PHV::Field *f) const {
        return meter_color_destinations_8bit.count(f) > 0;
    }

    bool hasPackConflict(const PHV::FieldSlice fs1, const PHV::FieldSlice fs2) const {
        return conflicts.hasPackConflict(fs1, fs2);
    }

    bool hasSpecialityReads(const PHV::Field *f) const { return special_no_pack.count(f) > 0; }

    ordered_set<const PHV::Field *> &meter_color_dests() { return meter_color_destinations; }

    const ordered_set<const PHV::Field *> &meter_color_dests() const {
        return meter_color_destinations;
    }

    ordered_set<const PHV::Field *> &meter_color_dests_8bit() {
        return meter_color_destinations_8bit;
    }

    const ordered_set<const PHV::Field *> &meter_color_dests_8bit() const {
        return meter_color_destinations_8bit;
    }

    ordered_set<const IR::MAU::Action *> actions_writing_fields(const PHV::Field *f) const {
        return constraint_tracker.written_in(PHV::FieldSlice(f, StartLen(0, f->size)));
    }
 
    ordered_set<const IR::MAU::Action *> actions_writing_fields(
        const PHV::AllocSlice &slice) const {
        PHV::FieldSlice fieldSlice(slice.field(), slice.field_slice());
        return constraint_tracker.written_in(fieldSlice);
    }

    ordered_set<const IR::MAU::Action *> actions_reading_fields(const PHV::Field *f) const {
        return constraint_tracker.read_in(PHV::FieldSlice(f, StartLen(0, f->size)));
    }

    ordered_set<const PHV::Field *> slices_sources(
        const PHV::Field *dest, const std::vector<PHV::FieldSlice> &slices) const;

    ordered_set<const PHV::Field *> slices_destinations(
        const PHV::Field *src, const std::vector<PHV::FieldSlice> &slices) const;

    std::optional<const PHV::Field *> field_destination(const PHV::Field *f,
                                                        const IR::MAU::Action *action) const;

    bool move_only_operations(const PHV::Field *f) const;

    bool all_field_slices_written_together(
        const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::ActionSet &set_of_actions,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    bool pack_conflicts_present(const PHV::Allocation::MutuallyLiveSlices &container_state,
                                const std::vector<PHV::AllocSlice> &slices) const;

    bool parser_constant_extract_satisfied(
        const PHV::Container &c, const PHV::Allocation::MutuallyLiveSlices &container_state) const;

    CanPackReturnType can_pack(const PHV::Allocation &alloc,
                               const std::vector<PHV::AllocSlice> &slices,
                               const PHV::Allocation::MutuallyLiveSlices &original_container_state,
                               const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    CanPackErrorV2 check_bitwise_and_basic_move_constraints(
        const PHV::ActionSet &actions, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const ActionPropertyMap *action_props) const;

    CanPackErrorV2 can_pack_v2(const PHV::Allocation &alloc,
                               const std::vector<PHV::AllocSlice> &slices) const;

    bool creates_container_conflicts(const PHV::Allocation::MutuallyLiveSlices &container_state,
                                     const PHV::Allocation::LiveRangeShrinkingMap &initActions,
                                     const MapTablesToActions &tableActionsMap) const;

    int count_bitmasked_set_instructions(
        const std::vector<PHV::AllocSlice> &slices,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    bool is_bitmasked_set(const std::vector<PHV::AllocSlice> &container_state,
                          const ordered_set<PHV::AllocSlice> &fields_not_written_to) const;

    void sort(std::list<const PHV::SuperCluster::SliceList *> &slice_list) const;

    void sort(std::vector<PHV::FieldSlice> &slice_list) const;

    void dest_first_sort(std::vector<const PHV::SuperCluster::SliceList *> &slice_list) const;

    ordered_set<const PHV::Field *> actionReads(const IR::MAU::Action *act) const;
 
    const ordered_set<PHV::FieldSlice> &actionReadsSlices(const IR::MAU::Action *act) const {
        return constraint_tracker.reads(act);
    }

    ordered_set<const PHV::Field *> actionWrites(const IR::MAU::Action *act) const;
 
    const ordered_set<PHV::FieldSlice> actionWritesSlices(const IR::MAU::Action *act) const {
        ordered_set<PHV::FieldSlice> rs;
        auto &writtenSlices = constraint_tracker.writes(act);
        for (auto &info : writtenSlices)
            if (info.phv_used != std::nullopt) rs.insert(*(info.phv_used));
        return rs;
    }

    bool checkBridgedPackingConstraints(const ordered_set<const PHV::Field *> &packing) const;

    bool cannot_initialize(const PHV::Container &c, const IR::MAU::Action *action,
                           const PHV::Allocation &alloc) const;

    bool can_pack_pov(const PHV::SuperCluster::SliceList *slice_list, const PHV::Field *f) const;

    bool diagnoseSuperCluster(const ordered_set<const PHV::SuperCluster::SliceList *> &sc,
                              const ordered_map<PHV::FieldSlice, unsigned> &fieldAlignments,
                              std::stringstream &error_msg) const;

    bool written_in(const PHV::Field *f, const IR::MAU::Action *act) const;

    bool written_in(const PHV::AllocSlice &slice, const IR::MAU::Action *act) const {
        PHV::FieldSlice field_slice(slice.field(), slice.field_slice());
        return constraint_tracker.written_in(field_slice).count(act);
    }

    bool written_by_ad_constant(const PHV::Field *f, const IR::MAU::Action *act) const;

    bool is_in_field_writes_to_actions(cstring, const IR::MAU::Action *) const;
    bool is_in_action_to_writes(const IR::MAU::Action *, cstring) const;
    bool is_in_write_to_reads(cstring, const IR::MAU::Action *, cstring) const;

    ordered_map<const PHV::Field *, int> compute_sources_first_order(
        const ordered_map<const PHV::Field *, std::vector<PHV::FieldSlice>> &fields) const;

    ActionSources getActionSources(const IR::MAU::Action *act, const PHV::Container &c,
                                   ordered_set<PHV::AllocSlice> &new_slices,
                                   const PHV::Allocation &alloc) const;

    CanPackErrorV2 check_move_constraints(
        const PHV::Allocation &alloc, const IR::MAU::Action *action,
        const std::vector<PHV::AllocSlice> &slices,
        const PHV::Allocation::MutuallyLiveSlices &container_state, const PHV::Container &c,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    CanPackErrorCode check_ara_move_constraints(
        const PHV::Allocation &alloc, const PHV::Allocation::MutuallyLiveSlices &container_state,
        const PHV::Container &c, const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    CanPackErrorV2 check_move_constraints_from_read(
        const PHV::Allocation &alloc, const std::vector<PHV::AllocSlice> &candidates,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    CanPackErrorV2 check_read_action_move_constraints(
        const PHV::Allocation &alloc, const std::vector<PHV::AllocSlice> &candidates,
        const IR::MAU::Action *action,
        const PHV::Allocation::LiveRangeShrinkingMap &initActions) const;

    CanPackErrorV2 check_read_action_num_source_constraints(
        const PHV::Allocation &alloc, const std::vector<PHV::AllocSlice> &candidates,
        const IR::MAU::Action *action) const;
};
 
std::ostream &operator<<(std::ostream &out, const ActionPhvConstraints::OperandInfo &info);
std::ostream &operator<<(std::ostream &out,
                         const safe_vector<ActionPhvConstraints::OperandInfo> &info);
std::ostream &operator<<(std::ostream &out, const ActionPhvConstraints::ClassifiedSource &src);
 
#endif /* BF_P4C_PHV_ACTION_PHV_CONSTRAINTS_H_ */