ARM64架构栈帧回溯

文章目录

前言
一、栈帧简介
二、demo演示

前言

一、栈帧简介

假设下列函数调用：

c 复制代码

funb()
{
	func()
}

funa()
{
	funb()
}

main()
{
	funa()
}

main函数，funa函数，funb函数都不是叶子函数，其栈布局如下所示：

LR 和FP寄存器保存在每个函数栈帧的栈顶：

FP = SP + 0

LR = SP + 8

根据这两个寄存器就可以反推出所有函数的调用栈。

FP栈帧指针（X29）指向保存在栈上的上一个栈帧的帧指针。在它之后存储了保存的LR（X30）。链中的最后一个帧指针应设置为0。

知道FP寄存器就能得到每个函数的栈帧基地址。而知道每个函数的栈帧基地址的条件下，可通过当前函数栈帧保存的LR获得当前函数的Entry地址和函数名。

通过FP还可以知道上一级的FP（栈帧基地址）。

在ARM64体系结构中，函数调用栈以单链表形式组织，其中每个栈帧都包含两个地址，用于构建这个链表。这种链表通常被称为调用链或链式栈。

在链式栈中，每个栈帧都有两个64位宽的地址：

（1）低地址（栈顶）存放了指向上一个栈帧的基地址，通常使用FP（Frame Pointer）寄存器来保存。类似于链表中的prev指针，它指向上一个栈帧的基地址，以便在函数返回时回到调用者的上下文。

（2）高地址存放了LR（Link Register）寄存器的值，它保存了当前函数的返回地址。LR寄存器中的值指向了调用当前函数的下一条指令的地址。当函数执行完毕时，该地址将被用于恢复程序控制流，并返回到调用者的位置。

通过这种方式，每个栈帧都可以通过链表中的prev指针链接在一起，形成一个完整的函数调用链。当函数返回时，可以使用prev指针获取上一个栈帧的基地址，并利用LR寄存器中的返回地址将控制流传递给调用者。

ARM64栈回溯：

在AAPC64中，栈指针（SP）指向当前栈帧的顶部，其中包含了上一级函数的LR和FP寄存器现场。通过查看SP所指向的地址，可以找到保存的上一级函数的LR和FP寄存器值。

对于LR寄存器，根据(LR-4)可以找到上一级函数所在的地址，减去4是因为ARM64指令集中的跳转指令（例如BL）会将要跳转到的地址加上4。因此，在栈上保存的LR值实际上是要跳转到的下一条指令的地址，而不是当前指令的地址。所以，为了找到上一级函数所在的地址，需要减去4。

上一级函数的FP寄存器实际上等于上一级函数使用的栈顶地址。通过保存上一级FP寄存器现场的位置，可以在栈上找到上一级函数的栈帧。同样，该栈帧中也会保存更上一级函数的LR和FP寄存器现场，以此类推，形成函数调用链。

通过链式保存的方式，可以回溯整个函数的调用流程，从当前函数一直追溯到最外层的调用者。这种方式使得在函数返回时可以按照相反的顺序恢复各个函数的现场，并正确返回到调用者的位置。

二、demo演示

C语言示例：

c 复制代码

int fund(int g, int h)
{
    return g + h;
}

int func(int e, int f)
{
   int ret = e + f;
   ret = fund(e, ret);
   return ret;
}

int funb(int c, int d)
{
    int ret = c + d;
    ret = func(c, ret);
    return ret;

}

int funa(int a, int b)
{
    int ret = a + b ;
    ret = funb(a, ret);
    return ret;
}

int main(void)
{
    int i = 1, j = 2;
    int ret = funa(i,j);

    return 0;
}

c 复制代码

(gdb) b main
(gdb) b funa
(gdb) b funb
(gdb) b func
(gdb) r

(1)

main：

c 复制代码

(gdb) disassemble
Dump of assembler code for function main:
	......
   0x0000005555555810 <+32>:    bl      0x55555557b4 <funa>
   0x0000005555555814 <+36>:    str     w0, [sp, #28]
   ......

c 复制代码

x29            0x7ffffff400
x30            0x7ff7e5c110

（2）

funa：

c 复制代码

(gdb) c
(gdb) disassemble
Dump of assembler code for function funa:
	......
   0x00000055555557dc <+40>:    bl      0x5555555778 <funb>
   0x00000055555557e0 <+44>:    str     w0, [sp, #44]
   ......

c 复制代码

(gdb) info registers
x29            0x7ffffff3d0
x30            0x5555555814

可以看到x30寄存器的值就是main函数 bl funa 下一条指令的地址。

根据x29寄存器得到funa栈帧基地址：

c 复制代码

0x7ffffff3d0

读取该地址的值(x29寄存器FP存放了指向上一个栈帧的基地址)：

c 复制代码

(gdb) x/1xg 0x7ffffff3d0
0x7ffffff3d0:   0x0000007ffffff400

那么可以得到main函数的栈帧基地址：0x0000007ffffff400

这个值就等于执行main函数时，x29寄存器的值。

将main函数的栈帧基地址+8然后读取获取main的返回地址：

这里 + 8 的原因：LR = FP + 8

c 复制代码

0x0000007ffffff400 + 8 = 0x0000007ffffff408

c 复制代码

(gdb) x/1xg 0x0000007ffffff408
0x7ffffff408:   0x0000007ff7e5c110

main的返回地址：0x0000007ff7e5c110

将main的返回地址 - 4 就可以获取 BL main这条函数跳转指令的地址：

这里 - 4 的原因：执行BL指令时，将下一条指令的地址（即返回地址）写入X30寄存器中，这里我们已经获取到了返回地址，那么 -4 就获取到了 BL 指令的地址。

c 复制代码

0x0000007ff7e5c110 - 4 = 0x0000007ff7e5c10c

那么其上一条调用main的指令地址就是0x0000007ff7e5c10c：

c 复制代码

(gdb) x/i 0x0000007ff7e5c10c
   0x7ff7e5c10c <__libc_start_main+228>:        blr     x3
(gdb) x/2i 0x0000007ff7e5c10c
   0x7ff7e5c10c <__libc_start_main+228>:        blr     x3
   0x7ff7e5c110 <__libc_start_main+232>:        bl      0x7ff7e71a40 <exit>

可以看到是__libc_start_main函数调用 main 函数。

（3）

funb：

c 复制代码

(gdb) disassemble
Dump of assembler code for function funb:
	......
   0x00000055555557a0 <+40>:    bl      0x555555573c <func>
   0x00000055555557a4 <+44>:    str     w0, [sp, #44]
	......

c 复制代码

(gdb) info registers
x29            0x7ffffff3a0
x30            0x55555557e0

可以看到x30寄存器的值就是 funa bl funb下一条指令的地址。

根据x29寄存器得到funb栈帧基地址：

c 复制代码

0x7ffffff3a0

读取该地址的值(x29寄存器FP存放了指向上一个栈帧funa的基地址)：

c 复制代码

(gdb) x/1xg 0x7ffffff3a0
0x7ffffff3a0:   0x0000007ffffff3d0

这个值就等于执行funa函数时，x29寄存器的值。

将funa函数的栈帧基地址+8然后读取获取funa的返回地址：

c 复制代码

0x0000007ffffff3d0 + 8 = 0x0000007ffffff3d8

c 复制代码

(gdb) x/1xg 0x0000007ffffff3d8
0x7ffffff3d8:   0x0000005555555814

funa的返回地址：0x0000005555555814

将funa的返回地址 - 4 就可以获取 main BL funa这条函数跳转指令的地址：

c 复制代码

0x0000005555555814- 4 = 0x0000005555555810

那么其上一条调用funa的指令地址就是0x0000005555555810：

c 复制代码

(gdb) x/i 0x0000005555555810
   0x5555555810 <main+32>:      bl      0x55555557b4 <funa>
(gdb) x/2i 0x0000005555555810
   0x5555555810 <main+32>:      bl      0x55555557b4 <funa>
   0x5555555814 <main+36>:      str     w0, [sp, #28]

可以看到是main函数调用 funa 函数。

（4）

func：

c 复制代码

(gdb) disassemble
Dump of assembler code for function func:
	......
   0x0000005555555764 <+40>:    bl      0x555555571c <fund>
   0x0000005555555768 <+44>:    str     w0, [sp, #44]
	......

c 复制代码

(gdb) info registers
x29            0x7ffffff370
x30            0x55555557a4

可以看到x30寄存器的值就是 funb bl func下一条指令的地址。

根据x29寄存器得到func栈帧基地址：

c 复制代码

0x7ffffff370

读取该地址的值(x29寄存器FP存放了指向上一个栈帧funb的基地址)：

c 复制代码

(gdb) x/1xg 0x7ffffff370
0x7ffffff370:   0x0000007ffffff3a0

这个值就等于执行funb函数时，x29寄存器的值。

将funb函数的栈帧基地址+8然后读取获取funb的返回地址：

c 复制代码

0x0000007ffffff3a0 + 8 = 0x0000007ffffff3a8

c 复制代码

(gdb) x/1xg 0x0000007ffffff3a8
0x7ffffff3a8:   0x00000055555557e0

funb的返回地址：0x00000055555557e0

将funb的返回地址 - 4 就可以获取 funaBL funb这条函数跳转指令的地址：

c 复制代码

0x00000055555557e0 - 4 = 0x00000055555557dc

那么其上一条调用funb的指令地址就是0x00000055555557dc：

c 复制代码

(gdb) x/i 0x00000055555557dc
   0x55555557dc <funa+40>:      bl      0x5555555778 <funb>
(gdb) x/2i 0x00000055555557dc
   0x55555557dc <funa+40>:      bl      0x5555555778 <funb>
   0x55555557e0 <funa+44>:      str     w0, [sp, #44]

可以看到是funa函数调用 funb 函数。