X86-64寄存器和栈帧

概要

说到x86-64&＃xff0c;总不免要说说AMD的牛逼&＃xff0c;x86-64是x86系列中集大成者&＃xff0c;继承了向后兼容的优良传统&＃xff0c;最早由AMD公司提出&＃xff0c;代号AMD64&＃xff1b;正是由于能向后兼容&＃xff0c;AMD公司打了一场漂亮翻身战。导致Intel不得不转而生产兼容AMD64的CPU。这是IT行业以弱胜强的经典战役。不过&＃xff0c;大家为了名称延续性&＃xff0c;更习惯称这种系统结构为x86-64。

X86-64在向后兼容的同时&＃xff0c;更主要的是注入了全新的特性&＃xff0c;特别的&＃xff1a;x86-64有两种工作模式&＃xff0c;32位OS既可以跑在传统模式中&＃xff0c;把CPU当成i386来用&＃xff1b;又可以跑在64位的兼容模式中&＃xff0c;更加神奇的是&＃xff0c;可以在32位的OS上跑64位的应用程序。有这种好事&＃xff0c;用户肯定买账啦。

值得一提的是&＃xff0c;X86-64开创了编译器的新纪元&＃xff0c;在之前的时代里&＃xff0c;Intel CPU的晶体管数量一直以摩尔定律在指数发展&＃xff0c;各种新奇功能层出不穷&＃xff0c;比如&＃xff1a;条件数据传送指令cmovg&＃xff0c;SSE指令等。但是GCC只能保守地假设目标机器的CPU是1985年的i386&＃xff0c;额。。。这样编译出来的代码效率可想而知&＃xff0c;虽然GCC额外提供了大量优化选项&＃xff0c;但是这对应用程序开发者提出了很高的要求&＃xff0c;会者寥寥。X86-64的出现&＃xff0c;给GCC提供了一个绝好的机会&＃xff0c;在新的x86-64机器上&＃xff0c;放弃保守的假设&＃xff0c;进而充分利用x86-64的各种特性&＃xff0c;比如&＃xff1a;在过程调用中&＃xff0c;通过寄存器来传递参数&＃xff0c;而不是传统的堆栈。又如&＃xff1a;尽量使用条件传送指令&＃xff0c;而不是控制跳转指令。

寄存器简介

先明确一点&＃xff0c;本文关注的是通用寄存器&＃xff08;后简称寄存器&＃xff09;。既然是通用的&＃xff0c;使用并没有限制&＃xff1b;后面介绍寄存器使用规则或者惯例&＃xff0c;只是GCC&＃xff08;G&＃43;&＃43;&＃xff09;遵守的规则。因为我们想对GCC编译的C(C&＃43;&＃43;)程序进行分析&＃xff0c;所以了解这些规则就很有帮助。

在体系结构教科书中&＃xff0c;寄存器通常被说成寄存器文件&＃xff0c;其实就是CPU上的一块存储区域&＃xff0c;不过更喜欢使用标识符来表示&＃xff0c;而不是地址而已。

X86-64中&＃xff0c;所有寄存器都是64位&＃xff0c;相对32位的x86来说&＃xff0c;标识符发生了变化&＃xff0c;比如&＃xff1a;从原来的%ebp变成了%rbp。为了向后兼容性&＃xff0c;%ebp依然可以使用&＃xff0c;不过指向了%rbp的低32位。

X86-64寄存器的变化&＃xff0c;不仅体现在位数上&＃xff0c;更加体现在寄存器数量上。新增加寄存器%r8到%r15。加上x86的原有8个&＃xff0c;一共16个寄存器。
刚刚说到&＃xff0c;寄存器集成在CPU上&＃xff0c;存取速度比存储器快好几个数量级&＃xff0c;寄存器多了&＃xff0c;GCC就可以更多的使用寄存器&＃xff0c;替换之前的存储器堆栈使用&＃xff0c;从而大大提升性能。

让寄存器为己所用&＃xff0c;就得了解它们的用途&＃xff0c;这些用途都涉及函数调用&＃xff0c;X86-64有16个64位寄存器&＃xff0c;分别是&＃xff1a;

%rax&＃xff0c;%rbx&＃xff0c;%rcx&＃xff0c;%rdx&＃xff0c;%esi&＃xff0c;%edi&＃xff0c;%rbp&＃xff0c;%rsp&＃xff0c;%r8&＃xff0c;%r9&＃xff0c;%r10&＃xff0c;%r11&＃xff0c;%r12&＃xff0c;%r13&＃xff0c;%r14&＃xff0c;%r15。

其中&＃xff1a;

• %rax 作为函数返回值使用。
• %rsp 栈指针寄存器&＃xff0c;指向栈顶
• %rdi&＃xff0c;%rsi&＃xff0c;%rdx&＃xff0c;%rcx&＃xff0c;%r8&＃xff0c;%r9 用作函数参数&＃xff0c;依次对应第1参数&＃xff0c;第2参数。。。
• %rbx&＃xff0c;%rbp&＃xff0c;%r12&＃xff0c;%r13&＃xff0c;%14&＃xff0c;%15 用作数据存储&＃xff0c;遵循被调用者使用规则&＃xff0c;简单说就是随便用&＃xff0c;调用子函数之前要备份它&＃xff0c;以防他被修改

• %r10&＃xff0c;%r11 用作数据存储&＃xff0c;遵循调用者使用规则&＃xff0c;简单说就是使用之前要先保存原值

 

 Main函数第40行的指令Callfoo其实干了两件事情&＃xff1a;

• Pushl %rip //保存下一条指令&＃xff08;第41行的代码地址&＃xff09;的地址&＃xff0c;用于函数返回继续执行
• Jmp foo //跳转到函数foo

Foo函数第19行的指令ret 相当于&＃xff1a;

• popl %rip //恢复指令指针寄存器

栈帧的建立和撤销

还是上一个例子&＃xff0c;看看栈帧如何建立和撤销。

说题外话&＃xff0c;以”点”做为前缀的指令都是用来指导汇编器的命令。无意于程序理解&＃xff0c;统统忽视之&＃xff0c;比如第31行。

栈帧中&＃xff0c;最重要的是帧指针%ebp和栈指针%esp&＃xff0c;有了这两个指针&＃xff0c;我们就可以刻画一个完整的栈帧。

函数main的第30~32行&＃xff0c;描述了如何保存上一个栈帧的帧指针&＃xff0c;并设置当前的指针。
第49行的leave指令相当于&＃xff1a;

Movq %rbp %rsp //撤销栈空间&＃xff0c;回滚%rsp。

Popq %rbp //恢复上一个栈帧的%rbp。

同一件事情会有很多的做法&＃xff0c;GCC会综合考虑&＃xff0c;并作出选择。选择leave指令&＃xff0c;极有可能因为该指令需要存储空间少&＃xff0c;需要时钟周期也少。

你会发现&＃xff0c;在所有的函数中&＃xff0c;几乎都是同样的套路&＃xff0c;我们通过gdb观察一下进入foo函数之前main的栈帧&＃xff0c;进入foo函数的栈帧&＃xff0c;退出foo的栈帧情况。

Shell> gcc -g -o testtest.c

Shell> gdb --args test

Gdb > break main

Gdb > run

进入foo函数之前&＃xff1a;

你会发现rbp-rsp&＃61;0×20&＃xff0c;这个是由代码第11行造成的。
进入foo函数的栈帧&＃xff1a;

回到main函数的栈帧&＃xff0c;rbp和rsp恢复成进入foo之前的状态&＃xff0c;就好像什么都没发生一样。

可有可无的帧指针

你刚刚搞清楚帧指针&＃xff0c;是不是很期待要马上派上用场&＃xff0c;这样你可能要大失所望&＃xff0c;因为大部分的程序&＃xff0c;都加了优化编译选项&＃xff1a;-O2&＃xff0c;这几乎是普遍的选择。在这种优化级别&＃xff0c;甚至更低的优化级别-O1&＃xff0c;都已经去除了帧指针&＃xff0c;也就是%ebp中再也不是保存帧指针&＃xff0c;而且另作他途。

在x86-32时代&＃xff0c;当前栈帧总是从保存%ebp开始&＃xff0c;空间由运行时决定&＃xff0c;通过不断push和pop改变当前栈帧空间&＃xff1b;x86-64开始&＃xff0c;GCC有了新的选择&＃xff0c;优化编译选项-O1&＃xff0c;可以让GCC不再使用栈帧指针&＃xff0c;下面引用 gcc manual 一段话 &＃xff1a;

-O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging.

这样一来&＃xff0c;所有空间在函数开始处就预分配好&＃xff0c;不需要栈帧指针&＃xff1b;通过%rsp的偏移就可以访问所有的局部变量。说了这么多&＃xff0c;还是看看例子吧。同一个例子&＃xff0c; 加上-O1选项&＃xff1a;

Shell>: gcc –O1 –S –o test.s test.c

分析main函数&＃xff0c;GCC分析发现栈帧只需要8个字节&＃xff0c;于是进入main之后第一条指令就分配了空间(第23行)&＃xff1a;

Subq $8, %rsp

然后在返回上一栈帧之前&＃xff0c;回收了空间&＃xff08;第34行&＃xff09;&＃xff1a;

Addq $8, %rsp

等等&＃xff0c;为啥main函数中并没有对分配空间的引用呢&＃xff1f;这是因为GCC考虑到栈帧对齐需求&＃xff0c;故意做出的安排。再来看foo函数&＃xff0c;这里你可以看到%rsp是如何引用栈空间的。等等&＃xff0c;不是需要先预分配空间吗&＃xff1f;这里为啥没有预分配&＃xff0c;直接引用栈顶之外的地址&＃xff1f;这就要涉及x86-64引入的牛逼特性了。

访问栈顶之外

通过readelf查看可执行程序的header信息&＃xff1a;

红色区域部分指出了x86-64遵循ABI规则的版本&＃xff0c;它定义了一些规范&＃xff0c;遵循ABI的具体实现应该满足这些规范&＃xff0c;其中&＃xff0c;他就规定了程序可以使用栈顶之外128字节的地址。

这说起来很简单&＃xff0c;具体实现可有大学问&＃xff0c;这超出了本文的范围&＃xff0c;具体大家参考虚拟存储器。别的不提&＃xff0c;接着上例&＃xff0c;我们发现GCC利用了这个特性&＃xff0c;干脆就不给foo函数分配栈帧空间了&＃xff0c;而是直接使用栈帧之外的空间。&＃64;恨少说这就相当于内联函数呗&＃xff0c;我要说&＃xff1a;这就是编译优化的力量。

寄存器保存惯例

过程调用中&＃xff0c;调用者栈帧需要寄存器暂存数据&＃xff0c;被调用者栈帧也需要寄存器暂存数据。如果调用者使用了%rbx&＃xff0c;那被调用者就需要在使用之前把%rbx保存起来&＃xff0c;然后在返回调用者栈帧之前&＃xff0c;恢复%rbx。遵循该使用规则的寄存器就是被调用者保存寄存器&＃xff0c;对于调用者来说&＃xff0c;%rbx就是非易失的。

反过来&＃xff0c;调用者使用%r10存储局部变量&＃xff0c;为了能在子函数调用后还能使用%r10&＃xff0c;调用者把%r10先保存起来&＃xff0c;然后在子函数返回之后&＃xff0c;再恢复%r10。遵循该使用规则的寄存器就是调用者保存寄存器&＃xff0c;对于调用者来说&＃xff0c;%r10就是易失的&＃xff0c;举个例子&＃xff1a;

#include

#include

void sfact_helper ( long int x, long int * resultp)

{

    if (x<&＃61;1)

       *resultp &＃61; 1;

    else {

       long int nresult;

       sfact_helper(x-1,&nresult);

       *resultp &＃61; x * nresult;

    }

}      /* -----  end of function foo  ----- */

long int

sfact ( long int x )

{

    long int result;

   sfact_helper(x, &result);

    return result;

}      /* -----  end of function sfact  ----- */

int

main ( int argc, char *argv[] )

{

    int sum &＃61; sfact(10);

   fprintf(stdout, "sum&＃61;%d\n", sum);

    return EXIT_SUCCESS;

}               /* ----------  end of function main  ---------- */

命令行中调用gcc&＃xff0c;生成汇编语言&＃xff1a;

Shell>: gcc –O1 –S –o test2.s test2.c

在函数sfact_helper中&＃xff0c;用到了寄存器%rbx和%rbp&＃xff0c;在覆盖之前&＃xff0c;GCC选择了先保存他们的值&＃xff0c;代码6~9说明该行为。在函数返回之前&＃xff0c;GCC依次恢复了他们&＃xff0c;就如代码27-28展示的那样。

看这段代码你可能会困惑&＃xff1f;为什么%rbx在函数进入的时候&＃xff0c;指向的是-16&＃xff08;%rsp&＃xff09;&＃xff0c;而在退出的时候&＃xff0c;变成了32(%rsp) 。上文不是介绍过一个重要的特性吗&＃xff1f;访问栈帧之外的空间&＃xff0c;这是GCC不用先分配空间再使用&＃xff1b;而是先使用栈空间&＃xff0c;然后在适当的时机分配。第11行代码展示了空间分配&＃xff0c;之后栈指针发生变化&＃xff0c;所以同一个地址的引用偏移也相应做出调整。

X86时代&＃xff0c;参数传递是通过入栈实现的&＃xff0c;相对CPU来说&＃xff0c;存储器访问太慢&＃xff1b;这样函数调用的效率就不高&＃xff0c;在x86-64时代&＃xff0c;寄存器数量多了&＃xff0c;GCC就可以利用多达6个寄存器来存储参数&＃xff0c;多于6个的参数&＃xff0c;依然还是通过入栈实现。了解这些对我们写代码很有帮助&＃xff0c;起码有两点启示&＃xff1a;

• 尽量使用6个以下的参数列表&＃xff0c;不要让GCC为难啊。
• 传递大对象&＃xff0c;尽量使用指针或者引用&＃xff0c;鉴于寄存器只有64位&＃xff0c;而且只能存储整形数值&＃xff0c;寄存器存不下大对象

让我们具体看看参数是如何传递的&＃xff1a;

#include

#include

int foo ( int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7 )

{

    int array[] &＃61; {100,200,300,400,500,600,700};

    int sum &＃61; array[arg1]&＃43; array[arg7];

    return sum;

}      /* -----  end of function foo  ----- */

    int

main ( int argc, char *argv[] )

{

    int i &＃61; 1;

    int j &＃61; foo(0,1,2, 3, 4, 5,6);

   fprintf(stdout, "i&＃61;%d,j&＃61;%d\n", i, j);

    return EXIT_SUCCESS;

}               /* ----------  end of function main  ---------- */

命令行中调用gcc&＃xff0c;生成汇编语言&＃xff1a;

Shell>: gcc –O1 –S –o test1.s test1.c

Main函数中&＃xff0c;代码31~37准备函数foo的参数&＃xff0c;从参数7开始&＃xff0c;存储在栈上&＃xff0c;%rsp指向的位置&＃xff1b;参数6存储在寄存器%r9d&＃xff1b;参数5存储在寄存器%r8d&＃xff1b;参数4对应于%ecx&＃xff1b;参数3对应于%edx&＃xff1b;参数2对应于%esi&＃xff1b;参数1对应于%edi。

Foo函数中&＃xff0c;代码14-15&＃xff0c;分别取出参数7和参数1&＃xff0c;参与运算。这里数组引用&＃xff0c;用到了最经典的寻址方式&＃xff0c;-40&＃xff08;%rsp&＃xff0c;%rdi&＃xff0c;4&＃xff09;&＃61;%rsp &＃43; %rdi *4 &＃43; (-40);其中%rsp用作数组基地址&＃xff1b;%rdi用作了数组的下标&＃xff1b;数字4表示sizeof&＃xff08;int&＃xff09;&＃61;4。

结构体传参

应&＃64;桂南要求&＃xff0c;再加一节&＃xff0c;相信大家也很想知道结构体是如何存储&＃xff0c;如何引用的&＃xff0c;如果作为参数&＃xff0c;会如何传递&＃xff0c;如果作为返回值&＃xff0c;又会如何返回。

看下面的例子&＃xff1a;

#include

#include

struct demo_s {

    char var8;

    int  var32;

    long var64;

};

struct demo_s foo (struct demo_s d)

{

    d.var8&＃61;8;

    d.var32&＃61;32;

    d.var64&＃61;64;

    return d;

}      /* -----  end of function foo  ----- */

    int

main ( int argc, char *argv[] )

{

    struct demo_s d, result;

   result &＃61; foo (d);

   fprintf(stdout, "demo: %d, %d, %ld\n", result.var8,result.var32, result.var64);

    return EXIT_SUCCESS;

}               /* ----------  end of function main  ---------- */

我们缺省编译选项&＃xff0c;加了优化编译的选项可以留给大家思考。

Shell>gcc  -S -o test.s test.c

上面的代码加了一些注释&＃xff0c;方便大家理解&＃xff0c;
问题1&＃xff1a;结构体如何传递&＃xff1f;它被分成了两个部分&＃xff0c;var8和var32合并成8个字节的大小&＃xff0c;放在寄存器%rdi中&＃xff0c;var64放在寄存器的%rsi中。也就是结构体分解了。
问题2&＃xff1a;结构体如何存储? 注意看foo函数的第15~17行注意到&＃xff0c;结构体的引用变成了一个偏移量访问。这和数组很像&＃xff0c;只不过他的元素大小可变。

问题3&＃xff1a;结构体如何返回&＃xff0c;原本%rax充当了返回值的角色&＃xff0c;现在添加了返回值2&＃xff1a;%rdx。同样&＃xff0c;GCC用两个寄存器来表示结构体。
恩&＃xff0c; 即使在缺省情况下&＃xff0c;GCC依然是想尽办法使用寄存器。随着结构变的越来越大&＃xff0c;寄存器不够用了&＃xff0c;那就只能使用栈了。

总结

了解寄存器和栈帧的关系&＃xff0c;对于gdb调试很有帮助&＃xff1b;过些日子&＃xff0c;一定找个合适的例子和大家分享一下。

参考

1. 深入理解计算机体系结构
2. x86系列汇编语言程序设计