Immediate  →  $0x400, $-533        ; Hằng số, tiền tố $
Register   →  %eax, %esi           ; Giá trị trong thanh ghi
Memory     →  (%eax), 0x100        ; Giá trị tại địa chỉ bộ nhớ

D(Rb, Ri, S)   →   Mem[Reg[Rb] + S * Reg[Ri] + D]

leal Src, Dst

int mul12(int x) {
    return x * 12;
}

leal (%eax, %eax, 2), %eax    ; %eax = x + 2*x = 3x
sall $2, %eax                  ; %eax = 3x << 2 = 12x

A. movl %eax, %ebx          ; %ebx = %eax = 0x1  → ❌
B. movl 2, %ebx             ; Sai cú pháp (thiếu $) → ❌ không hợp lệ
C. addl %eax, %ebx          ; %ebx = 0x2 + 0x1 = 0x3 → ❌
D. imull %eax, %ebx         ; %ebx = 0x2 * 0x1 = 0x2 → ✅
E. movb $2, %bl             ; 8 bit thấp của %ebx = 2; %ebx = 0x2 → ✅
F. movl (%edx,%eax,2), %ebx ; địa chỉ = 0x2 + 2*0x1 = 0x4 → không hợp lệ ở đây
G. movl 1(%eax), %ebx       ; địa chỉ = 0x1 + 1 = 0x2, đọc Mem[0x2] → không xác định
H. addl (%ecx), %ebx        ; %ebx += Mem[0x1] → không xác định

; x tại (%ebp+8), y tại (%ebp+12), z tại (%ebp+16)
movl 12(%ebp), %eax    ; %eax = y
xorl 8(%ebp), %eax     ; %eax = y ^ x
sall $5, %eax          ; %eax = (y^x) << 5
incr %eax              ; %eax = ((y^x)<<5) + 1   [lưu ý: đây là lỗi đánh máy, phải là incl]
subl 16(%ebp), %eax    ; %eax = ((y^x)<<5) + 1 - z

int fun2(int x, int y, int z) {
    int t1 = y - x;
    int t2 = 6 * z;
    return t1 ^ t2;
}

movl 16(%ebp), %edx         ; %edx = z
movl 12(%ebp), %eax         ; %eax = y
subl 8(%ebp),  %eax         ; %eax = y - x  (t1)
leal (%edx,%edx,2), %edx    ; %edx = z + 2z = 3z
addl %edx, %edx             ; %edx = 3z + 3z = 6z  (t2)
xorl %edx, %eax             ; %eax = t1 ^ t2  → kết quả
ret

; x tại (%ebp+8), y tại (%ebp+12)
movl 8(%ebp),  %eax     ; %eax = x
subl 12(%ebp), %eax     ; %eax = x - y
sarl $31, %eax          ; %eax = (x-y) >> 31  → toàn bit 0 hoặc toàn bit 1 (mask)
movl %eax,   %edx       ; %edx = mask
andl 12(%ebp), %eax     ; %eax = mask & y
notl %edx               ; %edx = ~mask
andl 8(%ebp),  %edx     ; %edx = ~mask & x
orl  %edx,     %eax     ; %eax = (mask & y) | (~mask & x)

movl 0x102, %eax               ; %eax = a
leal (%eax,%eax,4), %eax       ; %eax = a + 4a = 5a
leal 2(%eax), %eax             ; %eax = 5a + 2
leal (%eax,%eax), %eax         ; %eax = 2*(5a+2) = 10a + 4

; Cách 1:
leal 2(%eax,%eax,2), %eax      ; %eax = 2 + 3a
leal (%ebx,%eax,2), %eax       ; %eax = b + 2*(3a+2) = 6a + b + 4 ✅

; Cách 2:
leal 4(%ebx,%eax,4), %ebx      ; %ebx = b + 4a + 4
leal (%ebx,%eax,2), %eax       ; %eax = (b+4a+4) + 2a = 6a + b + 4 ✅

movl 8(%ebp),  %eax    ; %eax = x
addl 12(%ebp), %eax    ; %eax = x + y
imull %eax, %eax       ; %eax = (x+y)²
sarl $1, %eax          ; %eax = (x+y)² >> 1 = (x+y)²/2 (lấy phần nguyên)

int func5(char* str) {
    int a = str[0] - '0';  // '0' = 0x30 = 48
    int b = str[1] - '0';
    return a + b;
}

movl  8(%ebp), %eax      ; (1) %eax = địa chỉ str  ✅
movl  (%eax),  %al       ; (2) %al = str[0]  ⚠️ suffix không khớp
subl  $0x48,   %eax      ; (3) str[0] - '0'  ⚠️ dùng %eax thay vì %al
mov   1(%eax), %bh       ; (4) str[1] → vào %bh ❌ địa chỉ sai
subl  $'0,     %ebx      ; (5) - '0' ❌ cú pháp sai
addl  %ebx,    %eax      ; (6) a + b  ⚠️ size không nhất quán

; x tại (%ebp+8), n tại (%ebp+12)
movl 12(%ebp), %ecx    ; (1) %ecx = n
movl  8(%ebp), %edx    ; (2) %edx = x
xorl %eax, %eax        ; (3) %eax = 0
addl $1, %eax          ; (4) %eax = 1
sall %ecx, %eax        ; (5) %eax = 1 << n   ← LỖI
subl $1, %eax          ; (6) %eax = (1<<n) - 1
andl %edx, %eax        ; (7) %eax = x & ((1<<n)-1)

Assembly cơ bản
├── Thanh ghi
│   ├── IA32: %eax..%ebp (32-bit)
│   └── x86-64: %rax..%r15 (64-bit)
├── Chuyển dữ liệu
│   ├── mov{b,w,l,q} — suffix khớp với kích thước thanh ghi
│   └── Không có Mem→Mem trực tiếp
├── Địa chỉ bộ nhớ
│   └── D(Rb, Ri, S) = Mem[Rb + S*Ri + D]
├── leal — tính địa chỉ/biểu thức, không đọc bộ nhớ
└── Phép tính
    ├── 2 toán hạng: add, sub, imul, sal, sar, shr, xor, and, or
    └── 1 toán hạng: inc, dec, neg, not