┌──────────────────────────────────────┐
│  1. Chuyển luồng thực thi            │
│     - Nhảy vào hàm được gọi          │
│     - Trở về đúng vị trí sau khi gọi │
├──────────────────────────────────────┤
│  2. Truyền dữ liệu                   │
│     - Đẩy tham số vào stack          │
│     - Nhận giá trị trả về (%eax)     │
├──────────────────────────────────────┤
│  3. Quản lý bộ nhớ                   │
│     - Cấp phát stack frame           │
│     - Thu hồi khi hàm kết thúc       │
└──────────────────────────────────────┘

Địa chỉ cao  ┌─────────────────┐  ← Stack "Bottom"
             │      ...        │
             │   dữ liệu cũ   │
             ├─────────────────┤
             │   dữ liệu mới  │
             ├─────────────────┤  ← %esp (Stack Pointer)
             │   (trống)       │
Địa chỉ thấp └─────────────────┘  ← Stack "Top" (đỉnh hiện tại)

pushl Src    ; IA32 — push 4 bytes

; Tương đương với:
subl $4, %esp
movl Src, (%esp)

popl Dest    ; IA32 — pop 4 bytes

; Tương đương với:
movl (%esp), Dest
addl $4, %esp

call label
; Thực chất tương đương:
push %eip        ; lưu địa chỉ lệnh tiếp theo vào stack
jmp label        ; nhảy đến hàm

ret
; Thực chất tương đương:
pop %eip         ; lấy địa chỉ trả về ra khỏi stack
jmp *%eip        ; nhảy về đó

%eip = 0x804854e
%esp = 0x108
Stack[0x108] = 123

%esp = 0x104          (giảm 4)
Stack[0x104] = 0x8048553   (return address được push)
%eip = 0x8048b90      (nhảy vào main)

%eip = 0x8048553      (pop từ stack)
%esp = 0x108          (tăng 4)
; Tiếp tục thực thi từ 0x8048553

         ┌──────────────────┐
Caller   │   Arguments      │  ← Tham số truyền cho hàm con
Frame    │   Return Address │  ← Tự động push bởi lệnh call
         ├──────────────────┤  ← %ebp của frame hiện tại
Callee   │   Old %ebp       │  ← Frame pointer của hàm mẹ (được lưu)
Frame    │   Saved Regs     │  ← Các thanh ghi cần bảo toàn
         │   Local Vars     │  ← Biến cục bộ của hàm
         │   Arg Build      │  ← Tham số để gọi hàm khác (nếu có)
         └──────────────────┘  ← %esp

pushl %ebp          ; lưu frame pointer của hàm mẹ
movl  %esp, %ebp    ; thiết lập frame pointer cho hàm hiện tại
subl  $N, %esp      ; cấp phát N bytes cho biến cục bộ
pushl %ebx          ; lưu các thanh ghi callee-saved (nếu dùng)

popl  %ebx          ; khôi phục các thanh ghi đã lưu
; addl $N, %esp     ; thu hồi không gian biến cục bộ
; popl %ebp         ; hoặc dùng lệnh 'leave' thay cho 2 dòng trên
leave               ; tương đương: movl %ebp, %esp  +  popl %ebp
ret

int main() {
    int result = func(5, 6);
    return result;
}

int func(int x, int y) {
    int sum = 0;
    sum = x + y;
    return sum;
}

main:
    pushl  %ebp          ; set-up: lưu old %ebp
    movl   %esp, %ebp    ; set-up: thiết lập %ebp
    subl   $16, %esp     ; cấp phát 16 bytes cho biến cục bộ
    pushl  $6            ; đẩy tham số 2 (y=6) vào stack
    pushl  $5            ; đẩy tham số 1 (x=5) vào stack
    call   func          ; gọi hàm func (push return addr + jmp)
    addl   $8, %esp      ; dọn dẹp 2 tham số (2 x 4 bytes)
    movl   %eax, -4(%ebp); lưu giá trị trả về vào biến result
    movl   -4(%ebp), %eax; đặt return value của main vào %eax
    leave               ; finish: khôi phục %esp và %ebp
    ret

func:
    pushl  %ebp          ; set-up
    movl   %esp, %ebp
    subl   $16, %esp     ; cấp phát cho biến 'sum'
    movl   $0, -4(%ebp)  ; sum = 0
    movl   8(%ebp), %edx ; lấy x (tham số 1, offset +8 từ %ebp)
    movl   12(%ebp), %eax; lấy y (tham số 2, offset +12 từ %ebp)
    addl   %edx, %eax    ; eax = x + y
    movl   %eax, -4(%ebp); sum = x + y
    movl   -4(%ebp), %eax; chuẩn bị return value
    leave
    ret

void swap(int *xp, int *yp) {
    int t0 = *xp;
    int t1 = *yp;
    *xp = t1;
    *yp = t0;
}

swap:
    pushl %ebp           ; set-up
    movl  %esp, %ebp
    pushl %ebx           ; lưu %ebx (callee-saved)

    movl  8(%ebp),  %edx ; edx = xp  (địa chỉ của x)
    movl  12(%ebp), %ecx ; ecx = yp  (địa chỉ của y)
    movl  (%edx),   %ebx ; ebx = *xp = t0
    movl  (%ecx),   %eax ; eax = *yp = t1
    movl  %eax, (%edx)   ; *xp = t1
    movl  %ebx, (%ecx)   ; *yp = t0

    popl  %ebx           ; finish: khôi phục %ebx
    popl  %ebp
    ret

int func(int x, int y) { return x + y; }

func:
    pushl %ebp
    movl  %esp, %ebp
    movl  8(%ebp),  %edx
    movl  12(%ebp), %eax
    addl  %edx, %eax    ; eax = x + y  ← đây là return value
    popl  %ebp
    ret

Caller-Save (hàm mẹ tự lưu trước khi gọi):
  %eax  — cũng là register chứa return value
  %edx
  %ecx

Callee-Save (hàm con lưu nếu muốn dùng):
  %ebx
  %esi
  %edi

Special (bắt buộc khôi phục):
  %esp  — stack pointer
  %ebp  — frame pointer

subl $24, %esp      ; cấp phát 24 bytes cho biến cục bộ

movl %eax, -4(%ebp)   ; lưu vào biến cục bộ đầu tiên
movl -8(%ebp), %edx   ; đọc biến cục bộ thứ hai

┌─────────────┐  ← địa chỉ cao (bottom)
│  Frame: yoo │
├─────────────┤
│  Frame: who │
├─────────────┤
│ Frame: amI  │  (lần 1)
├─────────────┤
│ Frame: amI  │  (lần 2)
├─────────────┤
│ Frame: amI  │  (lần 3)  ← %esp trỏ vào đây (top)
└─────────────┘  ← địa chỉ thấp

main:
    pushl  %ebp
    movl   %esp, %ebp
    subl   $16, %esp
    movl   $1,  -4(%ebp)    ; biến a = 1
    movl   $2,  -8(%ebp)    ; biến b = 2
    movl   $0,  -12(%ebp)   ; biến c = 0
    pushl  -4(%ebp)          ; push a (= 1)  → tham số 2 của function
    pushl  -8(%ebp)          ; push b (= 2)  → tham số 1 của function
    call   function
    addl   $8, %esp
    movl   %eax, -12(%ebp)  ; c = return value
    movl   $0, %eax
    leave
    ret

function:
    pushl  %ebp
    movl   %esp, %ebp
    subl   $16, %esp
    movl   $10, -4(%ebp)           ; a = 10
    movl   -4(%ebp), %edx          ; edx = 10
    movl   8(%ebp),  %eax          ; eax = x (tham số 1 = 2)
    addl   %eax, %edx              ; edx = 10 + 2 = 12
    movl   12(%ebp), %eax          ; eax = y (tham số 2 = 1)
    imull  %edx, %eax              ; eax = 12 * 1 = 12
    movl   %eax, -8(%ebp)          ; result = 12
    movl   -8(%ebp), %eax          ; return value = 12
    leave
    ret