X86汇编语言学习手记（1，2）
时间：2010-05-12 来源：wwm
X86汇编语言学习手记(1)
作者: Badcoffee
Email: [email protected]
2004年10月
这是作者在学习X86汇 编过程中的学习笔记，难免有错误和疏漏之处，欢迎指正。
作者将随时修改错误并将新的版本发布在自己的Blog站点上。
严格说来，本篇文档更侧重于C语言和C编 译器方面的知识，如果涉及到具体汇编语言
的内容，可以参考相关文档。
1. 编译环境
OS: Solaris 9 X86
Compiler: gcc 3.3.2
Linker: Solaris Link Editors 5.x
Debug Tool: mdb
Editor: vi
注：关于编译环境的安装和设置，可以参考文章：Solaris 上的开发环境安装及设置。
mdb是Solaris提供的kernel debug工具，这里用它做反汇编和汇编语言调试工具。
如果在Linux平台可以用gdb进 行反汇编和调试。
2. 最简C代码分析
为简化问题，来分析一下最简的c代码生成的汇编代码：
# vi test1.c
int main()
{
return 0;
}
编译该程序，产生二进制文件：
# gcc test1.c -o test1
# file test1
test1: ELF 32-bit LSB executable 80386 Version 1, dynamically linked, not stripped
test1是一个ELF格式32位 小端(Little Endian)的可执行文件，动态链接并且符号表没有去除。
这正是Unix/Linux平台典型的可执行文件格式。
用mdb反汇编可以观察生成的汇编代码：
# mdb test1
Loading modules: [ libc.so.1 ]
> main::dis ; 反汇编main函数，mdb的命令一般格式为 <地址>::dis
main: pushl %ebp ; ebp寄存器内容压栈，即保存main函 数的上级调用函数的栈基地址
main+1: movl %esp,%ebp ; esp值赋给ebp，设置main函数的栈基址
main+3: subl ,%esp
main+6: andl xf0,%esp
main+9: movl ,%eax
main+0xe: subl %eax,%esp
main+0x10: movl ,%eax ; 设置函数返回值0
main+0x15: leave ; 将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原 栈基址
main+0x16: ret ; main函数返回，回到上级调用
>
注：这里得到的汇编语言语法格式与Intel的 手册有很大不同，Unix/Linux采用AT&T汇 编格式作为汇编语言的语法格式
如果想了解AT&T汇编可以参考文章：Linux AT&T 汇编语言开发指南
问题：谁调用了 main函数？
在C语言的层面来看，main函 数是一个程序的起始入口点，而实际上，ELF可执行文件的入口点并不是main而是_start。
mdb也可以反汇编_start：
> _start::dis ;从_start 的地址开始反汇编
_start: pushl
_start+2: pushl
_start+4: movl %esp,%ebp
_start+6: pushl %edx
_start+7: movl x80504b0,%eax
_start+0xc: testl %eax,%eax
_start+0xe: je +0xf <_start+0x1d>
_start+0x10: pushl x80504b0
_start+0x15: call -0x75
_start+0x1a: addl ,%esp
_start+0x1d: movl x8060710,%eax
_start+0x22: testl %eax,%eax
_start+0x24: je +7 <_start+0x2b>
_start+0x26: call -0x86
_start+0x2b: pushl x80506cd
_start+0x30: call -0x90
_start+0x35: movl +8(%ebp),%eax
_start+0x38: leal +0x10(%ebp,%eax,4),%edx
_start+0x3c: movl %edx,0x8060804
_start+0x42: andl xf0,%esp
_start+0x45: subl ,%esp
_start+0x48: pushl %edx
_start+0x49: leal +0xc(%ebp),%edx
_start+0x4c: pushl %edx
_start+0x4d: pushl %eax
_start+0x4e: call +0x152 <_init>
_start+0x53: call -0xa3 <__fpstart>
_start+0x58: call +0xfb ;在这里调用了main函数
_start+0x5d: addl xc,%esp
_start+0x60: pushl %eax
_start+0x61: call -0xa1
_start+0x66: pushl
_start+0x68: movl ,%eax
_start+0x6d: lcall ,
_start+0x74: hlt
>
问题：为什么用EAX寄存器保存函数返回值？
实际上IA32并没有规定用哪个寄存器来保存返回值。但如果反汇编Solaris/Linux的二进制文件，就会发现，都用EAX保 存函数返回值。
这不是偶然现象，是操作系统的ABI(Application Binary Interface)来决定的。
Solaris/Linux操作系统的ABI就是Sytem V ABI。
概念：SFP (Stack Frame Pointer) 栈框架指针
正确理解SFP必须了解：
IA32 的栈的概念
CPU 中32位寄存器ESP/EBP的作用
PUSH/POP 指令是如何影响栈的
CALL/RET/LEAVE 等指令是如何影响栈的
如我们所知：
1)IA32的栈是用来存放临时数据，而且是LIFO，即后进先出的。栈的 增长方向是从高地址向低地址增长，按字节为单位编址。
2) EBP是栈基址的指针，永远指向栈底（高地址），ESP是栈指针，永 远指向栈顶（低地址）。
3) PUSH一个long型数据时，以字节为单位将数据压入栈，从高到低 按字节依次将数据存入ESP-1、ESP-2、ESP-3、ESP-4的地址单元。
4) POP一个long型数据，过程与PUSH相反，依次将ESP-4、ESP-3、ESP-2、ESP-1从栈内弹出，放入一个32位寄存器。
5) CALL指令用来调用一个函数或过程，此时，下一条指令地址会被压入堆栈，以备返回时能恢复执行下条指令。
6) RET指令用来从一个函数或过程返回，之前CALL保存的下条指令地 址会从栈内弹出到EIP寄存器中，程序转到CALL之 前下条指令处执行
7) ENTER是建立当前函数的栈框架，即相当于以下两条指令：
pushl %ebp
movl %esp,%ebp
8) LEAVE是释放当前函数或者过程的栈框架，即相当于以下两条指令：
movl ebp esp
popl ebp
如果反汇编一个函数，很多时候会在函数进入和返回处，发现有类似如下形式的汇编语句：
pushl %ebp ; ebp寄存器内容压栈，即保存main函 数的上级调用函数的栈基地址
movl %esp,%ebp ; esp值赋给ebp，设置 main函数的栈基址
........... ; 以上两条指令相当于 enter 0,0
...........
leave ; 将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原栈基址
ret ; main函数返回，回到上级调用
这些语句就是用来创建和释放一个函数或者过程的栈框架的。
原来编译器会自动在函数入口和出口处插入创建和释放栈框架的语句。
函数被调用时：
1) EIP/EBP成为新函数栈的边界
函数被调用时，返回时的EIP首先被压入堆栈；创建栈框架时，上级函数栈的EBP被压入堆栈，与EIP一道行成新函数栈框架的边 界
2) EBP成为栈框架指针SFP，用来指示新函数栈 的边界
栈框架建立后，EBP指向的栈的内容就是上一级函数栈的EBP，可以想象，通过EBP就可以把层层调用函数的 栈都回朔遍历一遍，调试器就是利用这个特性实现 backtrace功能的
3) ESP总是作为栈指针指向栈顶，用来分配栈空间
栈分配空间给函数局部变量时的语句通常就是给ESP减去一个常数值，例如， 分配一个整型数据就是 ESP-4
4) 函数的参数传递和局部变量访问可以通过SFP即EBP来实现
由于栈框架指针永远指向当前函数的栈基地址，参数和局部变量访问通 常为如下形式：
+8+xx(%ebp) ; 函数入口参数的的访问
-xx(%ebp) ; 函数局部变量访问
假如函数A调用函数B， 函数B调用函数C ，则函数栈框架及调用关 系如下图所示：
+-------------------------+----> 高地址
| EIP (上级函数返回地址) |
+-------------------------+
+--> | EBP (上 级函数的EBP) | --+ <------当 前函数A的EBP (即SFP框架指针)
| +-------------------------+ +-->偏移量A
| | Local Variables | |
| | .......... | --+ <------ESP指向函数A新 分配的局部变量,局部变 量可以通过A的ebp-偏移量A访问
| f +-------------------------+
| r | Arg n(函数B的第n个参数) |
| a +-------------------------+
| m | Arg .(函数B的第.个参数) |
| e +-------------------------+
| | Arg 1(函 数B的第1个参数) |
| o +-------------------------+
| f | Arg 0(函数B的第0个参数) | --+ <------ B函数的参数可以由B的ebp+偏移量B访问
| +-------------------------+ +--> 偏移量B
| A | EIP (A函数的返回地址) | |
| +-------------------------+ --+
+--- | EBP (A函 数的EBP) |<--+ <------ 当前函数B的EBP (即SFP框架指针)
+-------------------------+ |
| Local Variables | |
| .......... | | <------ ESP指向函数B新分配的局部变量
+-------------------------+ |
| Arg n(函 数C的第n个参数) | |
+-------------------------+ |
| Arg .(函 数C的第.个参数) | |
+-------------------------+ +--> frame of B
| Arg 1(函 数C的第1个参数) | |
+-------------------------+ |
| Arg 0(函 数C的第0个参数) | |
+-------------------------+ |
| EIP (B函 数的返回地址) | |
+-------------------------+ |
+--> | EBP (B函 数的EBP) | --+ <------ 当前函数C的EBP (即SFP框架指针)
| +-------------------------+
| | Local Variables |
| | .......... | <------ ESP指向函数C新分配的局部变量
| +-------------------------+----> 低地址
frame of C
图 1-1
再分析test1反汇编结果中剩余部分语句的含义：
# mdb test1
Loading modules: [ libc.so.1 ]
> main::dis ; 反汇编main函数
main: pushl %ebp
main+1: movl %esp,%ebp ; 创建Stack Frame(栈框架)
main+3: subl ,%esp ; 通过ESP-8来分配8字节堆栈空间
main+6: andl xf0,%esp ; 使栈地址16字 节对齐
main+9: movl ,%eax ; 无意义
main+0xe: subl %eax,%esp ; 无意义
main+0x10: movl ,%eax ; 设置main函数返回值
main+0x15: leave ; 撤销Stack Frame(栈框架)
main+0x16: ret ; main 函数返回
>
以下两句似乎是没有意义的，果真是这样吗？
movl ,%eax
subl %eax,%esp
用gcc的O2级 优化来重新编译test1.c:
# gcc -O2 test1.c -o test1
# mdb test1
> main::dis
main: pushl %ebp
main+1: movl %esp,%ebp
main+3: subl ,%esp
main+6: andl xf0,%esp
main+9: xorl %eax,%eax ; 设置main返回值，使用xorl异或指令来使eax为0
main+0xb: leave
main+0xc: ret
>
新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之前的猜测。
提示：编译器产生的某些语句可能在程序实际语义上没有用处，可以用优化选项去掉这些语句。
问题：为什么用xorl来 设置eax的值？
注意到优化后的代码中，eax返 回值的设置由 movl ,%eax 变 为 xorl %eax,%eax ， 这是因为IA32指令中，xorl比movl有更高的运行速度。
概念：Stack aligned 栈对齐
那么，以下语句到底是和作用呢？
subl ,%esp
andl xf0,%esp ; 通过andl使低4位为0，保证栈地址16字节对齐
表面来看，这条语句最直接的后果是使ESP的地址后4位为0，即16字 节对齐，那么为什么这么做呢？
原来，IA32 系列CPU的 一些指令分别在4、8、16字节对齐时会有更快的运行速度，因此gcc编译器为 提高生成代码在IA32上的运行速度，默认对产生的代码进行16字 节对齐
andl xf0,%esp 的意义很明显，那么 subl ,%esp 呢，是必须的吗？
这里假设在进入main函数之前，栈是16字节对齐的话，那么，进入main函数后，EIP和EBP被压入堆栈后，栈地址最末4位二进制位必定是1000，esp -8则恰好使后4位地址二进制位为0000。看来，这也是为保证栈16字节对齐的。
如果查一下gcc的手册，就会发现关于栈对齐的参数设置：
-mpreferred-stack-boundary=n ; 希望栈按照2的n次的字节边界对齐, n的取值范围是2-12
默认情况下，n是 等于4的，也就是说，默认情况下，gcc是16字节对齐，以适应IA32大多数指令的要求。
让我们利用-mpreferred-stack-boundary=2来 去除栈对齐指令：
# gcc -mpreferred-stack-boundary=2 test1.c -o test1
> main::dis
main: pushl %ebp
main+1: movl %esp,%ebp
main+3: movl ,%eax
main+8: leave
main+9: ret
>
可以看到，栈对齐指令没有了，因为，IA32的栈本身就是4字节对齐的，不需要用额外指令进行对齐。
那么，栈框架指针SFP是不是必须的呢？
# gcc -mpreferred-stack-boundary=2 -fomit-frame-pointer test1.c -o test
> main::dis
main: movl ,%eax
main+5: ret
>
由此可知，-fomit-frame-pointer 可以 去除SFP。
问题：去除SFP后有什么缺点呢？
1)增加调式难度
由于SFP在调试器backtrace的 指令中被使用到，因此没有SFP该调试指令就无法使用。
2)降低汇编代码可读性
函数参数和局部变量的访问，在没有ebp的情况下，都只能通过+xx(esp)的方式访问，而很难区分两种方式，降低了程序的可读性。
问题：去除SFP有什么优点呢？
1)节省栈空间
2)减少建立和撤销栈框架的指令后，简化了代 码
3)使ebp空 闲出来，使之作为通用寄存器使用，增加通用寄存器的数量
4)以上3点使得程序运行速度更快
概念：Calling Convention 调用约定和 ABI (Application Binary Interface) 应用程序二进制接口
函数如何找到它的参数？
函数如何返回结果？
函数在哪里存放局部变量？
那一个硬件寄存器是起始空间？
那一个硬件寄存器必须预先保留？
Calling Convention 调 用约定对以上问题作出了规定。Calling Convention也是ABI的一部分。
因此，遵守相同ABI规 范的操作系统，使其相互间实现二进制代码的互操作成为了可能。
例如：由于Solaris、Linux都遵守System V的ABI，Solaris 10就提供了直接运行Linux二进制程序的功能。
详见文章：关注： Solaris 10的10大新变化
3. 小结
本文通过最简的C程 序，引入以下概念：
SFP 栈框架指针
Stack aligned 栈对齐
Calling Convention 调用约定 和 ABI (Application Binary Interface) 应用程序二进制接口
今后，将通过进一步的实验，来深入了解这些概念。通过掌握这些概念，使在汇编级调试程序产生的core dump、掌握C语言高级调试技巧成为了可 能。
X86 汇编语言学习手记(2)
作者: Badcoffee
Email: [email protected]
2004年11月
这是作者在学习X86汇编过程中的学习笔记，难免有错误和疏漏之处，欢迎指正。作者将随时修改错误并将新的版本发布在自己的Blog站点上。严格说来，本篇文档更侧重于C语言和C编译器方面的知识，如果涉及到基本的汇编语言的内容，可以参考相关文档。
自X86 汇编语言学习手记(1)在作者 的Blog上发布以来，得到了很多网友的肯定和鼓励，并且还有热心网友指出了其中的错误，作者已经 将文档中已发现的错误修正后更新在Blog上。
上一篇文章通过分析一个最简的C程序，引出了以下概念：
Stack Frame 栈框架 和 SFP 栈框架指针
Stack aligned 栈对齐
Calling Convention 调用约定 和 ABI (Application Binary Interface) 应用程序二进制接口
本章中，将通过进一步的实验，来深入了解这些概念。如果还不了解这 些概念，可以参考 X86汇编语言学习手记(1)。
1. 局部变量的栈分配
上篇文章已经分析过一个最简的C程序，
下面我们分析一下C编译器如何处理局部变量的分配，为此先给出如下程序：
#vi test2.c
int main()
{
int i;
int j=2;
i=3;
i=++i;
return i+j;
}
编译该程序，产生二进制文件，并利用mdb来观察程序运行中的stack的状态：
#gcc test2.c -o test2
#mdb test2
Loading modules: [ libc.so.1 ]
> main::dis
main: pushl %ebp
main+1: movl %esp,%ebp ; main至main+1，创建Stack Frame
main+3: subl ,%esp ; 为局部变量i,j分配栈空间，并保证栈16字节对齐
main+6: andl xf0,%esp
main+9: movl ,%eax
main+0xe: subl %eax,%esp ; main+6至main+0xe，再次保证栈16字节对齐
main+0x10: movl ,-8(%ebp) ; 初始化局部变量j的 值为2
main+0x17: movl ,-4(%ebp) ; 给局部变量i赋 值为3
main+0x1e: leal -4(%ebp),%eax ; 将局部变量i的 地址装入到EAX寄存器中
main+0x21: incl (%eax) ; i++
main+0x23: movl -8(%ebp),%eax ; 将j的 值装入EAX
main+0x26: addl -4(%ebp),%eax ; i+j并将结果存入EAX，作为返回值
main+0x29: leave ; 撤销Stack Frame
main+0x2a: ret ; main函数返回
>
> main+0x10:b ; 在地址 main+0x10处设置断点
> main+0x1e:b ; 在main+0x1e设 置断点
> main+0x29:b ; 在main+0x1e设 置断点
> main+0x2a:b ; 在main+0x1e设 置断点
下面的mdb的4个 命令在一行输入，中间用分号间隔开，命令的含义在注释中给出：
> :r;<esp,10/nap;<ebp=X;<eax=X ; 运行程序(:r 命令)
mdb: stop at main+0x10 ; 以ESP寄存器为起始地址，指定格式输出16字节的栈内容(<esp,10/nap 命 令)
mdb: target stopped at: ; 在最后输出EBP和EAX寄存器的值(<ebp=X 命令 和<eax=X 命令)
main+0x10: movl ,-8(%ebp) ; 程序运行后在main +0x10处指令执行前中断，此时栈分配后还未初始化
0x8047db0:
0x8047db0: 0xddbebca0 ; 这是变量j，4字节，未初始化，此处为栈顶，ESP的值就是0x8047db0
0x8047db4: 0xddbe137f ; 这是变量i， 4字节，未初始化
0x8047db8: 0x8047dd8 ; 这是_start的SFP(_start的EBP),4字节，由main 的SFP指向它
0x8047dbc: _start+0x5d ; 这是_start调 用main之前压栈的下条指令地址，main返 回后将恢复给EIP
0x8047dc0: 1
0x8047dc4: 0x8047de4
0x8047dc8: 0x8047dec
0x8047dcc: _start+0x35
0x8047dd0: _fini
0x8047dd4: ld.so.1`atexit_fini
0x8047dd8: 0 ; _start的SFP指向的内容为0，证明_start是程序的入口
0x8047ddc: 0
0x8047de0: 1
0x8047de4: 0x8047eb4
0x8047de8: 0
0x8047dec: 0x8047eba
8047db8 ; 这是main当前EBP寄存器的值，即main的SFP
0 ; EAX的值，当前为0
> :c;<esp,10/nap;<ebp=X;<eax=X ; 继续运行程序(:c 命令)， 其余3命令同上，打印16字节栈和EBP,EAX内容
mdb: stop at main+0x1e
mdb: target stopped at:
main+0x1e: leal -4(%ebp),%eax ; 程序运行到断点main+0x1e处 停止，此时局部变量i,j赋值已完成
0x8047db0:
0x8047db0: 2 ; 这是变量j，4字节，值为2，此处为栈顶，ESP的 值就是0x8047db0
0x8047db4: 3 ; 这是变量i，4字 节，值为3
0x8047db8: 0x8047dd8 ; 这是_start的SFP，4字节
0x8047dbc: _start+0x5d ; 这是返回_start后 的EIP
0x8047dc0: 1
0x8047dc4: 0x8047de4
0x8047dc8: 0x8047dec
0x8047dcc: _start+0x35
0x8047dd0: _fini
0x8047dd4: ld.so.1`atexit_fini
0x8047dd8: 0
0x8047ddc: 0
0x8047de0: 1
0x8047de4: 0x8047eb4
0x8047de8: 0
0x8047dec: 0x8047eba
8047db8 ; 这是main当前EBP寄存器的值，即main的SFP
0 ; EAX的值，当前为0
> :c;<esp,10/nap;<ebp=X;<eax=X ; 继续运行程序，打印16字节栈和EBP,EAX内 容
mdb: stop at main+0x29
mdb: target stopped at:
main+0x29: leave ; 运行到断点main+0x29处 停止，计算已经完成，即将撤销Stack Frame
0x8047db0:
0x8047db0: 2 ; 这是变量j，4字节，值为2，此处为栈顶，ESP的值就是0x8047db0
0x8047db4: 4 ; 这是i++以后的变量i，4字节，值为3
0x8047db8: 0x8047dd8 ; 这是_start的SFP，4字节
0x8047dbc: _start+0x5d ; 这是返回_start后 的EIP
0x8047dc0: 1
0x8047dc4: 0x8047de4
0x8047dc8: 0x8047dec
0x8047dcc: _start+0x35
0x8047dd0: _fini
0x8047dd4: ld.so.1`atexit_fini
0x8047dd8: 0
0x8047ddc: 0
0x8047de0: 1
0x8047de4: 0x8047eb4
0x8047de8: 0
0x8047dec: 0x8047eba
8047db8 ; 这是main当前EBP寄存器的值，即main的SFP
6 ; EAX的值，即函数的返回值，当前为6
> :c;<esp,10/nap;<ebp=X;<eax=X ; 继续运行程序，打印16字节栈和EBP,EAX内容
mdb: stop at main+0x2a
mdb: target stopped at:
main+0x2a: ret ; 运行到断点main+0x2a处停 止，Stack Frame已被撤销，main即 将返回
0x8047dbc:
0x8047dbc: _start+0x5d ; Stack Frame已经被撤销，栈顶是返回_start后的EIP，main的栈已被释放
0x8047dc0: 1
0x8047dc4: 0x8047de4
0x8047dc8: 0x8047dec
0x8047dcc: _start+0x35
0x8047dd0: _fini
0x8047dd4: ld.so.1`atexit_fini
0x8047dd8: 0
0x8047ddc: 0
0x8047de0: 1
0x8047de4: 0x8047eb4
0x8047de8: 0
0x8047dec: 0x8047eba
0x8047df0: 0x8047ed6
0x8047df4: 0x8047edd
0x8047df8: 0x8047ee4
8047dd8 ; _start的SFP,之前存储在地址0x8047db8处，main的Stack Frame撤销时恢复 6 ; EAX的值，即函数的返回值，当前为6
> :s;<esp,10/nap;<ebp=X;<eax=X ; 单步执行下条指 令(:s 命令)，打印16字节栈和EBP,EAX内容
mdb: target stopped at:
_start+0x5d: addl xc,%esp ; 此时main已经返回，_start+0x5d曾经存储在地址0x8047dbc处
0x8047dc0:
0x8047dc0: 1 ; main已经返回，_start +0x5d已经被弹出
0x8047dc4: 0x8047de4
0x8047dc8: 0x8047dec
0x8047dcc: _start+0x35
0x8047dd0: _fini
0x8047dd4: ld.so.1`atexit_fini
0x8047dd8: 0 ; _start的SFP指向的内容为0，证明_start是程序的入口
0x8047ddc: 0
0x8047de0: 1
0x8047de4: 0x8047eb4
0x8047de8: 0
0x8047dec: 0x8047eba
0x8047df0: 0x8047ed6
0x8047df4: 0x8047edd
0x8047df8: 0x8047ee4
0x8047dfc: 0x8047ef3
8047dd8 ; _start的SFP,之前存储在地址0x8047db8处，main的Stack Frame撤销时恢复
6 ; EAX的值为6，还是main函 数的返回值
>
通过mdb对程序运行时的寄存器和栈的观察和分析，可以得出局部变 量在栈中的访问和分配及释放方式：
1.局部变量的分配，可以通过esp减去所需字节数
subl ,%esp
2.局部变量的释放，可以通过leave指令
leave
3.局部变量的访问，可以通过ebp减去偏移量
movl -8(%ebp),%eax
addl -4(%ebp),%eax
问题：当存在2个以上的局部变量时，如何进行栈对齐？
在上篇文章中，提到subl ,%esp语句除了分配栈空间外，还有一个作用就是栈对齐。那么本例中，由于i和j正好是8字节，那么如果存在2个以上的局部变量时，如何同时满足空间分配和栈对齐呢？
2. 两个以上的局部变量的栈分配
在之前的C程序中，增加局部变量定义k， 程序如下：
# vi test3.c
int main()
{
int i, j=2, k=4;
i=3;
i=++i;
k=i+j+k;
return k;
}
编译该程序后，用mdb反汇编得出如下结果：
# gcc test3.c -o test3
# mdb test3
Loading modules: [ libc.so.1 ]
> main::dis
main: pushl %ebp
main+1: movl %esp,%ebp ; main至main+1，创建Stack Frame
main+3: subl x18,%esp ; 为局部变量i,j,k分 配栈空间，并保证栈16字节对齐
main+6: andl xf0,%esp
main+9: movl ,%eax
main+0xe: subl %eax,%esp ; main+6至main+0xe，再次保证栈16字节对齐
main+0x10: movl ,-8(%ebp) ; j=2
main+0x17: movl ,-0xc(%ebp) ; k=4
main+0x1e: movl ,-4(%ebp) ; i=3
main+0x25: leal -4(%ebp),%eax ; 将i的 地址装入到EAX
main+0x28: incl (%eax) ; i++
main+0x2a: movl -8(%ebp),%eax ; 将j的 值装入到 EAX
main+0x2d: movl -4(%ebp),%edx ; 将i的 值装入到 EDX
main+0x30: addl %eax,%edx ; j+i，结果存入EDX
main+0x32: leal -0xc(%ebp),%eax ; 将k的 地址装入到EAX
main+0x35: addl %edx,(%eax) ; i+j+k，结果存入地址ebp-0xc即k中
main+0x37: movl -0xc(%ebp),%eax ; 将k的 值装入EAX，作为返回值
main+0x3a: leave ; 撤销Stack Frame
main+0x3b: ret ; main函数返回
>
问题：为什么3个变量分配了0x18字节的栈空间？
在2个变量 的时候，分配栈空间的指令是：subl ,%esp
而在3个局 部变量的时候，分配栈空间的指令是：subl x18,%esp
3个整型变量只需要0xc字 节，为何实际上分配了0x18字节呢？
答案就是：保持16字节栈对齐。
在X86 汇编语言学习手记(1)里，已 经说明过gcc默认的编译是要16字节栈对 齐的，subl ,%esp会使栈16字 节对齐，而8字节空间只能满足2个局部变 量，如果再分配4字节满足第3个局部变量的 话，那栈地址就不再16字节对齐的，而同时满足空间需要而且保持16字节栈对齐的最接近的就是0x18。
如果，各定义一个50字节和100字 节的字符数组，在这种情况下，实际分配多少栈空间呢？答案是0x8+0x40+0x70，即184字节。
下面动手验证一下：
# vi test4.c
int main()
{
char str1[50];
char str2[100];
return 0;
}
# mdb test4
Loading modules: [ libc.so.1 ]
> main::dis
main: pushl %ebp
main+1: movl %esp,%ebp
main+3: subl xb8,%esp ; 为两个字符数组分配栈空间，同时保证16字 节对齐
main+9: andl xf0,%esp
main+0xc: movl ,%eax
main+0x11: subl %eax,%esp
main+0x13: movl ,%eax
main+0x18: leave
main+0x19: ret
> 0xb8=D ; 16进制换算10进制
184
> 0x40+0x70+0x8=X ; 表达式计算，结果指定为16进制
b8
>
问题：定义了多个局部变量时，栈分配顺序是怎样的？
局部变量栈分配的顺序是按照变量声明先后的顺序，同一行声明的变量 是按照从左到右的顺序入栈的，在test2.c中，变量声明如下：
int i, j=2, k=4;
而反汇编的结果中：
movl ,-8(%ebp) ; j=2
movl ,-0xc(%ebp) ; k=4
movl ,-4(%ebp) ; i=3
其中不难看出，i,j,k的栈中的位置如下图：
+----------------------------+------> 高地址
| EIP (_start函数的返回地址) |
+----------------------------+
| EBP (_start函数的EBP) | <------ main函数的EBP指针(即SFP框架指针)
+----------------------------+
| i (EBP-4) |
+----------------------------+
| j (EBP-8) |
+----------------------------+
| k (EBP-0xc) |
+----------------------------+------> 低地址
图 2-1
3. 小结
这次通过几个试验程序，进一步了解了局部变量在栈中的分配和释放以及位置，并再次回顾了上篇文章中涉及 到的以下概念：
SFP 栈框架指针
Stack aligned 栈对齐
并且，利用Solaris提供的mdb工 具，直观的观察到了栈在程序运行中的动态变化，以及Stack Frame的创建和撤销，根据给出 的图例的内容(图 2-1和图 1-1)，可以更清晰的了解IA32架构中栈在内存中的布局(Stack Layer)。
相关阅读 更多 +
