addi sp, sp, -16  # 分配16字节栈空间
sw   ra, 12(sp)   # 保存返回地址到栈中

# 异常处理入口
csrrw t0, mepc, t0  # 读取EPC值到t0寄存器（需通过CSR指令操作）

jal ra, function  # 跳转到function标签，同时将返回地址（PC+4）保存到ra寄存器

# 设置异常向量表
la t0, trap_handler
csrw mtvec, t0

# 或设置为向量模式
li t0, 0x1000 | 1  # BASE=0x1000, MODE=01
csrw mtvec, t0

trap_handler:
    csrrw t0, mepc, t0  # 读取mepc到t0
    addi t0, t0, 4      # 跳过导致异常的指令
    csrrw t0, t0, mepc  # 写回mepc
    mret                # 返回时执行下一条指令

# 开启全局中断
li t0, 0x8        # MIE = 1
csrs mstatus, t0

# 关闭全局中断
li t0, 0x8
csrc mstatus, t0

# 使能定时器中断
li t0, 0x80       # MTIE = 1
csrs mie, t0

# 使能外部中断
li t0, 0x800      # MEIE = 1
csrs mie, t0

// 伪代码表示硬件行为
mepc = PC;                    // 保存当前PC
mcause = {interrupt, code};   // 设置原因
mstatus.MPIE = mstatus.MIE;   // 保存MIE状态
mstatus.MIE = 0;              // 关闭中断
mstatus.MPP = current_priv;   // 保存当前特权级
PC = mtvec.BASE;              // 跳转到异常处理程序

.section .text
.global trap_handler
trap_handler:
    # 1. 保存上下文（到栈中）
    addi sp, sp, -32
    sw ra, 0(sp)
    sw t0, 4(sp)
    # ... 保存其他寄存器
    
    # 2. 读取异常原因
    csrr t0, mcause
    blt t0, zero, handle_interrupt  # 最高位为1表示中断
    
    # 3. 处理同步异常
    andi t0, t0, 0x7F  # 获取异常代码
    li t1, 8           # ECALL代码
    beq t0, t1, handle_ecall
    j handle_other_exception
    
handle_interrupt:
    # 处理中断
    andi t0, t0, 0x7F  # 获取中断代码
    li t1, 7           # 定时器中断
    beq t0, t1, handle_timer
    j handle_other_interrupt
    
handle_ecall:
    # 处理系统调用
    csrr a0, mepc      # 获取触发ecall的地址
    # ... 系统调用处理逻辑
    addi a0, a0, 4     # 跳过ecall指令
    csrw mepc, a0
    j trap_exit
    
handle_timer:
    # 处理定时器中断
    # ... 清除定时器中断标志
    j trap_exit
    
trap_exit:
    # 恢复上下文
    lw ra, 0(sp)
    lw t0, 4(sp)
    # ... 恢复其他寄存器
    addi sp, sp, 32
    
    # 返回
    mret

// mret执行时硬件自动完成：
MIE = MPIE;          // 恢复中断使能状态
MPIE = 1;            // 设置为1
PC = mepc;           // 跳回原程序
privilege_mode = MPP;// 恢复特权级

jal ra, target   # 硬件自动执行：ra = PC + 4
                 # 同时跳转到 target

// 伪代码表示 jal 的行为
temp = PC + 4;          // 计算返回地址
PC = PC + sign_extend(offset << 1);  // 计算目标地址（偏移左移1位，因为指令2字节对齐）
rd = temp;              // 保存返回地址

jal ra, func    # 跳转到 func，ra = 返回地址
jal func        # 省略 rd，默认为 ra（汇编器扩展）

// 叶子函数：不调用其他函数
int max(int a, int b) {
    return (a > b) ? a : b;
}

int calculate(int x, int y) {
    int sum = x + y;      // 没有函数调用
    int diff = x - y;     // 没有函数调用
    return sum * diff;    // 没有函数调用
}

# max函数 - 叶子函数，不需要保存ra
max:
    bge  a0, a1, max_a0   # if (a0 >= a1) goto max_a0
    mv   a0, a1           # else a0 = a1
max_a0:
    ret                   # 直接返回，ra没有被修改

# calculate函数 - 叶子函数，不需要保存ra
calculate:
    add  t0, a0, a1       # t0 = x + y
    sub  t1, a0, a1       # t1 = x - y
    mul  a0, t0, t1       # a0 = sum * diff
    ret                   # 直接返回

// 非叶子函数：调用了其他函数
int complex_calc(int a, int b) {
    int square_sum = square(a) + square(b);  // 两次函数调用！
    return sqrt(square_sum);                 // 又一次函数调用！
}

int square(int x) {
    return x * x;  // 叶子函数
}

int sqrt(int n) {
    // 简化实现，实际更复杂
    return n / 2;  // 叶子函数
}

# complex_calc函数 - 非叶子函数，必须保存ra
complex_calc:
    # ==== 序言：保存上下文 ====
    addi sp, sp, -16      # 分配栈空间
    sw   ra, 12(sp)       # 必须保存！否则会被覆盖
    sw   s0, 8(sp)        # 保存s0（如果需要）
    
    # 保存原始参数
    mv   s0, a1           # 保存b到s0
    
    # 第一次函数调用：square(a)
    # a0已经是a
    jal  ra, square       # 调用square(a)
    # 此时ra被覆盖为：返回complex_calc+16的地址
    mv   t0, a0           # 保存结果到t0
    
    # 第二次函数调用：square(b)
    mv   a0, s0           # a0 = b
    jal  ra, square       # 调用square(b)
    # 此时ra被覆盖为：返回complex_calc+24的地址
    add  t0, t0, a0       # t0 = square(a) + square(b)
    
    # 第三次函数调用：sqrt(square_sum)
    mv   a0, t0           # a0 = square_sum
    jal  ra, sqrt         # 调用sqrt
    # 此时ra被覆盖为：返回complex_calc+32的地址
    
    # ==== 尾声：恢复上下文 ====
    lw   s0, 8(sp)        # 恢复s0
    lw   ra, 12(sp)       # 恢复原来的返回地址（调用complex_calc的函数地址）
    addi sp, sp, 16       # 释放栈空间
    ret                   # 正确返回到调用者

# square函数 - 叶子函数
square:
    mul  a0, a0, a0
    ret

# sqrt函数 - 叶子函数
sqrt:
    srli a0, a0, 1        # a0 = a0 / 2
    ret

# 错误：非叶子函数没有保存ra
wrong_function:
    # 没有保存ra！
    
    # 调用其他函数
    jal ra, helper        # ra = 返回wrong_function+4的地址
    # 此时ra是返回wrong_function+4的地址
    
    # 函数结束
    ret                   # 问题：返回到wrong_function+4，无限循环！

# 使用tail call优化
tail_call_example:
    # ... 一些计算 ...
    j other_function      # 尾调用，直接跳转，不修改ra
    # 注意：这里没有ret！函数在other_function中结束

# 通过函数指针调用
indirect_call:
    addi sp, sp, -16
    sw   ra, 12(sp)       # 必须保存！
    
    # 函数指针在a1中
    jalr ra, 0(a1)        # 间接调用，会覆盖ra
    
    lw   ra, 12(sp)       # 恢复
    addi sp, sp, 16
    ret

// test.c
int leaf(int a) {
    return a + 1;  // 叶子函数
}

int nonleaf(int a) {
    return leaf(a) + leaf(a+1);  // 非叶子函数
}

# 编译
riscv64-unknown-elf-gcc -S test.c -O1

# 查看汇编
cat test.s

leaf:
    addi    a0,a0,1
    ret

nonleaf:
    addi    sp,sp,-16     # 分配栈
    sw      ra,12(sp)     # 必须保存ra！
    sw      s0,8(sp)      # 保存s0
    mv      s0,a0         # 保存参数
    addi    a0,a0,1
    call    leaf          # 第一次调用
    mv      s1,a0         # 保存结果
    mv      a0,s0
    call    leaf          # 第二次调用
    add     a0,s1,a0      # 相加
    lw      ra,12(sp)     # 恢复ra
    lw      s0,8(sp)      # 恢复s0
    addi    sp,sp,16      # 释放栈
    ret