cmp rax, 100     ; 比较 rax 和 100
jg  above_100    ; 若 rax > 100（有符号）则跳转

mov rax, 0x1234    ; RAX = 0x1234
add rbx, 10        ; RBX += 10（立即数10直接编码）

xor rax, rax       ; 清零RAX（寄存器操作）
add rcx, rdx       ; RCX += RDX

mov al, [0x8048000]  ; 读取绝对地址（实模式/内核态）

mov rsi, array_ptr
mov eax, [rsi]      ; EAX = *array_ptr

struct {
    int a;    // +0
    int b;    // +4
};
mov ecx, [rdi+4]   ; 访问结构体的b成员

mov rsi, 0          ; 索引初始化
loop_start:
    mov al, [array + rsi]
    inc rsi
    cmp rsi, 10
    jl  loop_start

; 访问int数组（每个元素4字节）
mov esi, 2          ; 索引=2
mov eax, [array + rsi*4] ; 相当于array[2]

mov eax, [ebx + esi*4 + 16] ; EAX = *(EBX + ESI*4 + 16)

section .data
    msg db "Hello",0
section .text
    lea rsi, [rel msg]  ; RIP相对寻址（推荐写法）

; C结构体：
; struct { char a; int b; short c; } s;
mov  al, [rdi]         ; s.a (offset=0)
mov  ebx, [rdi+4]      ; s.b (offset=4)
mov  cx, [rdi+8]       ; s.c (offset=8)

; int arr[3][4] → 行优先存储
; arr[i][j] = [base + i*16 + j*4]
mov rsi, 1           ; i=1
mov rdi, 2           ; j=2
mov eax, [array + rsi*16 + rdi*4] ; eax = arr[1][2]

; 调用者代码
push arg3    ; 参数3
push arg2    ; 参数2
push arg1    ; 参数1
call func
add esp, 12  ; 调用者清理栈（3个参数 × 4字节）

; 被调用者代码
func:
    push ebp
    mov ebp, esp
    ; ... 函数体 ...
    mov eax, return_value
    leave
    ret

; 调用者代码
push arg3
push arg2
push arg1
call func    ; 被调用者自己清理栈

; 被调用者代码
func:
    push ebp
    mov ebp, esp
    ; ... 函数体 ...
    mov eax, return_value
    leave
    ret 12   ; 清理 12 字节（3个参数 × 4字节）

; x64 Windows 示例
mov rcx, arg1    ; 第1个参数
mov rdx, arg2    ; 第2个参数
mov r8, arg3     ; 第3个参数
mov r9, arg4     ; 第4个参数
sub rsp, 32      ; 预留影子空间（Shadow Space）
call func
add rsp, 32      ; 调用者清理栈

my_func:
    push rbp          ; 保存旧的 RBP
    mov rbp, rsp      ; 设置新的栈帧基址
    sub rsp, 16       ; 分配 16 字节局部变量空间

    mov [rbp-8], rcx  ; 存储局部变量1
    mov [rbp-16], rdx ; 存储局部变量2

    ; ... 函数逻辑 ...

    mov rsp, rbp      ; 恢复 RSP
    pop rbp           ; 恢复旧的 RBP
    ret               ; 返回

main:
        push    rbp
        mov     rbp, rsp
        ; int a = 10;
        mov     DWORD PTR [rbp-4], 10

        ; if (a > 5)
        mov     eax, DWORD PTR [rbp-4] ; 将变量 a 的值加载到寄存器 eax
        cmp     eax, 5                 ; 比较 (eax - 5), 并设置标志位
        jle     .L2                    ; 条件跳转: 如果 `a <= 5` (Less than or Equal), 则跳转到 .L2 标签（else 块）

        ; if 块: a = 20;
        mov     DWORD PTR [rbp-4], 20
        jmp     .L3                    ; 无条件跳转: 跳过 else 块，直接到 .L3

.L2:    ; else 块标签
        ; else 块: a = 0;
        mov     DWORD PTR [rbp-4], 0

.L3:    ; if-else 之后的代码标签
        ; return a;
        mov     eax, DWORD PTR [rbp-4] ; 将返回值放入 eax
        pop     rbp
        ret

switch_example:
        ; x 在 edi 寄存器中
        cmp     edi, 2           ; 首先比较 x 和最大的 case 值 (2)
        ja      .L8              ; 如果 x > 2 (无符号比较), 跳转到 default (.L8)
        mov     eax, edi         ; 将 x 的值复制到 eax
        ; 下一行是精髓：通过跳转表直接跳转
        jmp     [QWORD PTR .L4[0+rax*8]] ; 计算地址 .L4 + rax*8，从中取出目标地址并跳转

.L4:
        ; 这就是跳转表！不是一个指令，而是一个数据段，存储着代码块的地址
        .quad   .L7              ; case 0 的地址
        .quad   .L8              ; case 1 的地址 (注意：这里原代码是 case 1: return 20; 但标签是.L5)
        .quad   .L6              ; case 2 的地址

.L7:    ; case 0
        mov     eax, 10
        ret
.L5:    ; case 1 (被优化了，见下文分析)
        mov     eax, 20
        ret
.L6:    ; case 2
        mov     eax, 30
        ret
.L8:    ; default
        mov     eax, 0
        ret

sparse_switch:
        ; x 在 edi 中
        cmp     edi, 200         ; 先和中间值 200 比较
        je      .L13             ; 如果等于 200，跳转
        jg      .L14             ; 如果大于 200，跳转到 .L14 处理更大的数
        cmp     edi, 100         ; 如果小于等于 200，再和 100 比较
        je      .L15             ; 如果等于 100，跳转
        jmp     .L11             ; 否则，跳转到 default

.L14:   ; 处理大于 200 的情况
        cmp     edi, 300
        je      .L16
        cmp     edi, 400         ; 继续比较下一个值
        je      .L17
        jmp     .L11             ; 都不匹配，跳转到 default

.L15:   ; case 100
        mov     eax, 1
        ret
.L13:   ; case 200
        mov     eax, 2
        ret
.L16:   ; case 300
        mov     eax, 3
        ret
.L17:   ; case 400
        mov     eax, 4
        ret
.L11:   ; default
        mov     eax, 0
        ret