v23.04 鸿蒙内核源码分析(汇编传参) | 如何传递复杂的参数 原创

#include <stdio.h>
#include <math.h>
struct reg{//参数远超寄存器数量
    int Rn[100]; 
    int pc;
};

int framePoint(reg cpu)
{
    return cpu.Rn[0] * cpu.pc;
}

int main()
{
    reg cpu;
    cpu.Rn[0] = 1;
    cpu.pc = 2;
    return framePoint(cpu);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

//编译器: armv7-a gcc (9.2.1)
framePoint(reg):
        sub     sp， sp， #16     @申请栈空间
        str     fp， [sp， #-4]!  @保护main函数栈帧，等同于push {fp}
        add     fp， sp， #0      @fp变成framePoint栈帧，同时也指向了栈顶
        add     ip， fp， #4      @定位到入栈口，让4个参数依次入栈 
        stm     ip， {r0， r1， r2， r3}@r0-r3入栈保存
        ldr     r3， [fp， #4]    @取值cpu.pc = 2    
        ldr     r2， [fp， #404]  @取值cpu.Rn[0] = 1
        mul     r3， r2， r3      @cpu.Rn[0] * cpu.pc
        mov     r0， r3          @返回值由r0保存
        add     sp， fp， #0      @重置sp，和add     fp， sp， #0配套出现
        ldr     fp， [sp]， #4    @恢复main函数栈帧
        add     sp， sp， #16     @归还栈空间，sp回落到main函数栈顶位置
        bx      lr              @跳回main函数
main:
        push    {fp， lr}        @入栈保存调用函数现场                     
        add     fp， sp， #4      @fp指向sp+4，即main栈帧的底部
        sub     sp， sp， #800    @分配800个线性地址，即main栈帧的顶部
        mov     r3， #1          @r3 = 1
        str     r3， [fp， #-408] @将1放置 fp-408处，即:cpu.Rn[0]处
        mov     r3， #2          @r3 = 2
        str     r3， [fp， #-8]   @将2放置 fp-8处，即:cpu.pc
        mov     r0， sp          @r0 = sp
        sub     r3， fp， #392    @r3 = fp - 392
        mov     r2， #388        @只拷贝388，剩下4个由寄存器传参
        mov     r1， r3          @保存由r1保存r3，用于memcpy
        bl      memcpy          @拷贝结构体部分内容，将r1的内容拷贝r2的数量到r0
        sub     r3， fp， #408    @定位到结构体剩余未拷贝处
        ldm     r3， {r0， r1， r2， r3} @将剩余结构体内容通过寄存器传参
        bl      framePoint(reg)         @执行framePoint
        mov     r3， r0          @返回值给r3
        nop @用于程序指令的对齐
        mov     r0， r3          @再将返回值给r0
        sub     sp， fp， #4      @恢复SP值
        pop     {fp， lr}        @出栈恢复调用函数现场
        bx      lr              @跳回调用函数
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.

int main()
{
    reg cpu;
    cpu.Rn[0] = 1;
    cpu.pc = 2;
    return framePoint(cpu);
}
1.
2.
3.
4.
5.
6.
7.

        mov     r0， sp          @r0 = sp
        sub     r3， fp， #392    @r3 = fp - 392
        mov     r2， #388        @只拷贝388，剩下4个由寄存器传参
        mov     r1， r3          @保存由r1保存r3，用于memcpy
        bl      memcpy          @拷贝结构体部分内容，将r1的内容拷贝r2的数量到r0
        sub     r3， fp， #408    @定位到结构体剩余未拷贝处
        ldm     r3， {r0， r1， r2， r3} @将剩余结构体内容通过寄存器传参
1.
2.
3.
4.
5.
6.
7.

r3 = fp-408， r2 = fp-404 ，r1 = fp-400 ，r0 = fp-396 得到虚拟地址的值，这些值整好是memcpy没有拷贝到变量剩余的值
1.

framePoint(reg):
        sub     sp， sp， #16     @申请栈空间
        str     fp， [sp， #-4]!  @保护main函数栈帧，等同于push {fp}
        add     fp， sp， #0      @fp变成framePoint栈帧，同时也指向了栈顶
        add     ip， fp， #4      @定位到入栈口，让4个参数依次入栈 
        stm     ip， {r0， r1， r2， r3}@r0-r3入栈保存
        ldr     r3， [fp， #4]    @取值cpu.pc = 2    
        ldr     r2， [fp， #404]  @取值cpu.Rn[0] = 1
        mul     r3， r2， r3      @cpu.Rn[0] * cpu.pc
        mov     r0， r3          @返回值由r0保存
        add     sp， fp， #0      @重置sp，和add     fp， sp， #0配套出现
        ldr     fp， [sp]， #4    @恢复main函数栈帧
        add     sp， sp， #16     @归还栈空间，sp回落到main函数栈顶位置
        bx      lr              @跳回main函数
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

framePoint申请了4个栈空间目的是用来存放四个寄存器值的，以上汇编代码逐句分析.

第一句: sub     sp， sp， #16     @申请栈空间，用来存放r0-r3四个参数

第二句: str     fp， [sp， #-4]!  @保护main的fp，等同于push {fp}，为什么这里要把main函数的fp放到 [sp， #-4]! 位置，注意 !号，表示SP的位置要变动，因为这里必须要保证参数的连续性.

第三句: add     fp， sp， #0      @指定framePoint的栈帧位置，同时指向了栈顶 SP

第四句: add     ip， fp， #4      @很关键，用了ip寄存器，因为此时 fp sp 都已经确定了，但别忘了 r0 - r3 还没有入栈呢.从哪个位置入栈呢， fp+4位置，因为 main函数的栈帧已经入栈了，在已经fp的位置.中间隔了四个空位，就是给 r0-r3留的.

第五句: stm     ip， {r0， r1， r2， r3}@r0-r3入栈，填满了剩下的四个空位.

第六句: ldr     r3， [fp， #4]    @取的就是cpu.pc = 2的值，因为上一句就是从这里依次入栈的，最后一个当然就是cpu.pc了.

第七句: ldr     r2， [fp， #404]  @取值cpu.Rn[0] = 1，其实这一句已经是跳到了main函数的栈帧取值了，所以看明白了没有，并不是在传统意义上理解的在framePoint的栈帧中取值.

第八句: mul     r3， r2， r3      @cpu.Rn[0] * cpu.pc 做乘法运算

第九句: mov     r0， r3          @返回值r0保存运算结构， 目的是return

第十句: add sp， fp， #0          @重置sp，其实这一句可以优化掉，因为此时sp = fp

第十一句: ldr     fp， [sp]， #4  @恢复fp，等同于pop {fp}，因为函数运行完了，需要回到main函数了，所以要拿到main的栈帧

第十二句: add     sp， sp， #16   @归还栈空间，等于把四个入参抹掉了.

最后一句: bx      lr            @跳回main函数，如此 fp 和 lr 寄存器中保存的都是 main函数的信息，就可以安全着陆了.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.