从汇编看函数

发表 编辑 分类
字数: 3.2k 阅读:

一、简介

CPU
中央处理器，内部主要包括寄存器、运算器、控制器。

  • 寄存器：存储数据
  • 运算器：处理数据
  • 控制器：控制硬件IO口的高低电平。

常用寄存器

  • pc：程序计数器，确定指令位置
  • sp：在任意时刻都会保存栈顶的地址，调用函数就会开辟栈空间（通过操作sp寄存器来开辟栈空间）
  • fp：也称为x29寄存器属于通用寄存器，在某些时刻利用它来保存栈底的地址

x30寄存器

  • x30寄存器存放当前调用函数的返回地址
  • 当ret指令执行时，会找到x30寄存器保存的地址值，继续向下执行

常用指令

  • str：读取寄存器值，存入内存中
  • ldr：读内存中的值，存入到寄存器
  • stp：入栈指令 stp x0, x1, [sp] 存入两个值
  • ldp：出栈指令 ldp x0, x1, [sp] 取出两个值
  • bl：将下一条指令的地址放入lr(x30)寄存器，跳转到标号处执行指令
  • ret：默认使用lr(x30)寄存器的值，通过底层指令提示CPU此处作为下条指令的地址
  • orr：orr{条件}{S}  目的寄存器，操作数1，操作数2，把结果放置到目的寄存器

函数参数和返回值
ARM64下，函数存放在x0~x7（w0~w7）这8个寄存器中，超过8个参数，就会入栈。函数返回值是放在x0寄存器中的。通用寄存器32个。

二、汇编函数嵌套

1、demo1-汇编函数嵌套

1
2
3
4
5
6
7
8
9
10
.text
.global _A, B
_A:
    mov x0, #0xaaaa
    bl _B
    mov x0,#0xaaaa
    ret
_B:
    mov x0, #0xbbbb
    ret

执行顺序：

1
2
3
4
5
demo`A:
    0x102c0a0c4 <+0>:  mov    x0, #0xaaaa
    0x102c0a0c8 <+4>:  bl     0x102c0a0d4               ; B ①
    0x102c0a0cc <+8>:  mov    x0, #0xaaaa   ②
->  0x102c0a0d0 <+12>: ret

继续执行，①和②会来回执行，①->②->①->…。
原因：在A函数中调用了B函数，这里x30的值将被置为B函数的结束地址，继续执行到ret，ret会读取了x30的地址（B函数的结束地址）①处，继续往下执行到②，因此就①->②->①->…。

下面看系统是如何处理嵌套函数的调用的：

2、demo2-c函数嵌套

1
2
3
4
5
6
7
8
9
10
11
int A(void);
void b() {
    return;
}
void c() {
    b();
}
int main(int argc, char * argv[]) {
    c();
//    A();
}

断点单步执行打印如下：

1
2
3
4
5
6
demo`c:
    0x102f9a318 <+0>:  stp    x29, x30, [sp, #-0x10]!
    0x102f9a31c <+4>:  mov    x29, sp
    0x102f9a320 <+8>:  bl     0x102f9a314               ; b at main.m:14:5
    0x102f9a324 <+12>: ldp    x29, x30, [sp], #0x10
->  0x102f9a328 <+16>: ret
  • stp：写入，向x29、x30写入到栈空间
  • stp x29, x30, [sp, #-0x10]!：等价于sp = sp-0x10（16字节）并赋值所在地址，拉伸栈空间，拉伸栈空间的大小为16字节的倍数
  • 执行c函数
  • ldp x29, x30, [sp], #0x10：将用sp所在地址值给x29、x30赋值，sp+0x10释放空间，保持栈平衡

在每一步打印x30的值：

从上面的运行结果可以看出，x30寄存器在调起内嵌函数前，存储x30地址到 [sp, #-0x10]的地址中，内嵌函数调用完成后，重新设置当前x30 = sp（sp存储了当前函数的地址），执行到ret，ret读取到的地址即当前函数的结束地址，继续执行则跳出该函数。

3、demo3-完善demo1
在函数内调用函数，保存当前函数A结束地址x30到sp-0x10（16个字节）位置，函数B结束后重新设置x30的值为sp（函数A的结束地址），这样就完成嵌套函数调用。

1
2
3
4
5
6
7
8
9
10
11
12
.text
.global _A, B
_A:
    mov x0, #0xaaaa
    str x30,[sp, #-0x10]!
    bl _B
    mov x0,#0xaaaa
    ldr x30, [sp], #0x10
    ret
_B:
    mov x0, #0xbbbb
    ret

如下：

三、函数

上面了解了汇编函数嵌套的处理方法，下面看一下在汇编层对参数是怎么处理的。

1
2
3
4
5
6
7
int sum(int a, int b) {
    return a+b;
}

int main(int argc, char * argv[]) {
    Int res = sum(5,7);
}

断点查看主函数汇编代码：

  • sub sp, sp, #0x30：sp-0x30申请48个字节的栈空间（sp指向可用栈空间的栈顶），sub减指令
  • x29、x30保存栈底栈顶，做为嵌套函数的中间变量
  • 上面可以看到变量值#0x5、#0x7，存入到w0、w1寄存器中

进入sum函数内查看，汇编指令：

  • 在sum函数内拉伸栈空间
  • str指令将w0、w1寄存器中的值入栈，再取出，有说法是为防止寄存器被使用，存储值发生变化，使用前读取栈区的值就不会出现被串改的问题，优化后的指令是直接走add sp, sp, #0x10的。但是既然在连续执行的指令中都有被串改的可能，那么在取值后，add前也是有可能被串改的，所以感觉以上说法并不能解释这一多余操作，除非后面指令中，有使用该参数值，存储到栈是有必要的
  • sp, sp, #0x10：数据处理完成回收栈空间
  • ret：有参数函数返回值是x0寄存器的值不是x30寄存器的值，w0是x0寄存器的低32位，因此x0=w0，ret=w0=0x12=12

编译器优化：


优化后的汇编指令：

  • 优化掉了参数的存储，取值，直接将寄存器值相加
  • 没有拉伸栈空间

掉了两根头发！！！

多参数demo

1
2
3
4
5
6
7
int sum(int a,int b,int c,int d,int e,int f,int g,int h,int i,int j,int k,int l) {
    return a+b+b+c+d+e+f+g+h+i+j+k+l;
}

int main(int argc, char * argv[]) {
    int res = sum(5,7);
}

main函数汇编指令如下：

初始化寄存器的值，这里使用w0~w8、x9，这里w0=x0，w9=x9，不用纠结为什么没有都使用w或x，w是x的低32位，同属于一个寄存器，在系统级别怎么用都行。过！

进入函数内部：

拉伸栈空间，存寄存器值，取值，相加，指令太多，每一条指令耗时1/主频，复合指令耗时2/主频，这么多指令，太烧了。

局部变量

demo1-函数多参数

1
2
3
4
5
6
7
8
9
10
int funcC() {
    int a = 1;
    int b = 2;
    int c = 3;
    return a+b+c;
}

int main(int argc, char * argv[]) {
    int res = funcC();
}

函数汇编指令如下：

  • 开辟栈空间0x10
  • 将值存入到w8寄存器中（任意w）
  • 将寄存器值入栈，出栈，计算

再看一段代码：

1
2
3
4
5
6
7
int funcC() {
    return 1+2+3;
}

int main(int argc, char * argv[]) {
    int res = funcC();
}

汇编指令：

这里就执行了一条指令，其实内部有做add相关指令，这里做了优化，但相比上面声明的局部变量，这里没有开辟栈空间，省去了很多指令，每一条指令耗时1/主频，复合指令耗时2/主频，每条指令都要放电一次，耗电，局部变量悠着点用，当然真正开发中编译器是会优化掉这些多余代码。

……
……