Bài 31.324 phút đọc

Bật, tắt, đảo và kiểm tra bit

Sau bài này bạn sẽ làm được

Bật, tắt, đảo và kiểm tra một bit bằng biểu thức đúng
Viết bộ macro thao tác bit an toàn
Nhận ra lỗi tràn khi dịch quá ba mươi mốt bit
Đọc và ghi một trường nhiều bit liền nhau

Bốn thao tác: bật, tắt, đảo, kiểm tra. Mỗi cái một biểu thức, và bốn biểu thức đó xuất hiện trong mọi trình điều khiển thiết bị từng được viết.

#Bốn thao tác cơ bản

Cùng một mặt nạ, ba phép toán khác nhau. Chỉ bit thứ hai bị ảnh hưởng, mọi bit khác giữ nguyên.

Thao tác	Biểu thức	Vì sao nó chạy
Bật bit n	x \|= 1u << n	OR với 1 luôn cho 1, OR với 0 giữ nguyên
Tắt bit n	x &= ~(1u << n)	AND với 0 luôn cho 0, AND với 1 giữ nguyên
Đảo bit n	x ^= 1u << n	XOR với 1 đảo, XOR với 0 giữ nguyên
Kiểm bit n	(x >> n) & 1u	Kéo bit về vị trí 0 rồi che mọi bit khác

terminal

./bit-thao-tac

x             10110001  = 0xB1 = 177
BIT(2)        00000100  = 0x04 = 4
x |= BIT(2)   10110101  = 0xB5 = 181
x &= ~BIT(2)  10110001  = 0xB1 = 177
x ^= BIT(2)   10110101  = 0xB5 = 181
KIEM_BIT(x, 2) = 0,  KIEM_BIT(x, 4) = 1

Mẫu chung: tạo mặt nạ, rồi áp mặt nạ

1u << n          /* mat na: chi bit n bang 1 */
~(1u << n)       /* mat na dao: chi bit n bang 0 */

x |  mat_na      /* bat nhung bit ma mat na co 1 */
x & ~mat_na      /* tat nhung bit ma mat na co 1 */
x ^  mat_na      /* dao nhung bit ma mat na co 1 */
x &  mat_na      /* GIU LAI nhung bit ma mat na co 1, xoa het con lai */

/* Bon dong cuoi la toan bo ly thuyet. Moi thu con lai
   chi la cach TAO ra mat na. */

Hai cách kiểm bit, và một cách hay bị dùng sai

if (x & (1u << n))      /* dung: khac 0 nghia la bit dang bat */

int b = (x >> n) & 1u;  /* dung: cho ra dung 0 hoac 1 */

int c = x & (1u << n);  /* CHAY nhung KHONG cho 0 hoac 1:
                           voi n = 5 thi c la 0 hoac 32 */

if (c == 1) ...         /* SAI: c la 32 chu khong phai 1 */

/* Neu ban can mot gia tri dung sai thi dung dang thu hai,
   hoac ep bang toan tu phu dinh hai lan: */

int b2 = !!(x & (1u << n));      /* !! bien moi gia tri khac 0 thanh 1 */

#Bộ macro nên có

bit.h

#ifndef BIT_H
#define BIT_H

#include <stdint.h>

/* Mat na chi co bit n bang 1 */
#define BIT(n)            (1u << (n))
#define BIT64(n)          (1ULL << (n))

/* Bon thao tac co ban */
#define BAT_BIT(x, n)     ((x) |=  BIT(n))
#define TAT_BIT(x, n)     ((x) &= ~BIT(n))
#define DAO_BIT(x, n)     ((x) ^=  BIT(n))
#define KIEM_BIT(x, n)    (((x) >> (n)) & 1u)

/* Mat na cho khoang bit tu lo den hi, ca hai dau mut */
#define MAT_NA(hi, lo)    ((~0u >> (31 - (hi))) & (~0u << (lo)))

/* Doc va ghi mot truong nhieu bit */
#define DOC_TRUONG(x, hi, lo)      (((x) & MAT_NA(hi, lo)) >> (lo))
#define GHI_TRUONG(x, hi, lo, v)                                    \
    ((x) = ((x) & ~MAT_NA(hi, lo))                                  \
         | (((unsigned)(v) << (lo)) & MAT_NA(hi, lo)))

#endif /* BIT_H */

Vì sao BIT dùng 1u chứ không phải 1

#define BIT(n) (1 << (n))       /* SAI */

BIT(31)     /* -> 1 << 31, va do la HANH VI KHONG XAC DINH:
               2^31 khong bieu dien duoc trong int co dau.
               Bai 31.2 da noi. */

#define BIT(n) (1u << (n))      /* dung: 1u la unsigned int */

BIT(31)     /* -> 2147483648u, hop le */

BIT(32)     /* van UB: unsigned int chi co 32 bit */

#define BIT64(n) (1ULL << (n))  /* cho bit tu 32 tro len */

BIT64(40)   /* -> 1099511627776 */

terminal

./bit-thao-tac --dich-lon

BIT(31) voi 1u  = 2147483648
1ULL << 40      = 1099511627776

MAT_NA có một hằng số 31 nằm cứng trong đó

#define MAT_NA(hi, lo) ((~0u >> (31 - (hi))) & (~0u << (lo)))
/*                              ^^ gia dinh unsigned int co 32 bit */

/* Tren he thong co unsigned int 16 bit, vi du mot so vi dieu khien 8 bit,
   con so 31 sai va macro cho ket qua rac.

   Ban khong phu thuoc do rong: */

#define MAT_NA(hi, lo) \
    (((~0u) >> (sizeof(unsigned) * CHAR_BIT - 1 - (hi))) & ((~0u) << (lo)))

/* Can #include <limits.h> cho CHAR_BIT.
   Dai hon, nhung dung o moi noi.

   Cach thu ba, ro rang nhat: */

#define MAT_NA(hi, lo) ((BIT((hi) - (lo) + 1) - 1u) << (lo))

/* Doc la: tao (hi-lo+1) bit 1 lien nhau, roi day len vi tri lo.
   Chu y: hong khi hi-lo+1 bang 32, vi BIT(32) la UB. */

#Ghi một giá trị đúng sai vào bit

/* Cach 1: re nhanh */
#define GHI_BIT(x, n, v)  ((v) ? BAT_BIT(x, n) : TAT_BIT(x, n))

/* Cach 2: khong re nhanh */
x = (x & ~BIT(n)) | ((unsigned)!!(v) << (n));

terminal

./ghi-bit

ban an toan: x = 8 (mong doi 8)
sau khi ghi 0: x = 0 (mong doi 0)

Toán tử phủ định hai lần biến mọi giá trị thành 0 hoặc 1

!!0      /* 0 */
!!1      /* 1 */
!!42     /* 1 */
!!-7     /* 1 */

/* Can no vi neu v la 2 thi:
     2 << 3 = 16, tuc bit 4, KHONG phai bit 3.

   Voi !!v thi moi gia tri khac 0 deu thanh 1, va
     1 << 3 = 8, dung bit 3. */

/* Neu ban chac chan v chi la 0 hoac 1 thi bo !! di cung duoc,
   nhung mot dau cham than doi khong dang de tiet kiem. */

Cách một an toàn hơn vẻ ngoài của nó

#define GHI_BIT(x, n, v)  ((v) ? BAT_BIT(x, n) : TAT_BIT(x, n))

/* x xuat hien HAI lan trong than macro, nen nhin qua thi
   giong cam bay danh gia nhieu lan o Bai 19.3.

   Nhung toan tu ba ngoi chi danh gia MOT nhanh, nen x
   thuc te chi duoc tinh mot lan: */

unsigned m[4] = {0};
int i = 0;

GHI_BIT(m[i++], 1, 1);

/* Ket qua: i = 1, va m[0] = 2. Dung nhu mong doi. */

terminal

./ghi-bit --canh-bao

sau GHI_BIT(m[i++], 1, 1): i = 1  (mong doi 1)
m = 2 0 0 0

Nhưng v thì vẫn chỉ được đánh giá một lần, còn n thì xuất hiện trong cả hai nhánh. Với đối số có tác dụng phụ thì bạn vẫn phải cẩn thận. Cách hai không có vấn đề này vì mỗi tham số xuất hiện đúng một lần.

Trên thanh ghi phần cứng, cách hai có thể sai

/* Voi bien thuong thi hai cach tuong duong. Voi THANH GHI thi khong: */

volatile uint32_t *GPIOA_ODR = (volatile uint32_t *)0x40020014;

/* Cach 2 tren thanh ghi: */
*GPIOA_ODR = (*GPIOA_ODR & ~BIT(5)) | (1u << 5);

/* Day la mot chu ky DOC, SUA, GHI. Neu mot ngat xay ra o giua
   va no cung ghi vao GPIOA_ODR thi thay doi cua ngat bi mat.
   Bai 48.1 cua Phan 18 goi day la van de doc sua ghi.

   Nhieu vi dieu khien co thanh ghi RIENG de bat va tat bit
   ma khong can doc truoc: */

GPIOA->BSRR = BIT(5);           /* bat chan 5, mot lenh ghi */
GPIOA->BSRR = BIT(5 + 16);      /* tat chan 5 */

/* Mot lenh ghi duy nhat, khong doc, nen khong co cua so nguy hiem. */

#Thao tác nhiều bit cùng lúc

/* Mat na co the co nhieu bit, va bon phep toan van dung nguyen */

#define CO_DOC     BIT(0)
#define CO_GHI     BIT(1)
#define CO_THUC_THI BIT(2)
#define CO_AN      BIT(3)

unsigned quyen = 0;

quyen |= CO_DOC | CO_GHI;              /* bat HAI co mot luc */
quyen &= ~(CO_GHI | CO_AN);            /* tat HAI co mot luc */
quyen ^= CO_THUC_THI;                  /* dao mot co */

if (quyen & CO_DOC)                    /* co it nhat CO_DOC */
if ((quyen & (CO_DOC | CO_GHI)) == (CO_DOC | CO_GHI))   /* co CA HAI */
if (quyen & (CO_DOC | CO_GHI))         /* co it nhat MOT trong hai */

Kiểm nhiều cờ: phân biệt bất kỳ với tất cả

unsigned can = CO_DOC | CO_GHI;

if (quyen & can)          /* co IT NHAT MOT trong hai co */
if ((quyen & can) == can) /* co CA HAI co */
if (!(quyen & can))       /* KHONG co co nao */
if ((quyen & can) != can) /* THIEU it nhat mot co */

/* Loi hay gap nhat la dung dang thu nhat khi y muon dang thu hai.
   Chuong trinh cho qua khi nguoi dung chi co quyen doc, trong khi
   ban muon doi ca doc lan ghi. */

/* Viet thanh ham cho ro nghia: */
static int co_du_quyen(unsigned quyen, unsigned can) {
    return (quyen & can) == can;
}

static int co_bat_ky(unsigned quyen, unsigned can) {
    return (quyen & can) != 0;
}

Đọc và ghi một trường nhiều bit liền nhau

/* Thanh ghi cau hinh 8 bit:
     bit 7..4  toc do  (0 den 15)
     bit 3..2  che do  (0 den 3)
     bit 1     bat
     bit 0     ngat */

unsigned cau_hinh = 0xB6;      /* 10110110 */

unsigned toc_do = (cau_hinh & 0xF0) >> 4;     /* 1011 = 11 */
unsigned che_do = (cau_hinh & 0x0C) >> 2;     /* 01   = 1  */
unsigned bat    = (cau_hinh >> 1) & 1u;       /* 1 */
unsigned ngat   =  cau_hinh       & 1u;       /* 0 */

terminal

./truong-bit

y             10110110  = 0xB6 = 182
MAT_NA        11110000  = 0xF0 = 240
y & MAT_NA    10110000  = 0xB0 = 176
roi >> 4      00001011  = 0x0B = 11

Ghi vào trường phải xóa trước, và phải che giá trị mới

Thiếu xóa, hoặc thiếu che

cau_hinh |= (toc_do_moi << 4);       /* CHI BAT, khong tat bit cu.
                                        Neu truong dang la 1011 va ban ghi 0100
                                        thi ket qua la 1111, khong phai 0100. */

cau_hinh = (cau_hinh & ~0xF0) | (toc_do_moi << 4);
                                     /* Da xoa truoc, nhung neu toc_do_moi
                                        lon hon 15 thi bit thua tran sang
                                        truong ben canh. */

Xóa, dịch, che

cau_hinh = (cau_hinh & ~0xF0u)
         | ((toc_do_moi << 4) & 0xF0u);

/* Ba buoc:
     1. xoa truong cu bang AND voi mat na dao
     2. day gia tri moi len dung vi tri
     3. CHE gia tri moi bang chinh mat na, de bit thua khong tran

   Buoc 3 hay bi quen, va no chi lo ra khi nguoi goi truyen
   gia tri ngoai khoang. */

#Ba cạm bẫy còn lại

Một: dịch quá số bit của kiểu

uint8_t co = 0;

BAT_BIT(co, 10);          /* BIT(10) la 1024, khong nam trong uint8_t.
                             Phep OR duoc tinh tren int, roi cat con 8 bit,
                             nen co khong doi. Khong ai canh bao. */

/* Cach phong: kiem luc bien dich khi n la hang so */
#define BAT_BIT_KIEM(x, n)                                   \
    do {                                                     \
        _Static_assert((n) < sizeof(x) * CHAR_BIT,           \
                       "so hieu bit vuot do rong cua bien"); \
        (x) |= BIT(n);                                       \
    } while (0)

/* Chi chay khi n la hang so bien dich. Voi n la bien thi
   phai kiem luc chay: */
if (n < sizeof co * CHAR_BIT) BAT_BIT(co, n);

Hai: thăng hạng nguyên với kiểu nhỏ

uint8_t co = 0xFF;

uint8_t dao = ~co;        /* ~co tinh tren INT:
                             co thang hang thanh 255
                             ~255 = -256
                             gan vao uint8_t -> 0

                             Ket qua DUNG, nhung chi vi tinh co. */

uint16_t a = 0xFFFF;
uint32_t b = a << 16;     /* a thang hang thanh int co dau 32 bit
                             0xFFFF << 16 khong nam trong int
                             -> HANH VI KHONG XAC DINH */

uint32_t c = (uint32_t)a << 16;    /* dung */

/* Quy tac: voi uint8_t va uint16_t, EP sang unsigned hoac uint32_t
   truoc khi dich hoac dao. Bai 31.2 da noi, va no lap lai o day
   vi day la cho no hay xay ra nhat. */

Ba: quên rằng bit đánh số từ 0

/* Datasheet noi: "bit 5 la co bao san sang".

   Do la bit thu SAU tinh tu phai, va so hieu la 5.
   Mat na la BIT(5) = 0x20, khong phai BIT(6). */

uint32_t co_san_sang = KIEM_BIT(thanh_ghi, 5);

/* Voi mot truong tu bit 4 den bit 7:
     so bit  = 7 - 4 + 1 = BON bit
     mat na  = 0xF0
     gia tri = (x & 0xF0) >> 4

   Cong thuc so bit la hi - lo + 1, va dau cong 1 rat hay bi quen. */

Viết một phép kiểm cho mọi macro bit

kiem-bit.c

#include <assert.h>

#include "bit.h"

int main(void) {
    /* BIT */
    assert(BIT(0)  == 0x00000001u);
    assert(BIT(4)  == 0x00000010u);
    assert(BIT(31) == 0x80000000u);

    /* Bat, tat, dao */
    unsigned x = 0xB1u;

    assert((x |  BIT(2)) == 0xB5u);
    assert((x & ~BIT(2)) == 0xB1u);
    assert((x ^  BIT(2)) == 0xB5u);
    assert((x ^  BIT(4)) == 0xA1u);

    /* Kiem */
    assert(KIEM_BIT(x, 0) == 1u);
    assert(KIEM_BIT(x, 1) == 0u);
    assert(KIEM_BIT(x, 4) == 1u);
    assert(KIEM_BIT(x, 7) == 1u);

    /* Mat na */
    assert(MAT_NA(7, 4)   == 0x000000F0u);
    assert(MAT_NA(3, 0)   == 0x0000000Fu);
    assert(MAT_NA(31, 28) == 0xF0000000u);
    assert(MAT_NA(5, 5)   == 0x00000020u);
    assert(MAT_NA(31, 0)  == 0xFFFFFFFFu);

    /* Doc va ghi truong */
    unsigned y = 0xB6u;

    assert(DOC_TRUONG(y, 7, 4) == 0xBu);
    assert(DOC_TRUONG(y, 3, 2) == 0x1u);
    assert(DOC_TRUONG(y, 1, 1) == 0x1u);
    assert(DOC_TRUONG(y, 0, 0) == 0x0u);

    GHI_TRUONG(y, 7, 4, 0x3u);
    assert(y == 0x36u);

    GHI_TRUONG(y, 7, 4, 0xFFu);          /* gia tri qua lon, phai bi che */
    assert(y == 0xF6u);

    puts("moi phep kiem dat");

    return 0;
}

terminal

gcc -std=c11 -Wall -Wextra -o kiem-bit kiem-bit.c && ./kiem-bit

moi phep kiem dat

Ba mươi dòng kiểm cho một header hai mươi dòng nghe thừa thãi, cho tới khi bạn sửa một macro mặt nạ và nó lệch một bit. Macro bit là loại mã đúng hoặc sai rất rõ ràng, nên chúng là ứng viên tốt nhất cho kiểm thử tự động.

Tự làm thử

Viết bốn biểu thức bật, tắt, đảo, kiểm và chạy chúng trên 0xB1 với bit 2 và bit 4.
Viết BIT(n) bằng 1 thay vì 1u rồi gọi BIT(31), chạy dưới UBSan nếu có.
Viết ba bản MAT_NA ở trên và kiểm cả ba bằng năm trường hợp trong bảng.
Ghi giá trị 0x3 vào trường bit 4 tới 7 của 0xB6 và xác nhận kết quả là 0x36.
Ghi giá trị 0xFF vào cùng trường đó và xác nhận bit thừa bị che.
Viết tệp kiểm thử đầy đủ cho bit.h của bạn.

Trình chấm điểm tự động sẽ được bổ sung ở giai đoạn sau. Hiện tại bạn tự chạy thử trên máy.

Tóm tắt

Bốn thao tác: OR để bật, AND với mặt nạ đảo để tắt, XOR để đảo, dịch rồi AND với 1 để kiểm.
BIT(n) phải dùng 1u, và BIT64(n) phải dùng 1ULL cho bit từ 32 trở lên.
Ghi vào một trường nhiều bit cần đủ ba bước: xóa trường cũ, dịch giá trị mới lên vị trí, và che giá trị mới bằng mặt nạ.
Kiểm nhiều cờ phải phân biệt x & can nghĩa là bất kỳ với (x & can) == can nghĩa là tất cả.
Với uint8_t và uint16_t, ép sang uint32_t trước khi dịch, vì thăng hạng nguyên đưa chúng về int có dấu.