03 — Number Systems¶

Assembly works directly with binary data. Decimal is a human convenience; the CPU only knows bits. You must be comfortable converting between bases and understanding how negative numbers and characters are encoded.

Positional Number Systems¶

Every positional number system has a base (radix). The value of each digit is multiplied by the base raised to its position.

Binary (Base 2)¶

Each digit is a bit. Groupings: - 4 bits = nibble - 8 bits = byte - 16 bits = word - 32 bits = doubleword (dword) - 64 bits = quadword (qword)

Binary to Decimal¶

1011₂ = 1×2³ + 0×2² + 1×2¹ + 1×2⁰
       = 8    + 0    + 2    + 1
       = 11₁₀

Decimal to Binary¶

Repeatedly divide by 2, collect remainders bottom-up:

42 ÷ 2 = 21 R 0
21 ÷ 2 = 10 R 1
10 ÷ 2 =  5 R 0
 5 ÷ 2 =  2 R 1
 2 ÷ 2 =  1 R 0
 1 ÷ 2 =  0 R 1
             ↑ read upward: 101010₂

Hexadecimal (Base 16)¶

Hex is the most important base for assembly. One hex digit = exactly 4 bits = one nibble.

Hex to Binary (instant conversion)¶

Replace each hex digit with its 4-bit binary:

0xCAFE → C    A    F    E
       → 1100 1010 1111 1110

A 64-bit register in hex¶

0xDEADBEEFCAFEBABE
  DE AD BE EF CA FE BA BE  (8 bytes)

This is why hex is preferred — it's compact and maps directly to bytes.

Powers of 2 (Memorize These)¶

Signed Integers: Two's Complement¶

x86 uses two's complement to represent negative numbers. This lets the same ADD/SUB hardware handle both signed and unsigned arithmetic.

The Rule¶

For an N-bit number: - If the most significant bit (MSB) is 0 → positive (same as unsigned) - If the MSB is 1 → negative

Range¶

Computing Two's Complement (negation)¶

To negate a number: flip all bits, then add 1

42  = 0b00101010
~42 = 0b11010101  (flip all bits)
+1  = 0b11010110  = -42 in two's complement

Verification: 42 + (-42) = 0

  00101010
+ 11010110
──────────
 100000000  (carry out of 8 bits = overflow, ignored → 0)  ✓

Why Two's Complement?¶

• Only one representation of zero (unlike sign-magnitude)
• Addition hardware works identically for signed and unsigned
• Subtraction is just a + (-b)

Bit Manipulation Essentials¶

These operations are used constantly in assembly:

The Flags Register (RFLAGS)¶

After arithmetic and logic operations, the CPU updates flags in the RFLAGS register. These control conditional jumps.

Example: sub rax, rax → result is 0 → ZF=1, SF=0, CF=0, OF=0

ASCII and Character Encoding¶

Characters in memory are just numbers. ASCII assigns a number to each printable character.

'A' = 0x41 = 65
'a' = 0x61 = 97   (lowercase = uppercase + 0x20)
'0' = 0x30 = 48   (digit '0' is not value 0!)
'\n'= 0x0A = 10   (newline)

In NASM, character literals can be written directly:

mov al, 'A'      ; al = 65
mov al, 'A' + 32 ; al = 97 = 'a'  (to lowercase)

Number Literals in NASM¶

mov rax, 42          ; decimal
mov rax, 0x2A        ; hexadecimal
mov rax, 0b00101010  ; binary
mov rax, 0o52        ; octal
mov rax, 'A'         ; character (ASCII 65)

Practice Problems¶

1. Convert 0xBEEF to decimal and binary.
2. What is -1 in 8-bit two's complement? In 64-bit?
3. What is 0x80000000 as a signed 32-bit integer?
4. Given rax = 0xFF, what is rax & 0x0F? rax | 0x100?
5. What ASCII character is at position 0x48?

Next: 04 — Setting Up the Environment¶