Есть ли переносимая альтернатива битовым полям С++?

У нас есть это в производственном коде, где нам пришлось портировать код MIPS на x86-64.

https://codereview.stackexchange.com/questions/54342/template-for-endianness-free-code-data-always-packed-as-big-endian

Хорошо работает для нас.

По сути, это шаблон без какого-либо хранилища, аргументы шаблона указывают положение соответствующих битов.

Если вам нужно несколько полей, вы объединяете несколько специализаций шаблона в объединение вместе с массивом байтов для хранения.

В шаблоне есть перегрузки для присвоения значения и оператор преобразования в unsigned для чтения значения.

Кроме того, если поля больше байта, они хранятся в порядке байтов с обратным порядком байтов, что иногда полезно при реализации кросс-платформенных протоколов.

вот пример использования:

union header
{
    unsigned char arr[2];       // space allocation, 2 bytes (16 bits)

    BitFieldMember<0, 4> m1;     // first 4 bits
    BitFieldMember<4, 5> m2;     // The following 5 bits
    BitFieldMember<9, 6> m3;     // The following 6 bits, total 16 bits
};

int main()
{
    header a;
    memset(a.arr, 0, sizeof(a.arr));
    a.m1 = rand();
    a.m3 = a.m1;
    a.m2 = ~a.m1;
    return 0;
}

Из стандарта С++ 14 (черновик N3797), раздел 9.6 [class.bit], пункт 1:

Распределение битовых полей внутри объекта класса определяется реализацией. Выравнивание битовых полей определяется реализацией. Битовые поля упакованы в некоторую адресуемую единицу распределения. [Примечание: битовые поля охватывают единицы распределения на одних машинах, а не на других. Битовые поля назначаются справа налево на одних машинах и слева направо на других. — примечание в конце]

Хотя примечания не являются нормативными, каждая реализация, о которой я знаю, использует одну из двух компоновок: порядок битов с прямым порядком байтов или прямым порядком байтов.

Обратите внимание, что:

• Вы должны указать заполнение вручную. Это означает, что вы должны знать размер ваших типов (например, используя <cstdint>).
• Вы должны использовать беззнаковые типы.
• Макросы препроцессора для определения порядка битов зависят от реализации.
• Обычно порядок следования битов совпадает с порядком следования байтов. Я считаю, что есть флаг компилятора, чтобы переопределить его, но я не могу его найти.

Например, посмотрите netinet/tcp.h и другие близлежащие заголовки.

Изменить с помощью OP: например, tcp.h определяет

struct
{
    u_int16_t th_sport;     /* source port */
    u_int16_t th_dport;     /* destination port */
    tcp_seq th_seq;     /* sequence number */
    tcp_seq th_ack;     /* acknowledgement number */
# if __BYTE_ORDER == __LITTLE_ENDIAN
    u_int8_t th_x2:4;       /* (unused) */
    u_int8_t th_off:4;      /* data offset */
# endif
# if __BYTE_ORDER == __BIG_ENDIAN
    u_int8_t th_off:4;      /* data offset */
    u_int8_t th_x2:4;       /* (unused) */
# endif
    // ...
}

И поскольку он работает с основными компиляторами, это означает, что расположение памяти битсета на практике надежно.

Редактировать:

Это переносимо в пределах одного порядка байтов:

struct Foo {
    uint16_t x: 10;
    uint16_t y: 6;
};

Но это может быть не так, потому что он охватывает 16-битный блок:

struct Foo {
    uint16_t x: 10;
    uint16_t y: 12;
    uint16_t z: 10;
};

И это может быть не потому, что он имеет неявное заполнение:

struct Foo {
    uint16_t x: 10;
};

С помощью C++ легко реализовать битовые поля с известными позициями:

template<typename T, int POS, int SIZE>
struct BitField {
    T *data;

    BitField(T *data) : data(data) {}

    operator int() const {
        return ((*data) >> POS) & ((1ULL << SIZE)-1);
    }

    BitField& operator=(int x) {
        T mask( ((1ULL << SIZE)-1) << POS );
        *data = (*data & ~mask) | ((x << POS) & mask);
        return *this;
    }
};

Приведенная выше игрушечная реализация позволяет, например, определить 12-битное поле в переменной unsigned long long с помощью

unsigned long long var;

BitField<unsigned long long, 7, 12> muxno(&var);

и сгенерированный код для доступа к значению поля просто

0000000000000020 <_Z6getMuxv>:
  20:   48 8b 05 00 00 00 00    mov    0x0(%rip),%rax  ; Get &var
  27:   48 8b 00                mov    (%rax),%rax     ; Get content
  2a:   48 c1 e8 07             shr    $0x7,%rax       ; >> 7
  2e:   25 ff 0f 00 00          and    $0xfff,%eax     ; keep 12 bits
  33:   c3                      retq   

В основном то, что вам придется писать от руки

Я написал реализацию битовых полей на C++ в виде заголовочного файла библиотеки. Пример, который я привожу в документации, заключается в том, что вместо того, чтобы писать это:

struct A
  {
    union
      {
        struct
          {
            unsigned x : 5;
            unsigned a0 : 2;
            unsigned a1 : 2;
            unsigned a2 : 2;
          }
        u;
        struct
          {
            unsigned x : 5;
            unsigned all_a : 6;
          }
        v;
      };
  };

// …

A x;
x.v.all_a = 0x3f;
x.u.a1 = 0;

ты можешь написать:

typedef Bitfield<Bitfield_traits_default<> > Bf;

struct A : private Bitfield_fmt
  {
    F<5> x;
    F<2> a[3];
  };

typedef Bitfield_w_fmt<Bf, A> Bwf;

// …

Bwf::Format::Define::T x;
BITF(Bwf, x, a) = 0x3f;
BITF(Bwf, x, a[1]) = 0;

Существует альтернативный интерфейс, в котором последние две строки вышеприведенного кода изменятся на:

#define BITF_U_X_BWF Bwf
#define BITF_U_X_BASE x
BITF(X, a) = 0x3f;
BITF(X, a[1]) = 0;

Используя эту реализацию битовых полей, параметр шаблона признаков дает программисту большую гибкость. Память — это просто память процессора по умолчанию, или она может быть абстракцией, когда программист предоставляет функции для выполнения чтения и записи «памяти». Абстрагированная память представляет собой последовательность элементов любого беззнакового целочисленного типа (выбирается программистом). Поля могут располагаться либо от наименьшего к наибольшему, либо от наибольшего к наименьшему значению. Расположение полей в памяти может быть обратным их расположению в структуре формата.

Реализация находится по адресу: https://github.com/wkaras/C-plus-plus-library-bit-fields

(Как видите, мне, к сожалению, не удалось полностью избежать использования макросов.)

C предназначен для низкоуровневых манипуляций с битами. Достаточно просто объявить буфер беззнаковых символов и установить для него любой битовый шаблон, который вы хотите. Особенно, если ваши битовые строки очень короткие, поэтому вписываются в один из целочисленных типов.

Одной из потенциальных проблем является порядок следования байтов. C вообще не может «видеть» это, но так же, как целые числа имеют порядок следования байтов, так же и байты при сериализации. Другой причиной является очень небольшое количество машин, которые не используют октеты для байтов. C гарантирует, что байт должен быть не менее октета, но 32 и 9 являются реальными реализациями. В этих обстоятельствах вы должны принять решение, игнорировать ли старшие биты (в этом случае наивный код должен работать) или рассматривать их как часть битового потока (в этом случае вы должны быть осторожны, складывая CHAR_BIT в ваши расчеты). Также сложно протестировать код, так как вам вряд ли будет легко заполучить машину CHAR+BIT 32.