CPU
├── ALU (Arithmetic Logic Unit) – Bộ tính toán
├── Registers – Thanh ghi (lưu trữ tạm thời tốc độ cao)
└── Cache
    ├── L1 Cache (nhanh nhất, nhỏ nhất)
    ├── L2 Cache
    └── L3 Cache (chậm hơn, lớn hơn)

Memory (RAM) – Bộ nhớ chính

Storage
├── SSD (Solid State Drive)
└── HDD (Hard Disk Drive)

movl $0x4, %rax       # temp = 0x4  (Imm → Reg)
movl $-147, (%rax)    # *p = -147   (Imm → Mem)
movl %rax, %rdx       # rdx = rax   (Reg → Reg)
movl %rax, (%rdx)     # *p = temp   (Reg → Mem)
movl (%rax), %rdx     # temp = *p   (Mem → Reg)

# Truy cập phần tử thứ i của mảng int A[]
# A[i] có địa chỉ = base_A + 4*i
movl (%eax, %ecx, 4), %edx    # edx = A[i], với eax=&A[0], ecx=i

Lệnh toán học / so sánh
     ↓
Cập nhật %eflag (CF, ZF, SF, OF)
     ↓
Lệnh jX kiểm tra cờ
     ↓
Nhảy hay không nhảy

cmpl  a, b    # Tính b - a, không lưu kết quả, chỉ cập nhật cờ
testl a, b    # Tính b & a (AND), không lưu kết quả, chỉ cập nhật cờ

cmpl %ebx, %eax     # So sánh eax với ebx (tính eax - ebx)
jg   .label_true    # Nhảy nếu eax > ebx

// C code
int result;
if (a > b) {
    result = a - b;
} else {
    result = b - a;
}

# Assembly tương đương (AT&T)
    cmpl  %ebx, %eax      # so sánh a (eax) với b (ebx)
    jle   .else_branch    # nếu a <= b thì nhảy sang else
    subl  %ebx, %eax      # eax = a - b
    jmp   .end
.else_branch:
    subl  %eax, %ebx      # ebx = b - a
    movl  %ebx, %eax      # eax = kết quả
.end:

// C code
int i = 0, sum = 0;
while (i < 10) {
    sum += i;
    i++;
}

# Assembly tương đương
    movl $0, %ecx         # i = 0
    movl $0, %eax         # sum = 0
.loop_check:
    cmpl $10, %ecx        # so sánh i với 10
    jge  .loop_end        # nếu i >= 10 thì thoát
    addl %ecx, %eax       # sum += i
    incl %ecx             # i++
    jmp  .loop_check
.loop_end:

Địa chỉ cao
┌──────────────────┐
│   ... (caller)   │  ← Caller's frame
├──────────────────┤
│   Argument n     │  ← Tham số thứ n (đẩy vào stack từ phải sang trái)
│   ...            │
│   Argument 1     │
├──────────────────┤
│  Return Address  │  ← Địa chỉ lệnh tiếp theo của caller (push khi call)
├──────────────────┤  ← %ebp trỏ vào đây
│   Saved %ebp     │  ← Lưu frame pointer cũ
├──────────────────┤
│ Saved Registers  │
│ Local Variables  │
├──────────────────┤  ← %esp trỏ vào đây (đỉnh stack)
Địa chỉ thấp

8(%ebp)     # Tham số thứ 1
12(%ebp)    # Tham số thứ 2
-4(%ebp)    # Biến cục bộ thứ 1
-8(%ebp)    # Biến cục bộ thứ 2

# Lệnh call:
# 1. Push địa chỉ lệnh kế tiếp (Return Address) vào stack
# 2. Nhảy đến địa chỉ hàm được gọi
call  func_name

# Lệnh ret:
# 1. Pop Return Address từ stack
# 2. Nhảy về địa chỉ đó
ret

int val[5];
// val[0] tại địa chỉ x
// val[1] tại địa chỉ x + 4
// val[i] tại địa chỉ x + 4*i

# Truy cập val[i], biết &val[0] trong %eax, i trong %ecx
movl (%eax, %ecx, 4), %edx    # edx = val[i]

struct example {
    char  a;    // 1 byte tại offset 0
    // 3 bytes padding
    int   b;    // 4 bytes tại offset 4
    char  c;    // 1 byte tại offset 8
    // 3 bytes padding
};
// sizeof(struct example) = 12, không phải 6!

union data {
    int   i;    // 4 bytes
    float f;    // 4 bytes
    char  c;    // 1 byte
};
// sizeof(union data) = 4 (kích thước của thành phần lớn nhất)

void vulnerable(char *input) {
    char buf[8];
    strcpy(buf, input);  // Không kiểm tra độ dài!
}

Stack khi bị overflow:
┌──────────────┐
│ Return Addr  │ ← bị ghi đè bởi attacker!
├──────────────┤
│  Saved %ebp  │ ← bị ghi đè
├──────────────┤
│ buf[7..0]    │ ← 8 bytes buffer
└──────────────┘

int arr[5];
arr[10] = 42;  // Truy xuất ngoài phạm vi!