C++ Embedded

packed structure
Собравшиеся представители компании "ООО МУЛАТ" так и не соизволили показать свои лица, я демонстративно выключил камеру. Кажется, с этого момента беседа не заладилась.
У коллективного собеседующего явно есть какая-то тактика, и он ее придерживается: то про структуру вопрос, то про управление выравниванием. Ходит вокруг да около, вот уже дрожит коллективный голос, мочи нет, как хочет говорить про свою боль, свою прелесть, свои натруженные упакованные структуры. Священный Грааль всех телеком-компаний.
Для чего они вообще нужны? Представим, что есть у нас пакет, где лежат не тюльпаны и не лилии, но данные: тэг типа int8_t и значение типа int32_t. Мы берем их и изо всех сил передаем по сети или еще как-нибудь. Допустим, endianness у нас такой, какой надо. На другом устройстве мы получаем пакеты данных и хотим их быстро распарсить.
Для этого мы уже и соответствующую структуру подготовили:

struct Pack {
  int8_t tag;
  int32_t value;
};

и функцию для изъятия значения:

int32_t getValue(Pack *p) {
  return p->value;
}

Презрев все дурацкие правила и перекрестившись, просто натягиваем структуру на память, как сову на глобус.

Pack *ptr {reinterpret_cast<Pack*>(mem)};  // mem - это адрес полученных данных.
int32_t const x {getValue(ptr)};

Приглядевшись к функции getValue для архитектуры Cortex M33 (-mcpu=cortex-m33), мы увидим

    ldr     r3, [r7, #4]
    ldr     r3, [r3, #4]

Первая инструкция LDR загружает в R3 адрес начала структуры, а вторая загружает в тот же регистр значение int32_t со смещением в 4 байта от полученного адреса. Данных пришло 5 байт, а в структуре аж целых 8, проклятое выравнивание!
Понятно, что это прямой путь к катастрофе. Вот тут, улюлюкая и пританцовывая, выскакивают просветленные сишники со своими пакетированными структурами.
Им нравится доминировать и навязывать структурам выравнивание, больше всего они любят побайтовое, чтоб члены слиплись, как пельмешки, в один бесформенный комок.
#pragma pack(n) - устанавливает новое выравнивание n для всех структур ниже. Нужно не забыть вернуть выравнивание на место инструкцией #pragma pack().
Чтоб избирательно уродовать конкретную структуру в GCC, им можно задать специальный атрибут:

struct __attribute__((packed)) Pack { ...

Для IAR есть другая форма записи:

struct __packed Pack { ...

Вот теперь размер структуры такой, какой нужно, и наш ужасный код заработает. Но какой ценой?!
Почти никакой, только изменится размер смещения для второй инструкции LDR. Еще у нас появится милая пометка, что операция будет происходить по невыровненному адресу.

    ldr     r3, [r7, #4]
    ldr     r3, [r3, #1]      @ unaligned

Да, инструкции LDR и прочие совершенно спокойно работают с невыровненными адресами, но это для Cortex M33.
Для иной архитектуры все будет не так гладко. Есть такие, что не могут кормить инструкции неровными адресами, например, Cortex M0.
Заменим у компилятора флаг на -mcpu=cortex-m0 и насладимся метаморфозами внутри функции getValue:

    ldr     r3, [r7, #4]
    ldrb    r2, [r3, #1]
    ldrb    r1, [r3, #2]
    lsls    r1, r1, #8
    orrs    r2, r1
    ldrb    r1, [r3, #3]
    lsls    r1, r1, #16
    orrs    r2, r1
    ldrb    r3, [r3, #4]
    lsls    r3, r3, #24
    orrs    r3, r2

Компилятор создает более сложный и медленный код, чтоб получить доступ к значениям в структуре и избежать HardFault. И это еще, можно сказать, повезло! Некоторые недалекие компиляторы не умеют генерировать код, который корректно работает с опакеченными структурами. Тогда попытка доступа к памяти по невыровненному адресу закончится печально.
Коллективное сознание "ООО МУЛАТ" осталось недовольно моими путанными объяснениями и снизошло уточнить, что размер упакованной структуры равен сумме размеров ее членов. Вот тут я и понял, что пора бежать. Как они могли забыть про вырожденный случай пустой структуры? Как такую ни упаковывай, размер по-прежнему будет равен единице.

👍6🔥2👏1

429 viewsDanila Demidow, 11:35