C++函数调用过程解析

为什么80%的码农都做不了架构师？>>>   

用一个简单的例子解释C++函数调用的过程，备忘。

实验环境

以下是本次实验的环境配置

* 操作系统: Ubuntu 14.04 x86_64
* 编译器: gcc-4.8.2

开始之前

阅读资料

开始之前，建议先阅读如下几篇文章，对call stack和asm多少有点了解，下文会涉及到很多这方面的东西。

• Understanding Memory
• Wikipedia:call stack
• A Readers Guide to x86 Assembly
• Wikipedia:function prologue

预备知识

下面是一些在后面的解释中会用到的知识，以下说明均基于x86-64平台。

1. 栈(call stack, runtime stack或stack): 在Linux上我们编译程序后一般生成的可执行文件是ELF格式的，下图是一个简化版的ELF文件结构[1]

    +----------------------+
    |       ... ...        |
    +----------------------+
    |        .text         | <- 程序的可执行指令
    +----------------------+
    |       ... ...        |
    +----------------------+
    |        .data         | <- 初始化的全局和静态变量
    +----------------------+
    |        .bss          | <- 未初始化的全局和静态变量
    +----------------------+
    |       ... ...        |
    +----------------------+
   

   可执行文件将会在运行时被载入内存中，下面是一个简化的进程虚拟地址空间图。

    +----------------------+ <- 高地址处
    |       ... ...        |
    +----------------------+
    |        stack         | <- 本文的主角，call stack，向低地址处生长
    +----------------------+
    |       ... ...        |
    +----------------------+
    |        heap          | <- 动态分配的内存，向高地址处生长
    +----------------------+
    |  uninitialized data  | <- 未初始化的全局变量和静态变量
    +----------------------+
    |   initialzed data    | <- 初始化的全局和静态变量，从ELF的.data区载入
    +----------------------+
    |        code          | <- 程序代码，从ELF的.text区载入
    +----------------------+
    |       ... ...        |
    +----------------------+ <- 低地址处
   

2. 寄存器:

   • %rax: 通常用于返回第一个整数。
   • %rbp: base pointer，指向当前frame的底部附近(caller的%rbp)。
   • %rsp: stack pointer，用于保存最新分配的frame的顶部，也就是stack顶部。

3. 调用者(caller)和被调用者(callee): 在函数foo的上下文中，调用者(caller)就是main函数，被调用者(callee)就是foo函数。

4. stack frame: stack是由一个个的stack frmae组成的，每次函数调用都会在栈上分配一个新的frame，该frame内保存了当前函数调用的上下文信息，包括请求参数(可能直接保存在寄存器中[2])，返回地址和局部变量等内容。

5. 返回地址: callq指令会在调用函数的时候将下一条指令的地址push到stack上，当本次调用结束后，retq指令会跳转到被保存的返回地址处使程序继续执行。

6. stack上的数据是字节对齐的。

7. stack由高地址处向低地址处生长，在下图中16(%rbp)表示地址16 + value of register[%rbp]

    +----------------------+ <- 高地址处
    |       ... ...        |
    +----------------------+
    |      parameters      | <- 没有保存到寄存器里的callee的函数参数(如果有的话)
    +----------------------+ <- 16(%rbp) + n*8 n=0,1,2,3 ...
    |    return address    | <- callee的返回地址，callee的stack frame开始处
    +----------------------+ <- 8(%rbp)
    |     caller's %rbp    | <- 保存的是caller的%rbp
    +----------------------+ <- (%rbp)
    |    saved registers   | <- 最开始是在函数调用中会被占用的寄存器(如果有的话)，调用结束后恢复
    +----------------------+
    | callee's locals etc. | <- 之后是函数内定义的局部变量和临时变量(保存函数参数寄存器等)
    +----------------------+
    |       ... ...        |
    +----------------------+
    |      parameters      | <- callee的callee的函数参数(如果有的话)
    +----------------------+ <- n*8(%rsp) n=0,1,2,3 ...
    |       ... ...        | <- 栈顶，calleee的stack frame结束处
    +----------------------+ <- (%rsp)
    |       ... ...        |
    +----------------------+ <- 低地址处
   

   当callee的函数参数太多(或存在不能存储到寄存器上的参数类型)时，多余的函数参数会按照从右向左的顺序依次入栈，占用caller的stack frame的空间。[3]

8. 汇编指令:

   • leaveq: 相当于以下两条指令[4]

   mov %rbp, %rsp // 恢复rsp，将stack frame里的局部变量出栈
   pop %rbp       // 恢复caller的rbp中
   

   • callq: 将下一条指令的地址入栈，然后跳转到目标地址处执行[5]。
   • retq: 将返回地址出栈并跳转到该地址处继续执行[5]。

简单的例子

下面是一个非常简单的例子。

cpp源代码

// call_stack_example.cpp
int foo2(int a, long b, int c, int d, int e, int f, int g, int i) {
    return a + b;
}
int foo(int &a, long b) {
    int m = 1;
    int o[3] = {0x1, 0x2, 0x3};
    return foo2(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x9);
}
int main() {
    int z = 0xa;
    int r = foo(z, 0xb);
    return r;
}

使用如下命令编译call_stack_example.cpp

g++ -g -O0 -fno-stack-protector call_stack_example.cpp -o a.out

为了让汇编代码更简单，我们在编译选项里使用-fno-stack-protector，这可以禁止gcc默认启用的Stack Protection[6]，关于Stack Protection的详细信息可参考Buffer overflow protection和StackGuard: Simple Stack Smash Protection for GCC。

汇编代码和注释

然后使用objdump输出汇编代码

objdump -dS a.out -j .text

下面是call_stack_example.cpp内三个函数的汇编代码和注释，gcc默认使用的是AT&T汇编语法。

int foo2(int a, long b, int c, int d, int e, int f, int g, int i) {
  push %rbp               // 将caller的%rbp入栈
  mov %rsp,%rbp           // 初始化callee的%rbp
  mov %edi,-0x4(%rbp)     // a: mem[R[rbp]-0x4] = R[edi]
  // 暂存寄存器的值，使其可以被重用，使用-O选项可以优化掉这部分代码
  mov %rsi,-0x10(%rbp)    // b
  mov %edx,-0x8(%rbp)     // c
  mov %ecx,-0x14(%rbp)    // d
  mov %r8d,-0x18(%rbp)    // e
  mov %r9d,-0x1c(%rbp)    // f

return g + i;
  mov 0x18(%rbp),%eax     // g在caller的stack frame的底部
  mov 0x10(%rbp),%edx     // i在caller的stack frame的底部
  add %edx,%eax           // R[eax] += R[edx]
}
  pop %rbp    // 将caller的rbp出栈(恢复%rbp)
  retq        // 将返回地址出栈，跳转到该地址处

int foo(int &a, long b) {
  push %rbp             // 将caller的%rbp入栈
  mov %rsp,%rbp         // 初始化callee的%rbp
  sub $0x30,%rsp        // 为当前stack frame分配0x30字节的空间
  mov %rdi,-0x18(%rbp)  // mem[R[rbp]-0x18] = R[rdi]
  mov %rsi,-0x20(%rbp)  // mem[R[rbp]-0x20] = R[rsi]

int m = 1;
  movl $0x1,-0x4(%rbp)  // mem[R[rbp]-0x4] = 0x1

int o[3] = {0x1, 0x2, 0x3};
  movl $0x1,-0x10(%rbp) // mem[R[rbp]-0x10] = 0x1
  movl $0x2,-0xc(%rbp)  // mem[R[rbp]-0xc] = 0x1
  movl $0x3,-0x8(%rbp)  // mem[R[rbp]-0x10] = 0x1

return foo2(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x9);
  movl $0x9,0x8(%rsp)   // mem[R[rsp]+0x8] = 0x9; 参数太多，无法用寄存器传递参数0x9
  movl $0x7,(%rsp)      // mem[$[rsp]] = 0x7; 参数太多，无法用寄存器传递参数0x7
  mov $0x6,%r9d         // R[r9d] = 0x6 使用寄存器传递函数参数，下同
  mov $0x5,%r8d         // R[r8d] = 0x5
  mov $0x4,%ecx         // R[ecx] = 0x4
  mov $0x3,%edx         // R[edx] = 0x3
  mov $0x2,%esi         // R[esi] = 0x2
  mov $0x1,%edi         // R[edi] = 0x1
  callq 4004ed <_Z4foo2iliiiiii> // 调用foo2
}
  leaveq    // 将caller的rbp出栈(恢复%rbp)，将已保存的局部变量和临时变量出栈
  retq      // 将返回地址出栈，跳转到该地址处

int main() {
  push %rbp         // 将caller的%rbp入栈
  mov %rsp,%rbp     // 初始化callee的%rbp
  sub $0x10,%rsp    // 为当前stack frame分配0x10字节的空间

int z = 0xa;
  movl $0xa,-0x8(%rbp) // mem[R[%rbp]-0x8] = 0xa

int r = foo(z, 0xb);
  lea -0x8(%rbp),%rax   // R[rax] = &z
  mov $0xb,%esi         // R[esi] = 0xb
  mov %rax,%rdi         // R[rdi] = R[rax]
  callq 400513 <_Z3fooRil>  // 调用foo
  mov %eax,-0x4(%rbp)       // mem[R[rbp]-0x4] = R[eax] (%eax保存了之前foo的返回值)

return r;
  mov -0x4(%rbp),%eax   // R[eax] = mem[R[rbp]-0x4]
}
  leaveq    // 将caller的rbp出栈(恢复%rbp)，将已保存的局部变量和临时变量出栈
  retq      // 将返回地址出栈，跳转到该地址处
  nopl (%rax)

其他例子

函数参数传递

下面的例子取自System V Application Binary Interface的图3.5 Parameter Passing Example和图3.6 Register Allocation Example

假设有以下结构体和函数

typedef struct {
    int a, b;
    double d;
} structparm;

extern void func(
    int e,
    int f,
    structparm s,
    int g,
    int h,
    long double ld,
    double m,
    __m256 y,
    double n,
    int i,
    int j,
    int k);

然后如下调用函数func:

structparm s;
int e, f, g, h, i, j, k;
long double ld;
double m, n;
__m256 y;

func (e, f, s, g, h, ld, m, y, n, i, j, k);

则函数参数的传递方式如下表

General Purpose Registers	Floating Point Registers	Stack Frame Offset
%rdi: e	%xmm0: s.d	0: ld
%rsi: f	%xmm1: m	16: j
%rdx: s.a, s.b	%ymm2: y[7]	24: k[8]
%rcx: g	%xmm3: n
%r8: h
%r9: i

额外阅读资料

1. System V Application Binary Interface
2. Gentle Introduction to x86-64 Assembly
3. x86-64 Machine-Level Programming
4. Review of assembly language
5. Buffer Overflows and You
6. Protection against buffer overflows
7. Stack frame layout on x86-64
8. BUFFER OVERFLOW 6: The Function Stack
9. Linux x86 Program Start Up
10. x64 Architecture
11. X86_64 Assembly Language Tutorial: Part 1
12. Amd64 Overview

1. man elf，引用于2014-05-07。 ↩

2. 关于参数是否通过寄存器传递的具体细则，请参考System V Application Binary Interface的3.2.3 Parameter Passing部分。 ↩

3. 参考System V Application Binary Interface的3.2 Function Calling Sequence，引用于2014-05-07。 ↩

4. Wikipedia:function prologue, 引用于2014-05-04。 ↩

5. Call vs Jmp: The Stack Connection，引用于2014-05-05。 ↩ ↩

6. 参考man gcc中关于-fstack-protector选项的说明。 ↩

7. %ymm0-%ymm15是256位的浮点数寄存器，其低128位对应%xmm0-%xmm15 ↩

8. 栈上的函数参数要按8字节对齐 ↩

转载于:https://my.oschina.net/tsh/blog/1475209