首页
论坛
专栏
课程

[原创]x86_64架构下的函数调用及栈帧原理

2020-1-15 15:03 1553

[原创]x86_64架构下的函数调用及栈帧原理

2020-1-15 15:03
1553

x86_64架构下的函数调用及栈帧原理

1. x86_64寄存器

在分析函数调用时,必须要对CPU的寄存器熟悉。在所有的体系架构中,每个寄存器都有建议的使用方法,编译器在对代码进行编译时,也通常按照体系架构建议的寄存器的使用方法进行编译。在x86_64体系架构中,总共有1664位通用寄存器,各寄存器及用途如下所示:

 

 

对上图中的寄存器做简单说明:

  • %rax :通常存储函数调用的返回结果,也被用在idiv (除法)和imul(乘法)命令中。

  • %rsp :堆栈指针寄存器,指向栈顶位置。pop操作通过增大rsp的值实现出栈,push操作通过减小rsp的值实现入栈。

  • %rbp :栈帧指针,标识当前栈帧的起始位置。

  • %rdi, %rsi, %rdx, %rcx,%r8, %r9 :六个寄存器,当参数少于7个时, 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9;当参数为7个以上时,前 6 个与前面一样, 但后面的依次从 “右向左” 放入栈中,即和32位汇编一样。

    ; 参数>=7时
    Func(a, b, c, d, e, f, g, h);
    ;参数的具体存放方式
    a->%rdi, b->%rsi, c->%rdx, d->%rcx, e->%r8, f->%r9
    h->8(%esp)
    g->(%esp)
    call Func
    

    备注:用栈在进行参数传递时,即便参数<8字节,也要对齐放在8字节的空间中

  • 函数执行前后必须保持原始的寄存器有3个:是rbx、rbp、rsp。rx寄存器中,最后4个必须保持原值:r12、r13、r14、r15。保持原值的意义是为了让当前函数有可信任的寄存器,减小在函数调用过程中的保存&恢复操作。除了rbp、rsp用于特定用途外,其余5个寄存器可随意使用。

  • Caller SaveCallee Save寄存器 : 寄存器的值是由”调用者保存“ 还是由 ”被调用者保存“。当进行函数调用时,子函数通常也会使用通用寄存器,但这些寄存器中可能保存着父函数(调用者)的值。如果是Caller Save 寄存器,在进行子函数调用之前,需要由调用者提前保存寄存器中的值(入栈),然后在子函数中可以向这些寄存器中写入任何数据;在完成调用后,恢复寄存器原来的值(出栈)。如果是Callee Save寄存器,父函数在进行子函数调用前不会保存寄存器中的值,在调用子函数后,子函数会首先保存寄存器中的值(入栈);子函数完成功能后,恢复寄存器中的值,然后再返回到父函数,结束调用。

2. 函数调用时的栈帧

1. 函数调用

在对子函数进行调用时,栈帧情况如下:

 

 

(注意此处栈帧增长方向从上到下)

  • 调用者栈帧中,保存了被调用函数的参数以及调用者的返回地址,其流程大致如下:

    父函数将调用参数从右到左依次压栈->返回地址入栈->跳转到子函数起始地址->子函数将父函数栈帧起始地址(%rbp)压栈->将%rbp 的值设置为当前 %rsp 的值,开辟栈帧空间

  • 函数调用时的汇编指令如下:

    ...   ;参数压栈
    call Func  ;将返回地址压栈,并跳转到子函数处执行
    ...  ;函数调用的返回位置
    
    Func:  ;子函数入口
    pushq %rbp  ;保存父函数的帧指针,创建新栈帧
    movq  %rsp, %rbp  ;让 %rbp 指向新栈帧的起始位置
    subq  $N, %rsp  ;开辟栈帧空间供子程序使用
    

以上过程由编译器自动完成。需要注意的是,父函数中进行参数压栈时,顺序为从右到左,但并不是固定,要看编译器的具体实现(gcc使用的是从右到左)。

2. 函数返回

函数返回时,我们需要的数据是函数的返回值(%rax),然后将栈结构恢复到函数调用之前的状态,最后跳转到父函数的返回地址继续执行。需要执行以下两条指令:

movq %rbp, %rsp    ; 使 %rsp 和 %rbp 指向同一位置,即子栈帧的起始处, 收回子栈帧空间
popq %rbp ; 将栈中保存的父栈帧的 %rbp 的值赋值给 %rbp,并且 %rsp 上移一个位置指向父栈帧的结尾处

为了便于栈帧恢复,x86_64 架构中提供了 leave 指令来实现上述两条命令的功能。执行 leave 后,前面图中函数调用的栈帧结构如下:

 

 

调用 leave 后,%rsp 指向返回地址;ret 指令,从栈顶弹出数据,并跳转到此数据指向的地址处。在leave 执行后,%rsp 指向返回地址,因而 ret 的作用就是把 %rsp 上移一个位置,并跳转到返回地址执行。

 

所以,leave 指令用于恢复父函数的栈帧,ret 用于跳转到返回地址处,leave 和ret 配合共同完成了子函数的返回。当执行完成 ret 后,%rsp 指向的是父栈帧的结尾处,父栈帧尾部存储的调用参数由编译器自动释放。

函数调用示例

程序源代码如下:

int add(int a, int b, int c, int d, int e, int f, int g, int h) { // 8 个参数
  int sum = a + b + c + d + e + f + g + h;  //相加求和
  return sum;
}

int main(void) {
  int i = 10;
  int j = 20;
  int k = i + j;
  int sum = add(11, 22,33, 44, 55, 66, 77, 88);
  int m = k; // 为了观察 %rax Caller Save 寄存器的恢复

  return 0;
}

上面程序生成的和子函数调用相关的汇编程序如下:

add:
.LFB2:
    pushq    %rbp
.LCFI0:
    movq    %rsp, %rbp
.LCFI1:
    movl    %edi, -20(%rbp)
    movl    %esi, -24(%rbp)
    movl    %edx, -28(%rbp)
    movl    %ecx, -32(%rbp)
    movl    %r8d, -36(%rbp)
    movl    %r9d, -40(%rbp)
    movl    -24(%rbp), %eax
    addl    -20(%rbp), %eax
    addl    -28(%rbp), %eax
    addl    -32(%rbp), %eax
    addl    -36(%rbp), %eax
    addl    -40(%rbp), %eax
    addl    16(%rbp), %eax
    addl    24(%rbp), %eax
    movl    %eax, -4(%rbp)
    movl    -4(%rbp), %eax
    leave
    ret

main:
.LFB3:
    pushq    %rbp
.LCFI2:
    movq    %rsp, %rbp
.LCFI3:
    subq    $48, %rsp
.LCFI4:
    movl    $10, -20(%rbp)
    movl    $20, -16(%rbp)
    movl    -16(%rbp), %eax
    addl    -20(%rbp), %eax
    movl    %eax, -12(%rbp)
    movl    $88, 8(%rsp)
    movl    $77, (%rsp)
    movl    $66, %r9d
    movl    $55, %r8d
    movl    $44, %ecx
    movl    $33, %edx
    movl    $22, %esi
    movl    $11, %edi
    call    add
    movl    %eax, -8(%rbp)
    movl    -12(%rbp), %eax
    movl    %eax, -4(%rbp)
    movl    $0, %eax
    leave
    ret

首先看 main 函数的前三条汇编语句:

.LFB3:
    pushq    %rbp
.LCFI2:
    movq    %rsp, %rbp
.LCFI3:
    subq    $48, %rsp

保存父函数栈帧,之后创建main 函数的栈帧并且分配了48 Byte 的空间。执行完成后,main 函数的栈帧如下图所示:

 

 

继续往后走,可以看到对k=i+j的处理过程:

    movl    $10, -20(%rbp)
    movl    $20, -16(%rbp)
    movl    -16(%rbp), %eax
    addl    -20(%rbp), %eax
    movl    %eax, -12(%rbp)  
    movl    $88, 8(%rsp)
    movl    $77, (%rsp)
    movl    $66, %r9d
    movl    $55, %r8d
    movl    $44, %ecx
    movl    $33, %edx
    movl    $22, %esi
    movl    $11, %edi
    call    add

需要注意的是,传统的栈空间的利用操作是使用一个栈空间,进行一次push操作。但是我们的代码里没有这样进行,而是利用之前分配的48字节的空间,以空间的缩减进行分配,本质上是和push操作是一样的。最终的计算结果保存在%eax中。

 

后续进行add函数调用,add的返回值将会放在%eax中,当前%eax中保存的是k值。所以需要首先保存%eax中的值,然后在add函数中进行调用,最后再恢复%eax的值。%eax 是 Caller Save的,所以由父函数main函数来进行保存(movl %eax,-12(%rbp))。

 

再往后,开始参数入栈,前6个参数依次保存到对应的寄存器中,最后两个参数从右到左压入栈中。

 

进入 add 函数后之后的操作如下:

add:
.LFB2:
    pushq    %rbp ; 保存父栈帧指针
.LCFI0:
    movq    %rsp, %rbp  ; 创建新栈帧
.LCFI1:
    movl    %edi, -20(%rbp)  ; 在寄存器中的参数压栈
    movl    %esi, -24(%rbp)
    movl    %edx, -28(%rbp)
    movl    %ecx, -32(%rbp)
    movl    %r8d, -36(%rbp)
    movl    %r9d, -40(%rbp)
    movl    -24(%rbp), %eax
    addl    -20(%rbp), %eax
    addl    -28(%rbp), %eax
    addl    -32(%rbp), %eax
    addl    -36(%rbp), %eax
    addl    -40(%rbp), %eax
    addl    16(%rbp), %eax
    addl    24(%rbp), %eax
    movl    %eax, -4(%rbp)
    movl    -4(%rbp), %eax
    leave
    ret

首先创建新栈帧,然后进行参数入栈。

 

在参数入栈时,我们看到并未使用 push 之类的指令,也没有调整 %esp 指针的值,而是使用了 -N(%rbp) 这样的指令来使用新的栈空间。这种使用”基地址+偏移量“ 来使用栈的方式和直接使用 %esp 指向栈顶的方式其实是一样的。

 

当add函数返回后,返回结果存储在%eax 中,%rbp 和 %rsp 调整为指向 main 的栈帧,之后执行main 函数中的如下指令:

movl    %eax, -8(%rbp)  ; 保存 add 函数返回值到栈中,对应 C 语句 int sum = add(...)
movl   -12(%rbp), %eax  ; 恢复寄存器 %eax 的值,与调用add前保存 %eax 相对应 
movl    %eax, -4(%rbp) ; 对应 C 语句 m = k,%eax 中的值就是 k。
movl    $0, %eax  ; main 函数返回值
leave   ; main 函数返回
ret

add 函数返回时,把返回值保存到了 %eax 中,使用完返回值后,会恢复 caller save 寄存器 %eax的值,这时main 栈帧恢复到调用add函数之前的状态。

 

需要注意的是,在调用 add 之前,main 中执行了一条 subq 48, %rsp 的指令,这主要是因为main函数并未再调用其他函数,结尾处的leave、ret两条指令直接覆盖了%rsp的值从而回到了父栈帧中。如果先调整 main 栈帧的 %rsp 值,之后 leave 再覆盖 %rsp 的值,相当于调整是多余的。因而省略main 中 add返回之后的 %rsp 的调整,而使用 leave 直接覆盖%rsp更为合理。

 

之前对这一块不是很懂,看了大佬的文章后就明白了~

参考链接

最后附上大佬的知乎链接,这篇文章解决了我很多疑惑。

  1. 知乎大佬原文


看雪线上公开课第01期《安全编码之SQL注入》,周日下午14:00,提前报名免费参与!

最新回复 (10)
supersoar 2020-1-15 16:00
2
0
感谢楼主分享技术文章。
~时光荏苒 2020-1-15 20:12
3
0
x64  不是 rcx rdx r8 r9 多余就用栈 吗
有毒 2 2020-1-15 22:26
4
0
一样的
最后于 2020-2-14 10:51 被有毒编辑 ,原因:
LovenSar 2020-2-12 01:47
5
0
x86_64和x64本质上不一样嘛?
Editor 2020-2-12 21:41
6
0
感谢分享!
明天去要饭 2020-2-12 21:53
7
0
感谢分享!
编程小白 2020-2-13 15:11
8
0
有毒 x86_64和x64是不一样的,你说是对的。我说的是x86_64架构的,也没错。
x64 是x86_64的简称
编程小白 2020-2-13 15:12
9
0
有毒 x86_64和x64是不一样的,你说是对的。我说的是x86_64架构的,也没错。
现在主流的有amd64(intel叫x86_64,简称x64) 和IA 64 两个64位平台 
编程小白 2020-2-13 15:21
10
0
4个和6个寄存器传参只不过是编译器的区别,GCC是6个,MSVC是4个
有毒 2 2020-2-14 10:45
11
0
编程小白 4个和6个寄存器传参只不过是编译器的区别,GCC是6个,MSVC是4个
感谢师傅的讲解,是我没有学习充分
游客
登录 | 注册 方可回帖
返回