Bitwise Operations and Masks

A bitwise operation is simply a logic operation like AND or OR done on two binary numbers one column at a time, and a mask is a number you combine with a register to pick out just the bits you want. Bitwise means exactly that, bit by bit, and a mask works like masking tape when you paint: it covers some spots and leaves the rest exposed. That's how firmware flips one switch inside a hardware register without disturbing the other seven. The formulas $x \lor 2^n$, $x \land \lnot 2^n$ and $x \oplus 2^n$ look cryptic, but they're tiny pieces: $2^n$ (a number with a single 1, at bit $n$), $\lor$ (OR, turn it on), $\land \lnot$ (AND with the opposite, turn it off) and $\oplus$ (XOR, flip it). It's just on, off and flip; bear with the symbols.

One truth table, many columns. Bitwise AND, OR, XOR and NOT apply the truth tables from the logic unit to every bit position at once:

and NOT 1100 is 0011. In C they're &, |, ^ and ~.

Masks. A mask is a constant with 1s exactly in the bit positions you care about. Why does that help? Look at what each operation does with a single bit $b$: $b \land 1 = b$, $b \land 0 = 0$, $b \lor 1 = 1$, $b \lor 0 = b$, $b \oplus 1 = \lnot b$ and $b \oplus 0 = b$. So a 0 in the mask means "leave this bit alone" for OR and XOR, and a 1 means "do something here." That gives you four moves:

• test bit $n$: $x \land 2^n$ is nonzero exactly when the bit is 1;
• set it: $x \lor 2^n$;
• clear it: $x \land \lnot 2^n$, an AND with a mask that's all 1s except at bit $n$;
• toggle it: $x \oplus 2^n$.

GPIOA->ODR |= (1u << 5);         // set bit 5: LED on
GPIOA->ODR &= ~(1u << 5);        // clear bit 5: LED off
GPIOA->ODR ^= (1u << 5);         // toggle it
if (USART1->SR & (1u << 5)) {    // test: has a byte arrived?
    byte = USART1->DR;
}
gain = (cfg >> 8) & 0xF;         // read the field in bits 11-8

Shifts multiply and divide by powers of 2. It's the same as tacking a zero onto a decimal number to multiply by 10. Shifting left by $n$ moves every bit to a place worth $2^n$ times as much, so $x \ll n = x \cdot 2^n$. Shifting right drops the low $n$ bits: $x \gg n = \lfloor x/2^n \rfloor$. For a negative signed number, compilers use an arithmetic shift that copies the sign bit in from the top, which still rounds down: $-7 \gg 1 = -4$, while C's division -7 / 2 rounds toward zero and gives $-3$.

Remainders mod a power of 2 are masks. The low $n$ bits of an unsigned $x$ are $x \bmod 2^n$, so $x \land (2^n - 1) = x \bmod 2^n$. Ring buffers use sizes like 64 or 256 for exactly this reason: wrapping the index costs one AND instead of a division.

A few classic tricks.

• $x \land (x - 1)$ clears the lowest 1 bit, since subtracting 1 turns that bit off and the 0s below it on. So it's 0 exactly when $x$ is 0 or a power of 2.
• In two's complement $\lnot x = -x - 1$, because $x + \lnot x = 11\ldots1 = -1$.
• XOR undoes itself: $(a \oplus k) \oplus k = a$. RAID storage keeps the XOR of several drives on a parity drive, so any one lost drive can be rebuilt by XORing the survivors.
• De Morgan's laws hold bit by bit, $\lnot(a \lor b) = \lnot a \land \lnot b$, so clearing bits 3 and 5 at once is x & ~((1 << 3) | (1 << 5)).

Firmware talks to hardware through memory-mapped registers, so every driver is full of masks and shifts: set a bit to switch on a peripheral's clock, test a bit to see whether data arrived, shift and mask to pull a field out of a status word.