Битовые операции в C

Операторы и маски

Маска — число, в котором единицами отмечены нужные биты. 1 << n даёт маску одного бита, (1 << k) - 1 — маску из k младших бит. Для AVR в avr-libc есть макрос _BV(n), определённый как (1 << (n)), и макросы проверки bit_is_set() и bit_is_clear(); имена бит вроде PB5 и CS11 в заголовках — это их номера.

Запись многобитного поля без порчи соседних бит — классический приём «очистить, затем установить»:

/* STM32F1: set the MODE/CNF field of PA5 (bits 23:20 of GPIOA->CRL) to 0b0010 */
uint32_t crl = GPIOA->CRL;
crl &= ~(0xFUL << 20);      /* clear the 4-bit field */
crl |= (0x2UL << 20);       /* output push-pull, 2 MHz */
GPIOA->CRL = crl;

Чтение в локальную переменную и одна запись обратно короче и безопаснее, чем две операции &= и |= над самим регистром: регистр не проходит через промежуточное состояние. Как устроены поля регистров GPIO STM32, разобрано в статье о GPIO STM32.

Маску и сдвиг поля любого регистра, его чтение и запись, суффикс констант для AVR и ARM и готовый код на C считает калькулятор ниже — отдельно он открывается на странице калькулятора битовых масок. В нём сразу открыт тот же GPIOA->CRL после сброса, но выбрано только двухбитное поле MODE5, биты 21:20. Запись 2 в него оставляет CNF5 = 01 и даёт 0x4464 4444 — выход с открытым стоком. Чтобы повторить пример выше, задайте поле 23:20: получится 0x4424 4444.

/* GPIOA->CRL: 32-bit register, arm-none-eabi-gcc (int is 32 bits): suffix UL */

/* Bit 31 */
GPIOA->CRL |= (1UL << 31);    /* set */
GPIOA->CRL &= ~(1UL << 31);   /* clear */
GPIOA->CRL ^= (1UL << 31);    /* toggle */
if (GPIOA->CRL & (1UL << 31)) {    /* test */
    /* bit 31 is 1 */
}

/* Field GPIO_CRL_MODE5: bits 21:20, 2 bits */
/* If a device header already defines these names, the lines must match it token for token */
#define GPIO_CRL_MODE5_Pos  (20U)
#define GPIO_CRL_MODE5_Msk  (0x3UL << GPIO_CRL_MODE5_Pos)  /*!< 0x00300000 */

uint32_t mode5 = (GPIOA->CRL & GPIO_CRL_MODE5_Msk) >> GPIO_CRL_MODE5_Pos;    /* read */
GPIOA->CRL = (GPIOA->CRL & ~GPIO_CRL_MODE5_Msk)
    | ((0x2UL << GPIO_CRL_MODE5_Pos) & GPIO_CRL_MODE5_Msk);    /* write 2 */

/* The same with the CMSIS-Core macros from core_cm*.h */
mode5 = _FLD2VAL(GPIO_CRL_MODE5, GPIOA->CRL);
GPIOA->CRL = (GPIOA->CRL & ~GPIO_CRL_MODE5_Msk) | _VAL2FLD(GPIO_CRL_MODE5, 0x2);

Ловушка 1: продвижение маленьких типов до int

Перед арифметическими и побитовыми операциями значения типов уже int — uint8_t, int8_t, uint16_t на 32-битных платформах — продвигаются до int (C11, 6.3.1.1). Поэтому:

uint8_t flags = 0x0F;
if (~flags == 0xF0) {
    /* never executed: ~flags is the int 0xFFFFFFF0 (-16), not 0xF0 */
}
if ((uint8_t)~flags == 0xF0) {
    /* executed */
}

Так же продвигаются операнды сдвига: uint8_t b = 0x80; b << 1 даёт int со значением 256, а не 0, и обрезается до байта только при присваивании в uint8_t. Это часто полезно — при сборке 16-битного значения из двух байтов (hi << 8) | lo старший байт не теряется, — но при сравнениях и инверсии результат приходится явно приводить к нужному типу.

Ловушка 2: сдвиги

Стандарт C11 (6.5.7) задаёт для сдвигов несколько случаев неопределённого поведения — компилятор вправе считать, что их не бывает, и оптимизировать код исходя из этого:

• сдвиг на отрицательное число бит или на число, большее или равное ширине продвинутого левого операнда: x << 32 для 32-битного x не определён, и рассчитывать на результат 0 нельзя;
• сдвиг влево отрицательного знакового числа или такой сдвиг положительного, результат которого не помещается в тип.

Сдвиг вправо отрицательного знакового числа стандарт оставляет на усмотрение реализации; GCC выполняет его с расширением знака, то есть как арифметический сдвиг. Беззнаковые типы ведут себя предсказуемо: результат берётся по модулю 2^N (C11, 6.2.5p9), поэтому для масок и регистров используют только беззнаковые типы.

Ширина int зависит от платформы: у avr-gcc он 16-битный, поэтому выражение 1 << 15 уже выходит за пределы знакового int, а 1 << 16 не определено. Для масок старше 15-го бита на AVR и старше 31-го на ARM нужна константа подходящего беззнакового типа:

uint32_t mask = 1UL << 20;     /* OK on AVR and ARM */
uint32_t bad  = 1 << 20;       /* undefined on AVR: int is 16 bits */
uint64_t big  = 1ULL << 40;

Ловушка 3: битовые поля структур

Структура с битовыми полями выглядит удобным описанием регистра, но порядок полей внутри слова, их размещение и выравнивание стандарт относит к поведению реализации (C11, 6.7.2.1), а GCC — к ABI конкретной платформы. Обычный int в битовом поле у GCC знаковый, если не указан ключ -funsigned-bitfields. Наконец, запись в поле — это чтение всего слова, изменение и запись, что для регистров с битами «сброс записью единицы» может случайно сбросить чужие флаги. Поэтому заголовки CMSIS и avr-libc описывают регистры масками и номерами бит, а не битовыми полями.

Атомарность

Операция REG |= mask на большинстве архитектур — три действия: чтение, изменение, запись. Если между ними сработает прерывание, которое меняет тот же регистр, его изменение потеряется. Решения зависят от архитектуры:

• AVR: для регистров ввода-вывода с адресами 0x00–0x1F запись одного бита компилируется в одну команду SBI или CBI, она атомарна; для остальных — запрет прерываний на время операции (подробности в системе команд AVR).
• STM32: регистр BSRR устанавливает и сбрасывает биты порта одной записью без чтения, а у Cortex-M3 и M4 есть ещё область bit-band — отдельный адрес для каждого бита.
• Общий случай: запретить прерывания на время чтения-изменения-записи или изменять регистр только в одном месте программы.

Полезные приёмы

Деление беззнакового числа на 2^k сдвигом x >> k эквивалентно делению с отбрасыванием остатка; для отрицательных знаковых чисел — нет: GCC сдвигает с расширением знака и округляет вниз (−3 >> 1 = −2), а деление в C округляет к нулю (−3 / 2 = −1). Подсчёт контрольных сумм на сдвигах и исключающем ИЛИ — например, CRC — можно проверить в калькуляторе CRC, который генерирует такой код на C.