Endianness (big vs little): Exercises — Hardware deep dive

Before we start, one reminder of the single formula the whole page rests on. For an $N$ -byte value $V$ , number its bytes with $k = 0$ as the least significant byte (LSB). Then

$b_{k} = ⌊ \frac{V}{25 6 ^{k}} ⌋ mod 256$

$25 6^{k} = 2^{8 k}$ shifts the low $k$ bytes out of the way (each byte is 8 bits).
$mod 256$ masks off everything except the lowest remaining byte.

And placement into memory at base address $A$ , offset $i$ :

Little-endian: $mem [A + i] = b_{i}$ (LSB goes to lowest address)
Big-endian: $mem [A + i] = b_{N - 1 - i}$ (MSB goes to lowest address)

The reference figure below is the mental picture for every problem: four mailboxes at addresses $A + 0 \dots A + 3$ , and the two rules for filling them.

L1 — Recognition

Recall Solution 1.1

WHAT we check: does the byte at the lowest address match the most significant byte or the least significant byte of the value? The value's MSB is 0xAA (the leftmost pair, weight $2^{24}$ ). The lowest address holds AA. MSB at lowest address ⇒ big-endian ("Big end → Beginning").

Recall Solution 1.2

Lowest address holds DD, which is the LSB (weight $2^{0}$ ). LSB at lowest address ⇒ little-endian.

Recall Solution 1.3

Big-endian. See Network Protocols — that is why htonl/ntohl exist: they convert between the host's order and this agreed big-endian wire order.

L2 — Application

Recall Solution 2.1

Extract bytes ( $k = 0$ is LSB): $b_{0} = EF, b_{1} = BE, b_{2} = AD, b_{3} = DE$ . Why: $b_{k} = ⌊ V /25 6^{k} ⌋ mod 256$ ; e.g. $b_{1} = ⌊ V /256 ⌋ mod 256 = BE$ . Place little-endian ( $mem [200 + i] = b_{i}$ ): 200:EF 201:BE 202:AD 203:DE.

Recall Solution 2.2

Big-endian reverses the index: $mem [200 + i] = b_{3 - i}$ . 200:DE 201:AD 202:BE 203:EF. Check: biggest byte (DE) landed at the smallest address — matches "Big end first."

Recall Solution 2.3

Bytes: $b_{0} = FF$ (LSB), $b_{1} = 00$ (MSB). Little-endian ( $mem [10 + i] = b_{i}$ ): 10:FF 11:00. Big-endian ( $mem [10 + i] = b_{1 - i}$ ): 10:00 11:FF. Why $N$ matters: the big-endian index is $N - 1 - i$ , so the reversal length depends on the value's width.

L3 — Analysis

Recall Solution 3.1

In little-endian the byte at offset $i$ is byte index $k = i$ , so weight it by $25 6^{i}$ : $V = 78 \cdot 25 6^{0} + 56 \cdot 25 6^{1} + 34 \cdot 25 6^{2} + 12 \cdot 25 6^{3} = 0x12345678 .$

Recall Solution 3.2

In big-endian $mem [i] = b_{N - 1 - i}$ , so the byte at offset $0$ is the MSB. Weight the lowest address most: $V = 78 \cdot 25 6^{3} + 56 \cdot 25 6^{2} + 34 \cdot 25 6^{1} + 12 \cdot 25 6^{0} = 0x78563412 .$ Lesson: identical bytes, opposite convention ⇒ a completely different number. This is exactly why two machines must agree.

Recall Solution 3.3

Writer (little-endian) lays: 0:44 1:33 2:22 3:11. Reader (big-endian) treats offset $0$ as MSB: $V = 44 \cdot 25 6^{3} + 33 \cdot 25 6^{2} + 22 \cdot 25 6^{1} + 11 \cdot 25 6^{0} = 0x44332211 .$ The value got byte-reversed — the classic bug fixed by ntohl in Network Protocols.

L4 — Synthesis

Recall Solution 4.1

Little-endian bytes: 0:09 1:00 2:00 3:00. One byte at address 0 = 0x09 = 9 — correct low-order value, widening is "free." Big-endian bytes: 0:00 1:00 2:00 3:09. One byte at address 0 = 0x00 = 0 — wrong; the 9 lives at address 3. Why: little-endian keeps low-order data at low addresses, so narrow reads work directly (see Memory Addressing).

Worked example Problem 4.2 (the pointer / type-punning detector)

uint32_t x = 1;
uint8_t  b = *(uint8_t*)&x;   // read the first byte

What is b on a little-endian machine? On big-endian? (See Pointers and Type Punning.)

Recall Solution 4.2

$x = 1$ has bytes $b_{0} = 01$ , $b_{1} = b_{2} = b_{3} = 00$ . Little-endian: lowest address holds $b_{0} = 01$ ⇒ b == 1. Big-endian: lowest address holds the MSB $b_{3} = 00$ ⇒ b == 0. The location of the single nonzero byte reveals the convention.

Recall Solution 4.3

$V = (0x12 ≪ 24) ∣ (0x34 ≪ 16) ∣ (0x56 ≪ 8) ∣ 0x78 .$ Equivalently $V = 0x12 \cdot 2^{24} + 0x34 \cdot 2^{16} + 0x56 \cdot 2^{8} + 0x78$ . This is independent of endianness: shifts operate on the value (the abstract number), never on memory addresses. Endianness only appears when that value is laid out in bytes. See Data Representation.

L5 — Mastery

Recall Solution 5.1

char[] is an array of single bytes, not one multi-byte scalar, so endianness does not touch it. Both machines: 0:48 ('H') 1:69 ('i') 2:00 (NUL). Endianness reorders bytes inside one wide integer; array element order is fixed by the array itself.

Recall Solution 5.2

Intended (big-endian reader): offset 0 is MSB ⇒ $V = 01 \cdot 256 + 00 = 0x0100 = 256$ . Little-endian host, no conversion: treats offset 0 as LSB ⇒ $V = 01 + 00 \cdot 256 = 0x0001 = 1$ . It reads 1 instead of 256 — off by a byte-swap. Correct handling: ntohs swaps back. This is the everyday reason network code converts explicitly.

Recall Solution 5.3

Store: $mem [i] = b_{i} = ⌊ V /25 6^{i} ⌋ mod 256$ . Read back by weighting each offset by $25 6^{i}$ : $V^{'} = \sum_{i = 0}^{N - 1} mem [i] \cdot 25 6^{i} = \sum_{i = 0}^{N - 1} b_{i} \cdot 25 6^{i} .$ But $\sum_{i} b_{i} \cdot 25 6^{i}$ is precisely the base-256 expansion of $V$ , so $V^{'} = V$ . The convention is lossless as long as write rule = read rule. (The same holds big-endian with $25 6^{N - 1 - i}$ .)

Level Map

Connections

Endianness (big vs little) — parent topic; all rules built there.
Memory Addressing — variable-width reads (Problem 4.1) rely on address ordering.
Data Representation — the value-to-bytes map $V = \sum b_{k} 25 6^{k}$ .
Network Protocols — big-endian wire order, Problems 3.3 and 5.2.
Pointers and Type Punning — the detector cast in Problem 4.2.
Bitwise Operations — shift/mask construction in Problem 4.3.