field_packing.h

 
#ifndef BF_P4C_PARDE_FIELD_PACKING_H_
#define BF_P4C_PARDE_FIELD_PACKING_H_
 
#include <vector>
 
#include "bf-p4c/ir/bitrange.h"
#include "bf-p4c/ir/gress.h"
#include "lib/cstring.h"
 
namespace P4 {
namespace IR {
namespace BFN {
class ParserState;
}  // namespace BFN
class Expression;
}  // namespace IR
}  // namespace P4
 
namespace BFN {
 
using namespace P4;
 
struct FieldPacking {
    struct PackedItem {
        const IR::Expression *field;
        gress_t gress;
 
        cstring source;
 
        unsigned width;
 
        bool isPadding() const { return field == nullptr; }
 
        explicit PackedItem(unsigned width) : field(nullptr), width(width) {}
        PackedItem(const IR::Expression *field, gress_t gress, cstring source, unsigned width)
            : field(field), gress(gress), source(source), width(width) {}
 
        static PackedItem makePadding(unsigned width) { return PackedItem(width); }
    };
 
    typedef std::vector<PackedItem>::iterator iterator;
    typedef std::vector<PackedItem>::const_iterator const_iterator;
 
    iterator begin() { return fields.begin(); }
    iterator end() { return fields.end(); }
    const_iterator begin() const { return fields.begin(); }
    const_iterator end() const { return fields.end(); }
 
    template <Endian Order, typename Func>
    void forEachField(Func func) const {
        int posBits = 0;
        for (auto &field : fields) {
            if (field.isPadding()) {
                posBits += field.width;
                continue;
            }
            const auto fieldRange =
                nw_bitrange(StartLen(posBits, field.width)).toOrder<Order>(totalWidth);
            posBits += field.width;
            func(fieldRange, field.field, field.source);
        }
    }
 
    void appendField(const IR::Expression *field, cstring source, unsigned width,
                     gress_t gress = INGRESS);
    void appendField(const IR::Expression *field, unsigned width, gress_t gress = INGRESS);
 
    void appendPadding(unsigned width);
 
    void append(const FieldPacking &packing);
 
    void padToAlignment(unsigned alignment, unsigned phase = 0);
 
    void clear();
 
    bool containsFields() const;
 
    bool isAlignedTo(unsigned alignment, unsigned phase = 0) const;
 
    IR::BFN::ParserState *createExtractionState(gress_t gress, cstring stateName,
                                                const IR::BFN::ParserState *finalState) const;
 
    std::vector<PackedItem> fields;
 
    unsigned totalWidth = 0;
};
 
}  // namespace BFN
 
std::ostream &operator<<(std::ostream &out, const BFN::FieldPacking *packing);
 
#endif /* BF_P4C_PARDE_FIELD_PACKING_H_ */