http://www.cnblogs.com/wangkangluo1/archive/2011/08/27/2155712.html
原文地址：http://blog.csdn.net/yayong/article/details/170842
X86汇编语言学习手记(1)
作者: Badcoffee
Email: blog.oliver@gmail.com
2004年10月
原文出处: http://blog.csdn.net/yayong
版权所有: 转载时请务必以超链接形式标明文章原始出处、作者信息及本声明
这是作者在学习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 $8,%esp
main+6: andl $0xf0,%esp
main+9: movl $0,%eax
main+0xe: subl %eax,%esp
main+0x10: movl $0,%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 $0
_start+2: pushl $0
_start+4: movl %esp,%ebp
_start+6: pushl %edx
_start+7: movl $0x80504b0,%eax
_start+0xc: testl %eax,%eax
_start+0xe: je +0xf <_start+0x1d>
_start+0x10: pushl $0x80504b0
_start+0x15: call -0x75 <atexit>
_start+0x1a: addl $4,%esp
_start+0x1d: movl $0x8060710,%eax
_start+0x22: testl %eax,%eax
_start+0x24: je +7 <_start+0x2b>
_start+0x26: call -0x86 <atexit>
_start+0x2b: pushl $0x80506cd
_start+0x30: call -0x90 <atexit>
_start+0x35: movl +8(%ebp),%eax
_start+0x38: leal +0x10(%ebp,%eax,4),%edx
_start+0x3c: movl %edx,0x8060804
_start+0x42: andl $0xf0,%esp
_start+0x45: subl $4,%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> ;在这里调用了main函数
_start+0x5d: addl $0xc,%esp
_start+0x60: pushl %eax
_start+0x61: call -0xa1 <exit>
_start+0x66: pushl $0
_start+0x68: movl $1,%eax
_start+0x6d: lcall $7,$0
_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 $8,%esp ; 通过ESP-8来分配8字节堆栈空间
main+6: andl $0xf0,%esp ; 使栈地址16字节对齐
main+9: movl $0,%eax ; 无意义
main+0xe: subl %eax,%esp ; 无意义
main+0x10: movl $0,%eax ; 设置main函数返回值
main+0x15: leave ; 撤销Stack Frame(栈框架)
main+0x16: ret ; main 函数返回
>
以下两句似乎是没有意义的，果真是这样吗？
movl $0,%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 $8,%esp
main+6: andl $0xf0,%esp
main+9: xorl %eax,%eax ; 设置main返回值，使用xorl异或指令来使eax为0
main+0xb: leave
main+0xc: ret
>
新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之前的猜测。
提示：编译器产生的某些语句可能在程序实际语义上没有用处，可以用优化选项去掉这些语句。
问题：为什么用xorl来设置eax的值？
注意到优化后的代码中，eax返回值的设置由 movl $0,%eax 变为 xorl %eax,%eax ，这是因为IA32指令中，xorl比movl有更高的运行速度。
概念：Stack aligned 栈对齐
那么，以下语句到底是和作用呢？
subl $8,%esp
andl $0xf0,%esp ; 通过andl使低4位为0，保证栈地址16字节对齐
表面来看，这条语句最直接的后果是使ESP的地址后4位为0，即16字节对齐，那么为什么这么做呢？
原来，IA32 系列CPU的一些指令分别在4、8、16字节对齐时会有更快的运行速度，因此gcc编译器为提高生成代码在IA32上的运行速度，默认对产生的代码进行16字节对齐
andl $0xf0,%esp 的意义很明显，那么 subl $8,%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 $0,%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 $0,%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语言高级调试技巧成为了可能。
完
原文地址：http://blog.csdn.net/yayong/article/details/236653
X86汇编语言学习手记(2)
作者: Badcoffee
Email: blog.oliver@gmail.com
2004年11月
原文出处: http://blog.csdn.net/yayong
版权所有: 转载时请务必以超链接形式标明文章原始出处、作者信息及本声明
这是作者在学习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 $8,%esp ; 为局部变量i,j分配栈空间，并保证栈16字节对齐
main+6: andl $0xf0,%esp
main+9: movl $0,%eax
main+0xe: subl %eax,%esp ; main+6至main+0xe，再次保证栈16字节对齐
main+0×10: movl $2,-8(%ebp) ; 初始化局部变量j的值为2
main+0×17: movl $3,-4(%ebp) ; 给局部变量i赋值为3
main+0×1e: leal -4(%ebp),%eax ; 将局部变量i的地址装入到EAX寄存器中
main+0×21: incl (%eax) ; i++
main+0×23: movl -8(%ebp),%eax ; 将j的值装入EAX
main+0×26: addl -4(%ebp),%eax ; i+j并将结果存入EAX，作为返回值
main+0×29: leave ; 撤销Stack Frame
main+0×2a: ret ; main函数返回
>
> main+0×10:b ; 在地址 main+0×10处设置断点
> main+0×1e:b ; 在main+0×1e设置断点
> main+0×29:b ; 在main+0×1e设置断点
> main+0×2a:b ; 在main+0×1e设置断点
下面的mdb的4个命令在一行输入，中间用分号间隔开，命令的含义在注释中给出：
> :r;<esp,10/nap;<ebp=X;<eax=X ; 运行程序(:r 命令)
mdb: stop at main+0×10 ; 以ESP寄存器为起始地址，指定格式输出16字节的栈内容(<esp,10/nap 命令)
mdb: target stopped at: ; 在最后输出EBP和EAX寄存器的值(<ebp=X 命令 和<eax=X 命令)
main+0×10: movl $2,-8(%ebp) ; 程序运行后在main +0×10处指令执行前中断，此时栈分配后还未初始化
0×8047db0:
0×8047db0: 0xddbebca0 ; 这是变量j，4字节，未初始化，此处为栈顶，ESP的值就是0×8047db0
0×8047db4: 0xddbe137f ; 这是变量i， 4字节，未初始化
0×8047db8: 0×8047dd8 ; 这是_start的SFP(_start的EBP),4字节，由main 的SFP指向它
0×8047dbc: _start+0×5d ; 这是_start调用main之前压栈的下条指令地址，main返回后将恢复给EIP
0×8047dc0: 1
0×8047dc4: 0×8047de4
0×8047dc8: 0×8047dec
0×8047dcc: _start+0×35
0×8047dd0: _fini
0×8047dd4: ld.so.1`atexit_fini
0×8047dd8: 0 ; _start的SFP指向的内容为0，证明_start是程序的入口
0×8047ddc: 0
0×8047de0: 1
0×8047de4: 0×8047eb4
0×8047de8: 0
0×8047dec: 0×8047eba
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+0×1e
mdb: target stopped at:
main+0×1e: leal -4(%ebp),%eax ; 程序运行到断点main+0×1e处停止，此时局部变量i,j赋值已完成
0×8047db0:
0×8047db0: 2 ; 这是变量j，4字节，值为2，此处为栈顶，ESP的值就是0×8047db0
0×8047db4: 3 ; 这是变量i，4字节，值为3
0×8047db8: 0×8047dd8 ; 这是_start的SFP，4字节
0×8047dbc: _start+0×5d ; 这是返回_start后的EIP
0×8047dc0: 1
0×8047dc4: 0×8047de4
0×8047dc8: 0×8047dec
0×8047dcc: _start+0×35
0×8047dd0: _fini
0×8047dd4: ld.so.1`atexit_fini
0×8047dd8: 0
0×8047ddc: 0
0×8047de0: 1
0×8047de4: 0×8047eb4
0×8047de8: 0
0×8047dec: 0×8047eba
8047db8 ; 这是main当前EBP寄存器的值，即main的SFP
0 ; EAX的值，当前为0
> :c;<esp,10/nap;<ebp=X;<eax=X ; 继续运行程序，打印16字节栈和EBP,EAX内容
mdb: stop at main+0×29
mdb: target stopped at:
main+0×29: leave ; 运行到断点main+0×29处停止，计算已经完成，即将撤销Stack Frame
0×8047db0:
0×8047db0: 2 ; 这是变量j，4字节，值为2，此处为栈顶，ESP的值就是0×8047db0
0×8047db4: 4 ; 这是i++以后的变量i，4字节，值为3
0×8047db8: 0×8047dd8 ; 这是_start的SFP，4字节
0×8047dbc: _start+0×5d ; 这是返回_start后的EIP
0×8047dc0: 1
0×8047dc4: 0×8047de4
0×8047dc8: 0×8047dec
0×8047dcc: _start+0×35
0×8047dd0: _fini
0×8047dd4: ld.so.1`atexit_fini
0×8047dd8: 0
0×8047ddc: 0
0×8047de0: 1
0×8047de4: 0×8047eb4
0×8047de8: 0
0×8047dec: 0×8047eba
8047db8 ; 这是main当前EBP寄存器的值，即main的SFP
6 ; EAX的值，即函数的返回值，当前为6
> :c;<esp,10/nap;<ebp=X;<eax=X ; 继续运行程序，打印16字节栈和EBP,EAX内容
mdb: stop at main+0×2a
mdb: target stopped at:
main+0×2a: ret ; 运行到断点main+0×2a处停止，Stack Frame已被撤销，main即将返回
0×8047dbc:
0×8047dbc: _start+0×5d ; Stack Frame已经被撤销，栈顶是返回_start后的EIP，main的栈已被释放
0×8047dc0: 1
0×8047dc4: 0×8047de4
0×8047dc8: 0×8047dec
0×8047dcc: _start+0×35
0×8047dd0: _fini
0×8047dd4: ld.so.1`atexit_fini
0×8047dd8: 0
0×8047ddc: 0
0×8047de0: 1
0×8047de4: 0×8047eb4
0×8047de8: 0
0×8047dec: 0×8047eba
0×8047df0: 0×8047ed6
0×8047df4: 0×8047edd
0×8047df8: 0×8047ee4
8047dd8 ; _start的SFP,之前存储在地址0×8047db8处，main的Stack Frame撤销时恢复 6 ; EAX的值，即函数的返回值，当前为6
> :s;<esp,10/nap;<ebp=X;<eax=X ; 单步执行下条指令(:s 命令)，打印16字节栈和EBP,EAX内容
mdb: target stopped at:
_start+0×5d: addl $0xc,%esp ; 此时main已经返回，_start+0×5d曾经存储在地址0×8047dbc处
0×8047dc0:
0×8047dc0: 1 ; main已经返回，_start +0×5d已经被弹出
0×8047dc4: 0×8047de4
0×8047dc8: 0×8047dec
0×8047dcc: _start+0×35
0×8047dd0: _fini
0×8047dd4: ld.so.1`atexit_fini
0×8047dd8: 0 ; _start的SFP指向的内容为0，证明_start是程序的入口
0×8047ddc: 0
0×8047de0: 1
0×8047de4: 0×8047eb4
0×8047de8: 0
0×8047dec: 0×8047eba
0×8047df0: 0×8047ed6
0×8047df4: 0×8047edd
0×8047df8: 0×8047ee4
0×8047dfc: 0×8047ef3
8047dd8 ; _start的SFP,之前存储在地址0×8047db8处，main的Stack Frame撤销时恢复
6 ; EAX的值为6，还是main函数的返回值
>
通过mdb对程序运行时的寄存器和栈的观察和分析，可以得出局部变量在栈中的访问和分配及释放方式：
1.局部变量的分配，可以通过esp减去所需字节数
subl $8,%esp
2.局部变量的释放，可以通过leave指令
leave
3.局部变量的访问，可以通过ebp减去偏移量
movl -8(%ebp),%eax
addl -4(%ebp),%eax
问题：当存在2个以上的局部变量时，如何进行栈对齐？
在上篇文章中，提到subl $8,%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 $0×18,%esp ; 为局部变量i,j,k分配栈空间，并保证栈16字节对齐
main+6: andl $0xf0,%esp
main+9: movl $0,%eax
main+0xe: subl %eax,%esp ; main+6至main+0xe，再次保证栈16字节对齐
main+0×10: movl $2,-8(%ebp) ; j=2
main+0×17: movl $4,-0xc(%ebp) ; k=4
main+0×1e: movl $3,-4(%ebp) ; i=3
main+0×25: leal -4(%ebp),%eax ; 将i的地址装入到EAX
main+0×28: incl (%eax) ; i++
main+0×2a: movl -8(%ebp),%eax ; 将j的值装入到 EAX
main+0×2d: movl -4(%ebp),%edx ; 将i的值装入到 EDX
main+0×30: addl %eax,%edx ; j+i，结果存入EDX
main+0×32: leal -0xc(%ebp),%eax ; 将k的地址装入到EAX
main+0×35: addl %edx,(%eax) ; i+j+k，结果存入地址ebp-0xc即k中
main+0×37: movl -0xc(%ebp),%eax ; 将k的值装入EAX，作为返回值
main+0×3a: leave ; 撤销Stack Frame
main+0×3b: ret ; main函数返回
>
问题：为什么3个变量分配了0×18字节的栈空间？
在2个变量的时候，分配栈空间的指令是：subl $8,%esp
而在3个局部变量的时候，分配栈空间的指令是：subl $0×18,%esp
3个整型变量只需要0xc字节，为何实际上分配了0×18字节呢？
答案就是：保持16字节栈对齐。
在X86 汇编语言学习手记(1)里，已经说明过gcc默认的编译是要16字节栈对齐的，subl $8,%esp会使栈16字节对齐，而8字节空间只能满足2个局部变量，如果再分配4字节满足第3个局部变量的话，那栈地址就不再16字节对齐的，而同时满足空间需要而且保持16字节栈对齐的最接近的就是0×18。
如果，各定义一个50字节和100字节的字符数组，在这种情况下，实际分配多少栈空间呢？答案是0×8+0×40+0×70，即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 $0xb8,%esp ; 为两个字符数组分配栈空间，同时保证16字节对齐
main+9: andl $0xf0,%esp
main+0xc: movl $0,%eax
main+0×11: subl %eax,%esp
main+0×13: movl $0,%eax
main+0×18: leave
main+0×19: ret
> 0xb8=D ; 16进制换算10进制
184
> 0×40+0×70+0×8=X ; 表达式计算，结果指定为16进制
b8
>
问题：定义了多个局部变量时，栈分配顺序是怎样的？
局部变量栈分配的顺序是按照变量声明先后的顺序，同一行声明的变量是按照从左到右的顺序入栈的，在test2.c中，变量声明如下：
int i, j=2, k=4;
而反汇编的结果中：
movl $2,-8(%ebp) ; j=2
movl $4,-0xc(%ebp) ; k=4
movl $3,-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)。
完