X0  // 访问完整的64位寄存器
W0  // 只访问低32位（高32位清零）

MOV X0, 0x123456789ABCDEF0  @ X0 = 0x123456789ABCDEF0
MOV W1, 0x12345678          @ W1 = 0x0000000012345678
ADD W0, W1, W1              @ X0 = 0x000000002468ACF0

// C代码
int result = add(10, 20, 30);

// 对应的寄存器使用：
// X0 = 10 (第一个参数)
// X1 = 20 (第二个参数) 
// X2 = 30 (第三个参数)
// 返回值通过 X0 返回

BL my_function    @ 跳转到my_function，同时将返回地址保存到LR
                  @ 在my_function中：
RET               @ 等同于 MOV PC, LR，跳回到调用处

SUB SP, SP, #16   @ 在栈上分配16字节空间
ADD SP, SP, #16   @ 释放栈空间

MOV X0, XZR       @ X0 = 0
CMP X1, XZR       @ 比较X1是否等于0

@ 函数定义
my_function:
    SUB SP, SP, #16       @ 1. 在栈上分配空间
    STR X30, [SP, #8]     @ 2. 保存返回地址(LR)
    STR X29, [SP, #0]     @ 3. 保存帧指针(FP)

    @ 函数体...
    ADD X0, X0, X1        @ 使用X0,X1(参数寄存器)

    LDR X29, [SP, #0]     @ 恢复FP
    LDR X30, [SP, #8]     @ 恢复LR  
    ADD SP, SP, #16       @ 释放栈空间
    RET                   @ 返回

@ 计算 (a + b) * c
@ 假设: a在X0, b在X1, c在X2

ADD X3, X0, X1    @ X3 = a + b (使用临时寄存器X3)
MUL X0, X3, X2    @ X0 = (a+b) * c，结果放在X0返回
RET

// C代码
int calculate(int a, int b, int c) {
    int temp = a + b;
    return temp * c;
}

// 所有函数都遵守统一的参数传递规则
void func(int a, int b, int c, int d, int e, int f);
// 调用时：
// R0 = a, R1 = b, R2 = c, R3 = d (前4个参数)
// [SP+0] = e, [SP+4] = f (第5、6个参数通过栈传递)

; 调用 func(1, 2, 3, 4)
MOV R0, #1      ; 参数1 → R0
MOV R1, #2      ; 参数2 → R1  
MOV R2, #3      ; 参数3 → R2
MOV R3, #4      ; 参数4 → R3
BL func         ; 调用函数

; 调用 func(1, 2, 3, 4, 5, 6)
MOV R0, #1      ; 参数1 → R0
MOV R1, #2      ; 参数2 → R1
MOV R2, #3      ; 参数3 → R2  
MOV R3, #4      ; 参数4 → R3
SUB SP, SP, #8  ; 为额外参数分配栈空间
MOV R4, #5
STR R4, [SP, #0] ; 参数5 → [SP+0]
MOV R4, #6
STR R4, [SP, #4] ; 参数6 → [SP+4]
BL func         ; 调用函数
ADD SP, SP, #8  ; 清理栈空间

func:
    PUSH {R4-R6, LR}    ; 如果要使用R4-R11，必须先保存

    ; 访问参数：
    ; 前4个参数直接在R0-R3中
    MOV R4, R0          ; 参数1保存到R4
    MOV R5, R1          ; 参数2保存到R5

    ; 访问第5个及以后的参数（需要计算栈偏移）
    LDR R6, [SP, #16]   ; 参数5在[SP+16]（跳过PUSH的寄存器）

; main函数准备参数（6个参数）
main:
    MOV R0, #10         ; 参数1 → R0
    MOV R1, #20         ; 参数2 → R1
    MOV R2, #30         ; 参数3 → R2
    MOV R3, #40         ; 参数4 → R3
    SUB SP, SP, #8      ; 为额外参数分配空间
    MOV R4, #50
    STR R4, [SP, #0]    ; 参数5 → [SP+0]
    MOV R4, #60         
    STR R4, [SP, #4]    ; 参数6 → [SP+4]
    BL complex_calc     ; 调用函数

; complex_calc函数接收所有参数
complex_calc:
    PUSH {R4-R6, LR}
    ; 接收寄存器中的参数
    MOV R4, R0          ; 参数1 = 10
    MOV R5, R1          ; 参数2 = 20
    ; 接收栈中的参数
    LDR R6, [SP, #16]   ; 参数5 = 50
    ; ... 计算 ...
    MOV R0, R4          ; 结果通过R0返回
    POP {R4-R6, PC}

main:
    MOV R4, R0              ; 如果R0有重要数据，先保存到R4
    BL other_func           ; 调用其他函数
    ; 我知道other_func可能会改动R0-R3，所以不依赖它们
    MOV R0, R4              ; 恢复我原来的数据

; 任何函数如果想用R4-R11，都必须：
my_func:
    PUSH {R4-R6}        ; 先保存原来的值
    ; ... 使用R4-R6 ...  ; 随便使用
    POP {R4-R6}         ; 恢复原样，不影响其他函数
    BX LR

// 所有函数共享同一套寄存器，但通过规则协作
int add(int a, int b) {
    return a + b;       // 用R0,R1接收参数，R0返回结果
}

int complex_calc(int a, int b, int c, int d, int e, int f) {
    // 前4个参数在寄存器，后2个在栈中
    int sum = a + b + c + d + e + f;
    return add(sum, 100); // 继续调用其他函数
}

; 所有函数共用寄存器，但各司其职
add:
    ; 我知道：R0=a, R1=b来自调用者
    ADD R0, R0, R1      ; 计算a+b
    ; 我知道：调用者期望结果在R0
    BX LR               ; 返回

complex_calc:
    PUSH {R4-R6, LR}    ; 我要用R4-R6，所以先保存
    ; 接收前4个参数：R0=a, R1=b, R2=c, R3=d
    MOV R4, R0
    MOV R5, R1
    ADD R4, R4, R5      ; a + b
    ADD R4, R4, R2      ; + c
    ADD R4, R4, R3      ; + d

    ; 接收栈中的第5、6个参数
    LDR R5, [SP, #16]   ; 参数e (跳过PUSH的4个寄存器)
    LDR R6, [SP, #20]   ; 参数f
    ADD R4, R4, R5      ; + e
    ADD R4, R4, R6      ; + f

    ; 调用add函数
    MOV R0, R4          ; 第一个参数 = sum
    MOV R1, #100        ; 第二个参数 = 100
    BL add

    ; 我知道：add的结果在R0中
    POP {R4-R6, PC}     ; 恢复寄存器，返回