risc-v中的函数调用
先来看一个普通main函数的完整执行过程(以a=b problem为例)
int main()
{
int a = 2;
int b = 3;
int c = a + b;
}
其risc-v(rv32)的汇编如下
main:
addi sp,sp,-32 # 将栈指针sp向下移动32个字节，预留栈空间
sw ra,28(sp) # 将返回地址ra存储到栈的偏移28字节处
sw s0,24(sp) # 将保存寄存器s0存储到栈的偏移24字节处
addi s0,sp,32 # 设置帧指针s0，指向当前栈顶
li a5,2 # 将立即数2加载到寄存器a5
sw a5,-20(s0) # 将a5的值存储到栈的偏移-20字节处
li a5,3 # 将立即数3加载到寄存器a5
sw a5,-24(s0) # 将a5的值存储到栈的偏移-24字节处
lw a4,-20(s0) # 从栈的偏移-20字节处加载数据到a4
lw a5,-24(s0) # 从栈的偏移-24字节处加载数据到a5
add a5,a4,a5 # 将a4和a5的值相加，结果存入a5
sw a5,-28(s0) # 将a5的值存储到栈的偏移-28字节处
li a5,0 # 将立即数0加载到寄存器a5
mv a0,a5 # 将a5的值移动到a0
lw ra,28(sp) # 从栈的偏移28字节处加载返回地址ra
lw s0,24(sp) # 从栈的偏移24字节处加载保存寄存器s0
addi sp,sp,32 # 将栈指针sp向上移动32个字节，释放栈空间
jr ra # 跳转到返回地址ra（函数返回）
一个函数的执行大致可以分为三个部分:开场(prologue),执行过程，结语(epilogue)
(这三个中文是我瞎起，别当真)
prologue
将栈指针-32进行开栈(rv32中一个字四字节，留了8个字的大小)
将返回地址(寄存器ra中的值)store到28(sp)中
将s0(帧指针fp，指向栈帧起始位置)的值store到24(sp)中
将sp+32的值赋给s0，使帧指针s0指向栈帧起始位置
执行过程
先将一个立即数放到寄存器a5，将a5的值压栈
再将另一个立即数放到寄存器a5,然后压栈
将两个立即数分别load到a4,a5寄存器，执行add指令，将结果保存在寄存器a5，然后再将a5的值store到-28(s0)
解释最后将立即数0 load到寄存器a5，然后又将这个0从a5 mv 到 a0的操作 :
首先需要区分两个概念 : 返回地址(ra存储)和返回值(a0存储)
然后，因为源代码没有指明返回值，所以默认return 0。这也就是立即数0的由来
至于为什么需要先放到寄存器a5再由a5 mv 到 a0是一个习惯问题，我自己也没咋搞懂，就先不深究
epilogue
先将在prologue时保存在栈帧上的ra和s0的值load回对应寄存器，然后将sp+32来回收栈。最后跳转到返回地址。
调用一个函数
int f(int x , int y)
{
return 0;
}
int main()
{
int a = 1;
f(1,2);
int b = 1;
}
f:
addi sp, sp, -32 # 栈指针向下移动 32 字节，分配栈帧空间
sw ra, 28(sp) # 将返回地址寄存器 `ra` 保存到栈偏移 28 字节处
sw s0, 24(sp) # 将寄存器 `s0` 保存到栈偏移 24 字节处
addi s0, sp, 32 # 设置新的帧指针 `s0` 为 `sp` 加 32 字节
sw a0, -20(s0) # 将寄存器 `a0` 的值保存到 `s0` 偏移 -20 字节处
sw a1, -24(s0) # 将寄存器 `a1` 的值保存到 `s0` 偏移 -24 字节处
li a5, 0 # 将立即数 0 加载到寄存器 `a5`
mv a0, a5 # 将寄存器 `a5` 的值移动到寄存器 `a0`
lw ra, 28(sp) # 从栈偏移 28 字节处恢复返回地址到 `ra`
lw s0, 24(sp) # 从栈偏移 24 字节处恢复 `s0` 的值
addi sp, sp, 32 # 恢复栈指针，释放 32 字节的栈帧
jr ra # 跳转到返回地址寄存器 `ra` 的地址（即返回调用者）
main:
addi sp,sp,-32 # 分配32字节的栈空间
sw ra,28(sp) # 保存返回地址到栈
sw s0,24(sp) # 保存 s0 到栈
addi s0,sp,32 # 设置 s0 指向栈顶
#######################################################################
li a5,1 # 将立即数1加载到 a5
sw a5,-20(s0) # 将 a5 的值存储到栈的偏移 -20 处
li a1,2 # 将立即数2加载到 a1
li a0,1 # 将立即数1加载到 a0
#######################################################################
call f # 调用函数 f
#######################################################################
li a5,1 # 将立即数1加载到 a5
sw a5,-24(s0) # 将 a5 的值存储到栈的偏移 -24 处
#######################################################################
li a5,0 # 将立即数0加载到 a5
mv a0,a5 # 将 a5 的值移动到 a0
lw ra,28(sp) # 从栈的偏移 28 处加载返回地址到 ra
lw s0,24(sp) # 从栈的偏移 24 处加载 s0 的值
addi sp,sp,32 # 释放栈空间
jr ra # 跳转到返回地址 ra（函数返回）
在调用函数f前，先做了一步将函数f的两个参数放入寄存器a1,a0中。这是因为寄存器a1,a0是调用者保存寄存器(a调用b的话，由a函数来管理调用者保存寄存器的内容)
调用函数f时，将保存着函数参数的a1,a0寄存器压入栈中。
这时我们可以发现，当一个参数寄存器(形式为ax)保存一个数后必定会先将其压入栈中再执行其他操作
其他操作则在第一个例子全都讲过。
递归调用
以一个斐波那契数列举例
int f(int x)
{
if(x == 1 || x == 2) return 1;
return f(x-1) + f(x-2);
}
f:
addi sp, sp, -32 # 栈指针向下移动 32 字节，分配栈帧空间
sw ra, 28(sp) # 将返回地址寄存器 `ra` 保存到栈偏移 28 字节处
sw s0, 24(sp) # 将 `s0` 寄存器保存到栈偏移 24 字节处
sw s1, 20(sp) # 将 `s1` 寄存器保存到栈偏移 20 字节处
addi s0, sp, 32 # 设置新的帧指针 `s0` 为 `sp` 加 32 字节
sw a0, -20(s0) # 将 `a0` 的值保存到 `s0` 偏移 -20 字节处
lw a4, -20(s0) # 将 `s0` 偏移 -20 字节处的值加载到 `a4`
li a5, 1 # 将立即数 1 加载到寄存器 `a5`
beq a4, a5, .L2 # 如果 `a4` == 1，则跳转到标签 .L2
lw a4, -20(s0) # 将 `s0` 偏移 -20 字节处的值加载到 `a4`
li a5, 2 # 将立即数 2 加载到寄存器 `a5`
bne a4, a5, .L3 # 如果 `a4` != 2，则跳转到标签 .L3
.L2:
li a5, 1 # 将立即数 1 加载到寄存器 `a5`
j .L4 # 跳转到标签 .L4
.L3:
lw a5, -20(s0) # 将 `s0` 偏移 -20 字节处的值加载到 `a5`
addi a5, a5, -1 # 将 `a5` 减 1
mv a0, a5 # 将 `a5` 的值移动到 `a0`
call f # 递归调用函数 `f`
mv s1, a0 # 将返回值保存到 `s1`
lw a5, -20(s0) # 将 `s0` 偏移 -20 字节处的值加载到 `a5`
addi a5, a5, -2 # 将 `a5` 减 2
mv a0, a5 # 将 `a5` 的值移动到 `a0`
call f # 递归调用函数 `f`
mv a5, a0 # 将返回值保存到 `a5`
add a5, s1, a5 # 将 `s1` 和 `a5` 的值相加
.L4:
mv a0, a5 # 将 `a5` 的值移动到 `a0`
lw ra, 28(sp) # 从栈偏移 28 字节处恢复返回地址到 `ra`
lw s0, 24(sp) # 从栈偏移 24 字节处恢复 `s0` 的值
lw s1, 20(sp) # 从栈偏移 20 字节处恢复 `s1` 的值
addi sp, sp, 32 # 恢复栈指针，释放 32 字节的栈帧
jr ra # 跳转到返回地址寄存器 `ra` 的地址（即返回调用者）
先看.L2上面那段 ：
在原来的基础上，递归函数又引入了一个寄存器s1用来保存递归的中间结果。
然后将函数参数a0和1比较，若相等则跳转到.L2
和2比较，若不相等，则跳转到.L3
否则就等于2，直接进入.L2
.L2
将a5置1，跳转到.L4
.L3
将-20(s0) (也就是原本函数的参数a0)放入寄存器a5
然后将a5-1的值作为参数(传给用来保存参数的寄存器a0)，之后调用f函数
将再次调用后的返回值a0保存到存中间结果的寄存器s1
如法炮制计算f(x-2),将s1和第二次返回的值相加，就是最终结果
.L4
将a5存储的最终结果交给返回值寄存器a0，最后恢复现场。
