How Negative Numbers Are Stored in Hex

Problem:

How do we write a negative number (like -1, -2, etc.) in hex?

💡 Simple Answer:

We use something called two's complement, which means:

Instead of storing a "minus" sign, we store a big number that, when read the right way, means a negative value.

Example (8-bit system):

An 8-bit number has 8 "slots", so it can hold values from:

• 0 to 255 if unsigned
• -128 to 127 if signed

Now look at this:

So:

• -1 is written as 0xFF
• -2 is written as 0xFE
• etc.

Even though 0xFF looks like 255, computers know (based on context) that in signed 8-bit, it actually means -1.

Rule of Thumb:

If you want to find the hex for a negative number:

1. Pick how many bits (8, 16, 32…).
2. Add that number to your negative number.

For example:

• For -1 in 8-bit: 256 + (-1) = 255 → 0xFF
• For -1 in 32-bit: 4294967296 + (-1) = 4294967295 → 0xFFFFFFFF

Simple Assembly Code Example:

Here’s how the CPU interprets the same value differently based on context:

; Assembly Code (x86, NASM syntax)
section .data
    a db 0xFF        ; one byte: 255 or -1 depending on context

section .text
    global _start

_start:
    movzx eax, byte [a]     ; zero-extend: treat a as unsigned
    ; EAX now = 255

    movsx ebx, byte [a]     ; sign-extend: treat a as signed
    ; EBX now = -1

    ; exit the program
    mov eax, 60             ; syscall: exit
    xor edi, edi            ; status 0
    syscall
    

Explanation:

• 0xFF is stored in memory.
• movzx treats it as unsigned, so you get 255.
• movsx treats it as signed, so you get -1.

The same byte (0xFF) gives different results depending on the instruction used.

General Purpose Registers in AMD64 and AArch64

General-purpose registers are used by the CPU to perform operations and store temporary data. Here’s a comparison of the registers in AMD64 and AArch64:

AMD64 (x86-64):

• Registers: RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, and R8–R15.
• Purpose:
  • RAX: Accumulator for arithmetic operations.
  • RBX: Base register, often used for addressing.
  • RCX: Counter for loops and shifts.
  • RDX: Data register, often used in division and I/O operations.
  • RSI and RDI: Source and destination for string operations.
  • RBP: Base pointer for stack frames.
  • RSP: Stack pointer.
  • R8–R15: Additional general-purpose registers.

AArch64 (ARM 64-bit):

• Registers: X0–X30 and SP (stack pointer).
• Purpose:
  • X0–X7: Used for function arguments and return values.
  • X8: Indirect result location (e.g., for large return values).
  • X9–X15: Temporary registers for general use.
  • X16 and X17: Intra-procedure-call scratch registers.
  • X18: Platform-specific register (e.g., thread pointer).
  • X19–X28: Callee-saved registers (preserved across function calls).
  • X29: Frame pointer.
  • X30: Link register (holds the return address).
  • SP: Stack pointer.

Both architectures have their own conventions and purposes for registers, but they serve similar roles in enabling efficient computation and function calls.