这篇主要是围绕 SP FP PC LR 寄存器进行介绍,不理解的可以一起讨论下,我也是今天才开始学习这些

汇编基础知识

  • 处理器寄存器被指定为R0、R1等。
  • MOVE指令的源位于左侧,目标位于右侧。
  • 伪处理程序中的堆栈从高地址增长到低地址。因此,push会导致堆栈指针的递减。pop会导致堆栈指针的增量。
  • 寄存器 sp(stack pointer) 用于指向堆栈。
  • 寄存器 fp(frame pointer) 用作帧指针。帧指针充当被调用函数和调用函数之间的锚。
  • 当调用一个函数时,该函数首先将 fp 的当前值保存在堆栈上。然后,它将 sp 寄存器的值保存在 fp 寄存器中。然后递减 sp 寄存器来为本地变量分配空间。
  • fp 寄存器用于访问本地变量和参数,局部变量位于帧指针的负偏移量处,传递给函数的参数位于帧指针的正偏移量。
  • 当函数返回时, fp 寄存器被复制到 sp 寄存器中,这将释放用于局部变量的堆栈,函数调用者的 fp 寄存器的值由pop从堆栈中恢复。

汇编指令介绍

首先先介绍涉及到的主要的汇编指令 PUSH 和 POP

语法

1
2
PUSH{cond} reglist
POP{cond} reglist

cond

是一个可选的条件代码(请参阅条件执行)。

reglist

是一个非空的寄存器列表,括在大括号内。可以包含寄存器范围。 如果包含多个寄存器或寄存器范围,则必须用逗号分隔。

使用示例

1
2
3
PUSH    {r0,r4-r7}
PUSH {r2,lr}
POP {r0,r10,pc} ; no 16-bit version available

简单的说,就是 PUSH 可以将选择的寄存器的值压栈,可以将 LR 寄存器的值一起压栈;而 POP 可以将选择寄存器的值从栈中弹出,可以选择弹出到 PC 寄存器,一般用于子函数回调

其他背景知识介绍

目标机是 ARM 架构处理器,内部为向下增长堆栈

向下增长意思堆栈是向低地址方向生长,称为递减堆栈

使用的是 arm-none-linux-gnueabi- 系列的交叉编译器

使用 gcc 编译,使用 objdump 反汇编

1
2
arm-none-linux-gnueabi-gcc -c c_call_fun.c 
arm-none-linux-gnueabi-objdump -d c_call_fun.o > c_call_fun_s

回到正题

之所以介绍这部分相关的知识是为了方便理解汇编中子函数调用子函数的过程

下面将从一个简单的示例进行介绍

被调用函数框架一

1
2
3
4
5
<fun_2>:
push {fp}
; code of the function
pop {fp}
bx lr

我们先把被调用函数的功能模块去除了,直接看它的主体框架

首先是对 fp(frame pointer) 压栈

压栈是为了保护该寄存器中的内容,弹出是为了恢复该寄存器中的值,为什么需要这么做在下面进行解释

最后的 bx lr 的作用等同于 mov pc,lr

因为在调用者中使用了 bl 调用子函数的时候,会将当前 PC 的值保存在 LR 中,这时将 LR 中的值载入到 PC 中,可以使得程序运行位置返回调用者中

这样就完成了子函数的调用

被调用函数框架二

1
2
3
4
5
6
7
8
<fun_2>:
push {fp}
add fp, sp, #0
sub sp, sp, #12
; code of the function
add sp, fp, #0
pop {fp}
bx lr

这部分代码做的事情如上图

在上文的基础上,通过减小 sp 的地址,为局部数据的存放开启了12字节的空间,也就是 fp 和 sp 中间的空间

前面介绍了 fp 的作用是连接调用函数地方和被调用函数地方

在刚调用子函数的时候,fp 还指向的是上一个函数的堆栈空间,为了方便程序返回调用者时能够正常运行,需要保存旧的 fp 中的值,再指向新的地址,来分配空间

最后子程序运行完毕后,将 fp 中的值传递给 sp ,相当于让 sp 中的值恢复到了进入子程序前的情况,这个操作叫做释放内存

被调用函数框架三

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int local_num = 1;

int fun_2(int num)
{
return num+local_num;
}
-----------------
<fun_2>:
push {fp} ; (str fp, [sp, #-4]!)
add fp, sp, #0
sub sp, sp, #12
str r0, [fp, #-8]
ldr r3, [pc, #24] ; 30 <fun_2+0x30>
ldr r2, [r3]
ldr r3, [fp, #-8]
add r3, r2, r3
mov r0, r3
add sp, fp, #0
pop {fp}
bx lr

这部分的功能示意图如上

这段代码访问了调用者的局部数据和被调用者的局部数据,从这段代码可以看出,被调用者的局部数据在 fp 的负偏移的地址,调用者的局部数据在 fp 的正偏移地址

调用者

上一篇我们提到了多层子函数调用的问题

就是 LR 寄存器只有一个,当使用 bl 调用子函数的时候,会将当前的 PC 存入 LR 中,这样子函数运行完会回到调用函数的地址继续运行程序

但是在子函数中再次调用子函数的时候,就不能直接使用 bl 调用子函数了,因为那样会把之前的 LR 寄存器中的值覆盖,导致程序无法正常运行

1
2
3
push	{fp, lr}
; code of the function
pop {fp, pc}

上面的代码是 main 函数的部分反汇编代码

我们都知道 main 函数也类似于一个子函数,在子函数中调用另一个子函数,需要存储当前的 LR 中的值。所以在 main 中将 LR 寄存器压栈,在 main 运行完后,将 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
38
39
40
41
42
43
44
45
int local_num = 1;

int fun_2(int num)
{
return num+local_num;
}

int main()
{
int num = 1;

num = fun_2(num);
}
-------------------------
c_call_fun.o: file format elf32-littlearm

Disassembly of section .text:

00000000 <fun_2>:
0: e52db004 push {fp} ; (str fp, [sp, #-4]!)
4: e28db000 add fp, sp, #0
8: e24dd00c sub sp, sp, #12
c: e50b0008 str r0, [fp, #-8]
10: e59f3018 ldr r3, [pc, #24] ; 30 <fun_2+0x30>
14: e5932000 ldr r2, [r3]
18: e51b3008 ldr r3, [fp, #-8]
1c: e0823003 add r3, r2, r3
20: e1a00003 mov r0, r3
24: e28bd000 add sp, fp, #0
28: e8bd0800 pop {fp}
2c: e12fff1e bx lr
30: 00000000 .word 0x00000000

00000034 <main>:
34: e92d4800 push {fp, lr}
38: e28db004 add fp, sp, #4
3c: e24dd008 sub sp, sp, #8
40: e3a03001 mov r3, #1
44: e50b3008 str r3, [fp, #-8]
48: e51b0008 ldr r0, [fp, #-8]
4c: ebfffffe bl 0 <fun_2>
50: e1a03000 mov r3, r0
54: e50b3008 str r3, [fp, #-8]
58: e24bd004 sub sp, fp, #4
5c: e8bd8800 pop {fp, pc}

参考资料