程序的机器级表示

最新推荐文章于 2023-06-01 23:05:27 发布

mathZHA

最新推荐文章于 2023-06-01 23:05:27 发布

阅读量5.5k

点赞数

分类专栏： C

C 专栏收录该内容

58 篇文章 0 订阅

订阅专栏

原文在文章1点击打开链接，文章2点击打开链接，还有文章3点击打开链接。（学渣从前天开始看深入理解计算机系统，作为数学党想了解一点计算机知识的框架，此外豆瓣的书评在这里->点击这里打开链接。看到第三章有这么一句：传递指令的两个操作数不能都指向存储器位置，不懂，就搜搜了发现几篇文章，先复制过来，留着慢慢看）。

文章1

x86主要寄存器

程序计数器(32位,%eip)：PC
整数寄存器/通用寄存器(32位,8个，%eax,%ebx,%ecx,%edx,%esi,%edi,%ebp,%esp)：存储地址(C指针)或整数数据。有的存储程序重要状态，%esp栈指针(栈顶)，%ebp帧指针(当前帧底)。
条件码寄存器(32位, EFLAGS)：状态标志，控制标志和系统标志。
段寄存器(16位, 6个)
浮点寄存器(8个,%st(0-7))：存储浮点数据
其它寄存器包括：控制寄存器(CR0-CR4),GDTR,IDTR,TR,LDTR,调试寄存器(DR0-DR7),内存类型范围寄存器MTRR,MSR,MCR,PMC等等。

通用寄存器

寄存器	用途
%eax	操作数运算
%ebx	指向DS段中数据的指针
%ecx	字符串操作和循环计数器
%edx	输入输出指针
%esi	指向DS段中数据的指针或字符串操作中字符串的复制源
%edi	指向ES段中数据的指针或字符串操作中字符串的复制地
%esp	栈指针(SS段)
%ebp	指向SS段上数据的指针

段寄存器

寄存器	用途
CS	代码段
DS	数据段
SS	堆栈段
ES	数据段
FS	数据段
GS	数据段

C类型长度

C类型	Intel数据类型	GAS后缀	32位大小	64位大小
char	byte	b	1	1
short	word	w	2	2
int	double-word	l	4	4
unsigned	double-word	l	4	4
long int	-	l	4	8
unsigned long	-	l	4	8
char*	double-word	l	4	8
float	single precision	s	4	4
double	double precision	l	8	8
long double	extended precision	t	12	16

浮点数与整数使用不同的一组指令和寄存器。

指令的操作数

立即数：$整数
寄存器：%寄存器
存储器：各种寻址模式

传送指令

传送指令movb, movw, movl

传送指令的两个操作数不能都指向存储器位置。

局部变量和临时变量尽可能保存在寄存器中，而不是存储器中。

函数调用

保存：返回地址、寄存器（%eax,%edx,%ecx调用者保存，%ebx,%esi,%edi被调用者保存，%ebp,%esp被调用者保存）
申请：局部变量、临时变量（匿名变量）

对齐

对齐：为了提高存储性能，对象的地址必须是某个值(通常是2,4,8)的倍数。

Linux的对齐策略是2字节数据类型(short)的地址必须是2的倍数。而较大数据类型(如int,int*,float,double)的地址必须是4的倍数。

Windows要求更严格：任何k字节的基本对象的地址都必须是k的倍数。

注意编译器可能在结构末尾添加一些填充使整个结构对齐。这利于定义结构类型数组。

缓冲区溢出(buffer overflow)

由于C语言对数组不进行越界检查，因此分配在栈中的数组和其它局部变量、状态信息临近排列。如果写入这个数组可能超出数组长度，写入到状态信息里，导致程序返回到错误地址，因而产生缓冲区溢出。更厉害的是通过字符串传入漏洞入侵代码(exploit code)，然后通过缓冲区溢出，执行那段代码。

文章2

1 从Hello world说起

Hello world是初学者使用任何一项编程语言最基本最简单的程序。下面是一个C语言版的"Helloworld" :

#include <stdio.h>
int main(){
	printf("Hello wolrd\n");
    return 0;
}

这段程序被编译、链接后会生成一个可执行文件，在操作系统中运行这个程序，屏幕会输出"Hello world"。在输出结果的背后，它究竟做了怎样的工作，比如C程序是如何执行的、C程序是如何加载到内存中、它又是如何输出到屏幕上的？这里既涉及到了C语言程序的执行过程，又涉及到了与操作系统交互的行为。这篇文章，我们将主要从编译器GCC的角度看C语言程序的执行过程。

gcc编译器并不是一个单一庞大的编译器，通常它是由多达六七个稍小的程序所组成，这些程序是由一个叫编译器驱动程序来调用。从宏观角度讲编译器有以下几个可分离出来的单独程序，包括：预处理器(preprocessor)、编译器(compiler,又分为两个部分：前端，进行语法和语义解析，生成一抽象语法树；后端，进行代码生成和相关的代码优化)、汇编器(assembler)、链接器(linker)

假设源程序文件名为hello.c,图1是gcc编译器运行hello.c源程序的执行过程：

下面我们以讲解gcc基本用法Usage: gcc [options] [filename] 来简略描述hello.c的运行过程

1.选项 -E : 预编译过程,处理宏定义和include，并作语法检查

gcc -E hello.c -o hello.i              #将hello.c预处理输出为hello.i文件

2.选项 -S : 编译过程,生成通用的汇编代码

gcc -S hello.c                         #生成汇编代码hello.s

3.选项 -c : 汇编过程,生成ELF格式的可重定位目标文件，目标文件(机器代码,)，用文本编辑器打开是乱码

gcc -c hello.c                         #生成目标代码hello.o(中间文件)，不能执行，在Makefile中应用广泛

4.选项 -L : 链接过程,将.o文件与所需库文件链接合并成ELF格式的可执行目标文件，分静态链接和动态链接

gcc hello.o -L dir(如./lib)            #指定库搜索路径，有多个则从前往后搜索

5.选项 -l : 链接过程,指定链接库，库命名规则是libxxx.a,指定库名时使用的格式是-lxxx

gcc hello.c -o hello -lm              #链接数学库
ld -o hello hello.o -lxxx             #链接xxx库

6.选项 -o : 将源文件预处理、编译、汇编并链接形成可执行目标文件，-o选项指定可执行文件的文件名，加载到内存中即可执行

gcc hello.c -o hello                  #生成可执行文件hello

7.部分选项：
选项 -Wall : 编译时打开警告信息开关
选项 -D : 在文件中定义宏INFO，编译时加上-D INFO使其生效
选项 -O : 后指定数字，使用编译优化级别1~3优化程序
选项 -g : 产生调试信息

8.选项 -static : 使用静态链接库，将使用的静态库对象嵌入至可执行映像文件中，加载时无需进一步的链接

gcc -c -Wall x1.c x2.c       #生成目标文件
ar -cru libxxx.a x1.o x2.o   #创建静态库
#定义静态库的应用接口xxx.h，里面显式引用上面的源文件函数和对象
gcc -O2 -c main.c            #测试用例调用静态库的函数
gcc -static -o p main.o ./libxxx.a  #链接静态库和目标文件生成可执行文件p

9.选项 -share : 使用共享库，在运行时动态加载目标程序所需要的信息
选项 -fPIC : 指示编译器生成与地址无关的目标文件(position-independent code)

gcc -shared -fPIC -o libxxx.so x1.c x2.c  #生成共享库libvector.so
gcc -o p1 main.c ./libvector.so           #共享库中的目标对象并未嵌入可执行文件中，执行时完成链接过程

最后由链接器ld合并到的可执行文件hello就可被加载到内存中，由系统执行。下面就具体来介绍程序执行时经历的各个过程

2 编译阶段：C程序的机器级表示

2.1 数据的表示、C代码和机器级代码的联系

A. 数据表示
对于C语言来说，它支持整型数据、浮点数据等多种采取不同编码方式的数据类型。从机器角度看，他们又是一样的，均表示为一个连续的字节序列。

根据机器的不同，数据使用的字节顺序也有所不同：

小端法：最低有效字节存储在所用字节中的最低地址。随着地址的增大，它在存储器中按照最低字节到最高字节的顺序进行存储。绝大部分Intel兼容机都是采用小端法，如Linux的IA32和x86-64机器，Windows的IA32机器
大端法：最高有效字节存储在所用字节中的最低地址。随着地址的增大，它在存储器中按照最高字节到最低字节的顺序进行存储。大多数IBM和Sun机器采用大端法，如运行Solaris的Sun Sparc处理器

下面是一段C代码，它使用强制类型转换来访问和打印不同数据对象的字节表示，byte_p表示一个指向无符号字符对象的指针，即一个字节指针引用一个字节序列。可用它来测试你的机器中类型为int、float、void *的对象字节表示和字节顺序，程序如下：

#include <stdio.h>

typedef unsigned char *byte_p;

void show_bytes(byte_p start,int len){
	for(int i=0;i < len;i++)
		printf(" %.2x",start[i]);
	printf("\n");
}

void show_int(int x){
	show_bytes((byte_p) &x,sizeof(int));
}

void show_float(float x){
	show_bytes((byte_p) &x,sizeof(float));
}

void show_pointer(void *x){
	show_bytes((byte_p) &x,sizeof(void *));
}

void test3(){
	int val=0x87654321;

	byte_p valp=(byte_p)&val;
	show_bytes(valp,4);
	show_int(val);

	float val1=0x4A564504; //3510593
	show_float(val);

    printf(" %p\n",&val);
	show_pointer(&val);

	/**
	 * 21 43 65 87
     　　* 21 43 65 87
     　　* 7a 35 f1 ce
     　　* 0x7fffb73c3d58
     　　* 58 3d 3c b7 ff 7f 00 00
	 */
}

int main(){
    test3();
	//小端法：21 43 65 87(低地址低字节序列)
	//大端法：87 65 43 21(低地址高字节序列)
	return 0;
}

B. C代码和机器级代码的联系
利用gcc编译一个C程序code.c以汇编代码的形式输出，如果使用-c选项它将会生成目标代码文件。

//code.c
int accum=0；
int sum(int x,int y){
	int t=x+y;
	accum+=t；
	return t；
}

利用Objdump反汇编器工具我们可以查看目标代码文件的内容，它产生的是一种类似于汇编代码的格式。OBJDUMP是所有二进制工具之母，它能够显示任何一个目标文件中的信息(三种形式的目标文件均可)-　objdump -d code.o，如下：

可看出IA32的机器代码和原始C代码差别是很大的，但是我们还是需要学习C程序的机器级表示呢？因为

相比二进制格式的机器级代码，汇编代码可读性更好，它是机器代码的文本表示，给出了程序中的每条指令。理解汇编代码和原始C代码的联系，是理解计算机如何执行程序的关键一步。
阅读汇编代码，有助于我们理解编译器的优化能力，并分析代码中的低效率。
注：编译器如果使用更高的优化级别优化程序，它可能会使产生的代码严重改变形式，比如快速操作代替慢速操作，递归计算变成迭代计算，对应关系就不太容易理解。
理解汇编代码，有助于我们了解程序运行时行为的信息。
我们会了解程序如何将数据存储在不同的存储器区域中，例如我们需要知道一个变量是否在运行时栈中，还是动态分配的堆中，还是全局区域中。
知道程序是如何映射到机器上是很重要的；再例如从这些机器表示中我们就能理解存储器访问越界是如何产生的，为什么蠕虫和病毒能够利用这些漏洞信息获得程序的控制权，以及出现了这种问题我们该如何防御它
高级语言的代码隐藏了程序的具体运行过程，而机器通过指令集体系结构和虚拟地址的实现屏蔽了程序的细节。它能在机器上运行实际上是一系列机器代码指令的执行序列。学习程序的机器级表示是连接高级语言与机器指令执行的桥梁。它有助于我们通过研究系统的逆向工程真正了解程序运行时的创建过程

再次强调，C语言提供了一种模型，可以在存储器中声明和分配各种数据类型的对象，但汇编代码中它只是简单地将存储器看成一个很大的、按字节寻址的序列，不区分有符号数和无符号数，不区分各种类型的指针。下面我们从汇编代码的角度描述C语言各种数据、结构等的表示，主要有以下几类：

数据的汇编表示和处理
机器级程序如何实现控制结构(if,else,while,switch语句)
机器级程序如何维护一个运行时栈来控制过程间数据和控制的传递及存储
机器级程序如何表示像数据、结构和联合这样的数据结构

C. AT&T汇编代码格式
这里所采用的是AT&T格式的汇编代码，它也是GCC、OBJDUMP和其他一些我们常用工具的默认格式。其他的诸如Microsoft的工具采用的是Intel的形式。它们之间所有所不同，一般地：

AT&T代码不能省略指示大小的后缀，比如指令movl(在利用反汇编器它省略了后缀指示符)
AT&T代码不能省略寄存器前面的'%'符号，比如%esp
AT&T代码用诸如8(%ebp)描述存储器中位置，并且在涉及多个操作数的指令情况下，源操作数在前面，目的操作数在后面

2.2 数据访问、传送和算术运算

我们第一个要关心的就是C语言数据类型对应的IA32是如何表示的。假定16位表示一个字，32位数成为双字，64位称为四字。下面是C语言数据类型在IA32中的大小：

C声明	汇编代码后缀	大小(字节)
char	b- 字节	1
short	w- 字	2
int	l- 双字	4
long	l- 双字	4
long long	-	8
void *	l- 双字	4
float	s- 单精度	4
double	l- 双精度	8
long double	t- 扩展精度	10/12

C语言对于机器来说它们则是统一连续的字节序列。我们关注C语言的数据类型，如何区分不同的数据类型，实际上就是关注机器如何存储字节的方式-寻址模式

2.2.1 寻址模式与数据访问

通常为了快速访问和存储数据，IA32 CPU中央处理单元会提供一组8个存储32位的整数寄存器。名字以%e开头，一般来说前6个寄存器都可堪称通用寄存器，它的使用没有限制。

注意：

这组IA32整数寄存器，有些可以存储C语言中的指针和整数数据，有些用来记录某些重要的程序状态，而有些用来保存临时数据如局部变量和函数的返回值
所有的8个寄存器都可以作为一个字(16位)或32个字(双字)来访问。并且可以独立访问前4个寄存器的两个低位字节
过程处理中%eax %ecx %edx的保存和恢复不同于接下来的三个寄存器%ebx %esi %edi
堆栈管理中%ebp表示帧指针，%esp表示栈指针。运行时，栈指针可以移动，因而信息的访问都是相对于帧指针的

在机器指令中这些存储的数据通常称为操作数，它指出执行一个操作中要引用的源数据值，以及放置结果的目标位置。源数据值可以以立即数或从寄存器或存储器中读出，结果可以存放在寄存器或存储器中。

操作数有三种类型：

立即数: 书写方式为$0xFF
寄存器：用来表示寄存器的内容。用 Ea 表示任意寄存器 a ,用引用 R[Ea] 表示其内容。
存储器引用：根据计算出来的有效存储器地址，访问某存储器位置。用 M[Addr] 表示对存储在存储器地址Addr开始的b个字节值的引用

下面是不同的数据寻址模式，它允许不同形式的存储器引用。 Imm(Eb，Ei,s) 是最常见的组成部分，它表示一个立即数偏移 Imm ，一个基址寄存器 Eb ，一个变址寄存器 Ei 和一个比例因子 s ,它的有效地址则表示为 Imm+R[Eb]+R[Ei]∗s 。如下图

寻址模式

2.2.2 数据传送命令

数据传送指令主要是由MOV类指定完成，根据操作数的大小不同，把它分成: movb、movw、movl 。

MOV类的指令是将源操作数的值复制到目的操作数中。其中源操作数指定的值要么是一个立即数，要么是存储在寄存器或存储器中，目的操作数指定一个位置，要么是一个寄存器，要么是一个存储器地址。

注意传送指令的两个操作数不能都指向存储器位置，将一个值从一个存储器位置复制到另一个存储器位置需要两条指令-第一条指令由源值加载到寄存器中，第二条将该寄存器写入目的存储器位置中。

如下几个实例(第一个是源操作数，第二个是目的操作数)：

movl $0x4050 %eax     // 立即数的内容存储到寄存器%eax中，4个字节
movl $-17,(%esp)      // 立即数的内容到存储器中，4个字节
movw %bp,%sp          // 寄存器的内容复制到另一个寄存器中，2个字节
movl %eax,-12(%ebp)   // 寄存器的内容到存储器中，4个字节
movb (%edi,%ecx)，%ah // 存储器的内容到寄存器中，1个字节

有两个数据传送操作需要重点说明下- 一将数据压入程序栈中，二从程序栈中弹出数据。

在IA32中，程序栈放在存储器某区域一端插入和删除元素，栈向下增长，因而栈顶元素是所有栈中元素地址最低的，栈指针%esp保存着栈顶元素的地址。其中pushl指令的功能是把数据压入到栈中，而popl指令是弹出数据，均只有一个操作数-压入的数据源和弹出的数据目的。

压栈：栈指针-4,再将值写到新的栈顶地址。
pushl %ebp的行为等价于以下两条指令。它们区别在于pushl指令编码为1个字节，而上面两条指令一共6个字节

subl $4,%esp         栈指针减去4，压栈
movl %ebp,(%esp)     把帧指针的内容存在栈%esp的位置上

出栈：从栈顶位置读出数据，并将指针值加4。
popl %eax等价于以下两条指令。

movl (%esp),%eax  从存储器中读出数据再写到寄存器%eax中
addl $4,%esp      寄存器%esp的值增加4

总之无论如何，%esp指向的地址总是指向栈顶，任何存储在栈顶之外的数据都被认为是无效的。

下面举一个例子：元素交换操作

在理解目标文件的代码段之前首先需要了解几点：

注意区分代码中数据传送命令的源操作数和目的操作数。寄存器还是存储器引用还是立即数
过程调用的汇编代码格式通常比较固定：保存旧的帧指针，再把栈指针当作帧指针来使用，相对于栈指针位置配一定大小的内存，执行函数的代码操作，栈做好返回的准备最后退出当前栈
过程调用中不建议直接使用相对于%ebp的参数和临时变量做数据运算，而是利用寄存器%eax %edx %ecx保存参数和临时变量来操作
C语言中的指针其实就是地址，间接引用指针实际上是将指针放在存储器中，然后在存储器引用使用这个寄存器(所以必须掌握数据传送的寻址模式)。再次看出C语言中各种数据类型表示在汇编代码中是没有区别的，不同的是数据的寻址模式不一样决定了它具体的表示意义，是读还是写，是指针(地址引用)还是基本数据类型。

如下是对这段汇编代码的注释:


push %ebp            //保存旧帧指针
mov  %esp,%ebp       //旧的栈指针作为新的帧指针
sub  $0x10，%esp     //在栈上分配16(0x10)字节内存

mov 0x8(%ebp),%eax   //从存储器(%ebp+8)中读出参数x(实际为地址)，存在寄存器%eax中
mov (%eax),%eax      //存储器引用该寄存器，取出该地址的内容*x，存在%eax中
mov %eax,-0x4(%ebp)  //将寄存器%eax的内容写入到存储器(%ebp-4)的位置中 temp=*x

mov 0xc(%ebp),%eax
mov (%eax),%edx      //这两步和前面类似，将第二个参数y(%ebp+12)存到%eax，并把其内容加载到寄存器%edx中
mov 0x8(%ebp),%eax
mov %edx,(%eax)      //将地址y的内容%edx赋值给地址x对应的存储器(%eax)中 *x=*y

mov 0xc(%ebp),%eax
mov -0x4(%ebp),%edx
mov %edx,(%eax)      //这三步分别取出y,temp然后再赋值 *y=temp

leave
ret

2.2.3 算术和逻辑操作

如下图为一些整数和逻辑操作，给出的每个指令类都有对字节、字和双字数据进行操作的指令，如ADD类指令有addb addw addl 。通常这些操作分为四组：加载有效地址、一元和二元操作、移位。

A. 加载有效地址
加载有效地址指令leal的形式是从存储器读取数据到寄存器，实际上它并没有引用存储器，它并不从指定的位置读取数据，而是将有效地址写入目的操作数中，同时它也能简洁描述普通的算术操作。

例如：

leal 7(%edx,%edx,4)，%eax   //设置存储器%eax的值为5x+7，%edx的值为x
leal 6(%edx)，%eax          //设置存储器%eax的值为x+6

B. 一元和二元操作
一元操作，只有一个操作数，既是源又是目的。该操作数可以是一个寄存器，也可以是一个存储器位置。有自增、自减、取负、取补运算，类似于C语言中的++和--运算符

二元操作，第二个操作数既是源又是目的。第一个操作数可以是立即数、寄存器或存储器位置，第二个操作数可以是寄存器或者存储器位置，不过两个操作数不能同时是存储器位置(需要两条指令)。例如：

subl %eax,%edx     //从寄存器%edx中减去%eax中
addl %ecx，4(%eax) //从寄存器%eax+4中加上%ecx中

C. 移位操作
这一组是移位操作，第一项是给出移位量，可以是立即数或者单字节寄存器，第二项给出的是要移位的数值，可以是寄存器或者存储器位置。

左移指令有两个名字SAL SHL，效果都一样，都是将右边填上0。右移指令不同，SAR执行算术移位(填上符号位)，SHR执行逻辑移位(填上0)。例如：

sall $2,%eax   // x << =n
sarl %c1,%eax  // x >> =n
xorl %edx,%edx //等价于movl $0,%edx，但它只需要2个字节，movl需要5个字节编码

2.3 C语言控制结构的汇编表示

在C语言中有提供这样的结构：条件语句、循环语句和分支语句。那么在机器级指令中提供怎样的机制来实现C语言控制结构的行为。它的主要思路是借助条件码寄存器和跳转指令来实现有条件的行为。

现代计算机中实现条件操作有两种方法：利用控制的条件转移和数据的条件转移。数据的条件转移更好地匹配了现代处理器的性能特性，但这里主要讲述控制的条件转移这种传统方法。

2.3.1 条件码和跳转指令

CPU除了提供上面的几个整数寄存器外，还维护着一组单个比特位的条件码，描述最近的算术或逻辑操作特性，用于执行条件分支指令。

CF：进位标志，表示最近的操作使最高位产生了进位。用于检查无符号操作数的溢出
ZF：零标志，表示最近的操作得出的结果为0
SF：符号标志，表示最近的操作得出的结果为负数
OF：溢出标志，表示最近的操作使补码溢出-正溢出或负溢出

有几种设置条件码的情形
A. 比较和测试指令：它们只设置条件码而不改变任何其他寄存器

cmp S2,S1 通过S1-S2的结果，比较两者的大小
test S2,S1 通过S1&S2的结果(按位与)，比如testl %eax,%eax用来检查%eax是正数，负数还是0或者其中一个操作数是掩码，用来指示哪些位应该被测试

B. 根据条件码的组合，使用set指令，不同后缀名表示不同条件

set指令的目的操作数是8个单字节寄存器或者存储一个字节的存储器位置，把该字节位置设置成0或1。它的基本思路是执行比较或测试指令，根据set指令的类型决定计算结果t=a-b：操作数的大小，是有符号的还是无符号的，程序值的数据类型。如图所示为set指令的常见情形

例如
sete表示相等时设置(set when equal)指令, 因而a=b,t=0,则置ZF位就表示相等。

setl表示当小于时设置(set when less)指令，测试一个有符号比较。假设没有发生溢出，OF位设置为0，即a < b时t为负数，SF位置为1；发生溢出，什么情形下满足a < b呢，则只有产生负溢出时，即t > 0此时OF位为1，SF为0。结合溢出位和符号位，使用异或操作SF^OF才能提供a < b是否为真的测试

seta表示当大于时设置指令测试一个无符号比较。当t=a-b>0时CF位置为０(无符号的)，ZF位为0,使用~CF &~ZF

通过cmp和test比较的操作数长度决定是何种类型，再结合set指令，判断是无符号还是有符号的。例如

cmpl %eax,%edx
setne %al #由1得知是32位数的比较，由2得知是比较两个数是否不等。判断要么是无符号int或者int比较

testw %ax,%ax
sete %al #一个16位数是否为０，两个字节的类型可用short或者unsigned short

C. 跳转指令：无条件的和有条件的
所谓跳转指令是指程序执行时切换到程序中的一个带有标号的地址。跳转指令又分无条件跳转(直接跳转、间接跳转)、有条件跳转

直接跳转中，直接选择一个跳转目标，写法为".L1";间接跳转中，跳转目标是从寄存器或者存储器位置中读出的，写法为"＼*＋操作数指示符"，如jmp *eax,用寄存器％eax的值作为跳转目标。有条件的跳转指令通常是根据条件码的某个组合，或者跳转或者继续执行代码中的下一条指令，与set指令向匹配。注意：条件跳转只能是直接跳转！

我们并不是要取掌握这些跳转指令，而是要理解跳转指令的目标如何编码，特别是要掌握PC相关的编码方式。它们会将目标指令的地址与紧跟在跳转指令后面那条指令的地址之间的差作为编码，地址偏移量一般为1/2/4个字节。

如下是一个与PC相关的寻址例子，它含两个跳转：第1行的jle指令指向更高的地址，第8行的jg指令指向更低的地址。如图所示：

分析：由Objdump得到的反汇编版本。可知第1行的跳转目标指明为0x17,对应的目标编码为0xd;第7行的跳转指标指明为0xa,对应的目标编码为0xf3。并且通过计算观察到第1行跳转指令的下一个指令地址0x17=0xd+0xa,第7行跳转指令的下一个指令地址0xa=0xf3+0x17。

可以看出来执行PC相对的寻址时，程序计数器的值是跳转指令后面的那条指令的地址，而不是跳转指令本身的地址(缘由：当时的处理器以更新计数器作为执行一条指令第一步)。

并且如果对目标文件链接后进行程序反汇编，依然可以看到1和7行跳转目标的编码始终没有变。优点显而易见，使用与PC相关的跳转目标编码，指令编码很简洁，目标代码无需做任何改变直接移到存储器不同位置。如图：

接下来几个小节，我们将使用各种类型的跳转指令来实现C语言的控制结构。从最基础的分支语句，再到循环和switch语句。

2.3.2 条件语句的翻译-if-else

C语言的if-else语句的通用形式模板：

if(test-expr)
	then-statement
else
	else-statement

对于这种通用形式，汇编实现一般采用如下插入条件(else-statement)和无条件分支(if-statement)的形式，保证执行正确的代码块。用C语法来描述控制流：

t=test-expr;
if(!t)
	goto false;
then-statment;
goto done;
false:
	else-statement
done:

因而对于C语言的if-else语句，需要创建一个goto版本的紧密遵循汇编代码控制流的等价语句(为了方便构造汇编代码)。基本思路是：首先比较了两个操作数(第3行),设置条件码。如果比较的结果表明x大于等于y，则它会跳转到计算x-y的代码块，否则继续执行计算y-x的代码。如下图所示一个计算两数之差的绝对值函数的C代码和汇编代码。

2.3.3 循环语句的翻译-do-while、while、for

C语言中提供了3种循环结构，如do-while、while、for。在汇编代码中，绝大多数都可以用条件测试和跳转组合结合起来实现循环的效果。并且大多数汇编器都是根据一个循环的do-while形式来产生循环代码(尽管实际中用的很少),其他的循环都是借助do-while形式再编译成机器代码。下面就从do-while循环开始研究

do-while循环

do-while语句的通用形式模板：

do
	body-statement
while (test-expr);

对于这种通用形式，用C语法的goto语句来描述控制流：

loop:
	body-statement
	t=test-expr;
	if(t)
		goto loop;

也就是说每次循环，程序都会先执行body-statement,然后再对test-expr表达式求值，如果测试为真，回去继续执行循环，可看到body-statement至少执行一次。

如下图所示用do-while循环来计算函数参数的阶乘：

思路比较明确，寄存器%edx保存参数n,%eax保存result。程序开始执行循环(.L2),先执行循环的主体，然后再测试n > 1,如果为真，条件跳转重复执行循环(第7行的跳转指令是实现循环的关键)，否则退出循环返回结果。我们可以看到寄存器%eax通常用来返回函数的值，所以常常选它存放要返回的程序值。

通过描述fact_do的过程，我们学习到一个逆向工程循环的基本策略：如何由汇编代码找到和原始代码的对应关系，核心是找到程序值和寄存器之间的映射关系。看看在循环前如何初始化寄存器，在循环中如何更新和测试寄存器以及在循环后又如何使用寄存器，把它组合起来就能打开C语言隐秘bug后的大门了。(注：GCC常会做一些寄存器优化的变换，更不易观察出来)

while循环

while语句的通用形式模板：

while (test-expr)
	body-statement

对于这种通用形式，用C语法的goto语句来描述控制流：

t=test-expr;
if(!t)
	goto done;
loop:
	body-statement
	t=test-expr;
	if(t)
		goto loop;
done:

和do-while不同的是它首先要对test-expr求值，第一次执行body时，循环就有可能终止。因而GCC常用的策略是使用条件分支，并且在需要时优化最开始的测试，省略循环的第一次执行，从而转换成do-while循环。

如下图所示用while循环来实现阶乘函数：

比较fact_while和fact_do的代码，它们几乎是相同的。唯一的不同点就是初始的测试和循环的跳转(第3/4行)

for循环

for循环语句的通用形式模板：

for(init-expr;test-expr;update-expr)
	body-statement

对于这种通用形式，用C语法的goto语句来描述控制流：

init-expr;
t=test-expr;
if(!t)
	goto done;
loop:
	body-statement
	update-texpr;
	t=test-expr;
	if(t)
		goto loop;
done:

它的基本步骤是首先对初始表达式init-expr求值，然后进入循环；在循环中先对测试条件test-expr求值，为假则退出，否则执行循环体body-statement,最后再更新表达式。

如下所示为for循环写的阶乘函数：

int fact_for(int n){
	int i;
	int result=1;
	for(i=2;i < =n;i++)
		result *=i;
	return result;
}

它对应的汇编代码如下所示。

2.3.4 多重分支语句的翻译-switch

switch语句是一个具有多种可能结果的分支语句，它不仅提高了C代码的可读性，而且通过使用跳转表(jump table)数据结构使得实现更为高效。

所谓跳转表实际上是一个指针数组，每个元素都是一个指向代码段的指针。通过表项的索引值i来执行一个跳转表内的数组引用，从而确定跳转指令的目标，并且如果有重复情况的引用即简单的使用相同的代码标号。

跟使用一组很长的if-else语句相比，优点是很明显的，使用跳转表执行switch语句的时间与开关情况的数量无关。甚至switch语句出现上百种情况，也只用一次跳转表去访问处理。

如下图所示为一个switch语句的示例，分别是：switch语句、翻译到扩展的C语言(使用跳转表)。汇编代码略。

根据汇编代码中index的值，有五个不同的跳转位置：loc_A(.L3)、loc_B(.L4)、loc_C、loc_D、loc_def。观察到jmp指令的操作数有前缀*,表明这是一个间接跳转，操作数指定一个存储器位(数组引用某索引元素)。通过分析switch语句确定指针数组的每个表项具体对应哪个代码块(不同的跳转位置)

2.4 C语言函数调用的栈帧结构

IA32程序用程序栈来支持过程调用。它包括将数据(参数和返回值)和控制从代码的一部分传到另一部分，另外还包括进入时为过程的局部变量分配空间，并在退出时释放空间。一般地，机器只提供转移控制到过程和从过程中转移出控制的简单指令，数据传递、局部变量的分配和释放必然通过程序栈实现

2.4.1 栈帧结构基础

机器用栈来传递过程参数、存储返回信息、保存寄存器用于以后恢复和本地存储。我们称为单个过程分配的那部分栈为栈帧。按前面的介绍，栈指针%esp可以移动，帧指针％esp不变化，因而大多数信息的访问都是相对于帧指针的。如下图所示：

支持过程调用和返回的指令

call指令：目标是指明被调用过程起始的指令地址。同跳转一样，调用可是直接的(一个标号)，也可是间接的(*后加一个操作数指示符)。其效果是：将返回地址入栈，并跳转到被调用过程(P调用Q,P调用者，Q被调用者)的第一条指令处。　所谓返回地址是指在程序中紧跟call后面的那条指令的地址，这样当被调用过程返回时，执行会从此处继续。

leave指令：为返回准备栈，它等价于如下代码：

movl %ebp,%esp
popl %ebp //恢复已保存的%ebp寄存器

ret指令：从过程调用中返回。指的是从栈中弹出地址，并跳转到这个位置

如图所示为sum和main函数的反汇编代码节选。

可以看到：main函数中，call指令调用函数sum,它的效果是将返回地址0x080483e1压入栈中，并跳到sum函数的第一条指令中。sum继续执行直到遇到ret指令，它的效果是从栈中弹出值0x080483e1,然后跳到这个地址(调用sum的call函数之后)，继续main函数的执行

寄存器使用惯例

调用者调用被调用者时，要求被调用者不能覆盖某个调用者稍后会使用的寄存器值。根据惯例，寄存器%eax、%edx、%ecx称为调用者保存寄存器。P调用Q时，Q可以覆盖这些寄存器而不会破坏任何P需要的数据(因为会恢复)。另一方面，寄存器%ebx、%esi等被划分为被调用者保存寄存器。要求Q必须在覆盖这些寄存器值之前，先把它们保存到栈中，并在返回前恢复它们。

2.4.2 普通函数、递归函数的调用过程

A. 普通函数的调用实例

考虑如下图定义的普通C函数调用，函数caller包括一个对函数swap_add的调用，并且给出了调用swap_add函数前和正在运行时的栈帧结构。注：访问的栈位置有些是相对于栈指针%esp的，有些是相对于基地址指针%ebp的，偏移量都是由相对于这两个指针的栈表示！

a. caller栈帧的汇编代码－调用swap-add前
如图所示，caller的栈帧包括存储局部变量arg1和arg2(相对于帧指针位置-4和-8，只能存在栈中，所以必须要为它们生成地址)。

第2、3、4行表示保存旧的%ebp,并把%ebp当做％esp的开始位置．然后栈指针减去24字节，从而在栈上分配24个字节(栈向低地址方向生长)。第5、6行初始化两个局部变量(arg1,arg2)

第7-10行开始计算&arg2和&arg1的值并存储到栈中，leal指令加载有效地址(将有效地址写入目的操作数中)，形成swap_add的参数。并且将这些参数存储到相对于栈指针偏移量为０和+4的地方
注意：

调用swap_add的栈帧caller，分配了24个字节，8个用于局部变量，8个用于向swap_add传递参数，还有8个未使用。(调用swap_add前)　GCC坚持一个访问数据的严格对齐原则，函数使用的所有栈空间必须是16字节的整数倍。(栈分配存在一些从不使用的空间)
C语言中，所有的参数都是传值调用。注意这与显示地产生一个指向某值的指针作为参数，值发生改变并无冲突。传递给函数的是指针值的一个副本，对函数内指针参数的改变并不会影响作为实参的指针变量，但它可以改变作为副本的指针指向的内容，从而达到类似于引用参数的效果。

b. swap_add的汇编代码－初始化栈帧，执行主体，过程返回恢复栈的状态

初始化栈帧：在这之前，call指令已经讲返回地址压入栈中。它执行的操作就是保存旧的%ebp,%esp指针指向%ebp,并且保存旧的%ebx。如下：

可以看到%ebx作为被调用者保存寄存器，它必须将旧值压入栈中。注意到%ebp已经移动了，作为swap_add的帧指针

swap_add主体代码：从caller的栈帧取出它的参数并执行swap_add操作。如下：

由于初始化栈帧中帧指针%esp已经移动，参数的位置因而也从%esp的旧值+4和0的位置变成了相对于%ebp的新值+12和+8的位置。寄存器%eax是作为返回值传递的

过程返回恢复栈的状态：恢复%ebx和%ebp的值

恢复这几个寄存器值后，重新设定栈指针式它指向存储的返回值。ret指令将控制转移到caller,再执行caller指令的下一条指令(返回地址)

B. 递归函数的调用实例
如图为递归的阶乘函数的C代码和汇编代码。我们主要检查当参数n来调用时，机器代码如何操作。

和普通函数的过程调用类似，第2-5行创建一个栈帧，其中包括%ebp的旧值、保存的被调用者寄存器%ebx的值及当递归调用自身的时候保存参数的4个字节。第6-7行用寄存器%ebx来保存参数n的值，并将%eax的返回值置为1。判断n < =1的结果，成立的话会跳转到完成代码（终止条件）;否则，处于递归的情形下，n-1的值存在栈上，并调用函数本身，此时后寄存器%eax保存着(n-1)!的值，被调用者保存寄存器%ebx保存参数n。

从这两个示例我们可以总结出一些要点：

栈规则提供了一种机制，每次函数调用都有存储它自己的私有状态信息(保存的返回位置、栈指针、被调用者保存寄存器－很重要，必须先保存)
如果需要，还需要根据分配和释放的栈规则存储局部变量。过程调用中在栈上分配局部变量，返回时自动释放。每个调用在各自栈中私有空间，局部变量都不会相互影响。
过程调用中访问信息均是相对于帧指针%ebp而言，$0x4(%ebp)表示的是返回地址，往地址增大的方向$0x8(%ebp)表示的是函数第一个参数，函数如果有多个参数，依次以4递增。本地变量和临时变量则是往地址变小的方向存储
在返回前，函数必须将栈恢复到原始条件，可以恢复所有的被调用者保存寄存器和%ebp,并重置%esp使其指向返回地址。
如果在调用过程中，使用了malloc函数，需要说明的是：
　一、指针变量是分配在栈上的局部变量，调用结束，该变量自动释放。但由malloc分配在堆的内存－该指针指向的堆内存却并未释放，如果不作处理，就会造成内存泄露；
　二、为了防止内存泄露，有两种处理情形：作为返回值，返回那段堆内存的指针，从而不会丢失对那段内存的控制；在栈调用结束前使用free操作手动释放那段内存；
　三、指针变量的内存随调用结束自动释放，指针指向的那段内存必须使用free或delete操作释放。因而明确一点的是free之后再解引用那个指针是非法的，因为访问已释放的内存地址是无效的，一般建议释放操作后主动置指针为NULL指针就不会造成误解。

2.5 C语言中的结构：数组、指针、结构、联合

2.5.1 数组和指针

对于数据类型T和整型常数N,声明如下: T a[N]。它具有两个效果：
在存储器分配L*N个字节的连续区域，L是数据类型T的大小;xa表示起始位置，则访问数组元素a[i]的位置在xa+ L*i的地方。

数组元素的访问一般借助存储器引用指令。如计算整型的Ｅ[i]: E的地址存放在寄存器%edx中，而i存放在寄存器%ecx中，访问指令如下：

movl (%edx,%ecx,4),%eax (计算地址xe+4i,并读取这个存储器位置的值，将结果放到寄存器%eax中)

指针，实际上是地址的一种表示方式，它指向某一个类型的对象。指针类型不是机器代码中的一部分，而是C语言提供的一种抽象。

产生指针可用&运算符，它适合于变量、结构、联合和数组的元素，我们常常用leal指令来生成存储器引用的地址。*用于指针的间接引用，它表示一个值，类型与指针的类型相关，它是通过存储器引用来实现的，要么写入数据，要么读取数据。

如下图为与整型数组E有关的表达式。它的起始地址和整数索引i分别存在寄存器%edx、%ecx中

可以看出：

leal指令用来创建地址，movl用来引用存储器(除了第一种和最后一种情况，前者表示复制地址，后者表示复制索引)
数组与指针是有紧密联系的。一个数组的名字既可以直接数组引用又可以像一个指针变量引用(但不能修改)。如a[3]与*(a+3)有一样的效果，它均需要用对象类型的大小对偏移量进行伸缩。我们写表达式p+i,指针p的指针为p,则得到的地址计算为p+L*i,L是与p相关联的数据类型大小！
指针能够从某种类型强制转换到另一种类型，只改变它的类型，而不改变它的值。所起的效果是改变指针运算的伸缩。如p是一个char*类型的指针，那么表达式(int*)p+7为p+28,(int*)(p+7)为p+7
对于二维数组，对应的元素的地址的汇编代码表示可以借助移位、加法和伸缩组合来避免直接的乘法工作

2.5.2 结构和联合、数据对齐

C语言提供两种结合不同类型的对象来创建数据类型的机制：

结构: 多个对象组合到一个单位中
联合: 允许用几种不同的类型来引用一个对象

与此同时，计算机系统对数据类型的对象地址必须是某值K(2、4、8)的倍数，这种对齐限制简化了处理器和存储器系统间的硬件设计。Intel建议对齐数据以提高存储器系统的性能。在Linux中采用如下的对齐策略：

数组作为同样大小的块来分配，结构体作为变长的块来分配，保存着不同大小的结构元素；联合作为一个单独的块来分配，这个块必须足够大，能够装下联合中最大的元素。
对于IA32系统，2字节数据类型(如short)的地址必须是2的倍数，而较大的数据类型(如int、float、int *)的地址必须是4的倍数。
x86-64系统对齐要求更为严格，对于任何需要K字节的标量数据类型的起始地址必须是K的倍数。如long、double和指针必须在8 字节边界上对齐，long double使用16字节对齐
结构体的对齐除了要满足每个字段的对齐要求，还需要考虑整体的结构满足怎样的对齐要求，例如32位的结构体元素里最大只有2个字节，它就无需满足4字节对齐，如果含有一个4字节的元素，则整体必须满足4字节对齐。即要求所有元素都满足自身的对齐要求(一定要了解是32还是64位系统，因为它们对齐方式有很大的不同)

下面就来具体介绍结构体和联合体：

A. 结构体
考虑下面的代码：

#include<stdio.h>
 /**

  */
struct test {   
    int i; 
    short c;
    int j;
    char *p;
    char s[0];
}; 

int main(){
    struct test *pt=NULL;
    printf("pt的地址: %p\n",pt);
    /*输出pt->i/c/j/p/s都会core dump，因为不能访问内存地址0x0－0x20,但可以输出这些内存地址*/
    printf("i的地址: %p\n",&pt->i); 
    printf("c的地址: %p\n",&pt->c);
    printf("j的地址: %p\n",&pt->j);
    printf("p的地址: %p\n",&pt->p);
    printf("s的地址: %p\n",pt->s);
    return 0;
}

在结构体中，编译器记录了每个字段的字节偏移，汇编代码通过以结构体的地址加上适当的偏移放访问结构的字段。记test的起始地址为xp,，结合数据对齐的策略:

在64位机器要保证每个元素的K字节数据对齐，各元素的地址为xp、xp+4、xp+8、xp+16、xp+24
在32位机器要保证较大数据类型的4字节数据对齐，各元素的地址为xp、xp+4、xp+8、xp+12、xp+16

以32为例，记结构体类型的指针变量在寄存器%edx中，获取每个字段元素的汇编代码如下(每行代码独立)：

movl (%edx),%eax 　　　获得pt->i
movl 4(%edx),%eax　　　获得pt->c
movl 8(%edx),%eax     获得pt->j
leal 4(%edx),%eax + movl %eax,12(%edx) 获得&pt->c存储在pt->p
movl 16(%edx),%eax    获得pt->s

也就是说结构体中的元素存储的都是相对于结构体首地址的偏移。回到上面的实例中，分别在64位和32位系统中测试，如下

64位系统:
pt的地址: (nil)
i的地址: (nil)
c的地址: 0x4
j的地址: 0x8
p的地址: 0x10
s的地址: 0x18

32位系统:
pt的地址: (nil)
i的地址: (nil)
c的地址: 0x4
j的地址: 0x8
p的地址: 0xc
s的地址: 0x10

我们可以看到输出指针p和数组s名字的不同形式，这是因为指针和数组还是有区别的。访问结构体中的指针字段实际上是指针本身的值(同其他非指针或数组的变量是一样)，访问结构体中的数组名其实就是数组的相对地址(即char s[10]中数组名s和&s是一样的)

B. 联合类型
联合类型提供了一种方式，绕过了C语言类型系统，允许以多种类型来引用一个对象，并且它的总大小为它最大字段的大小。在某些情况下，联合十分有用

事先知道一个数据结构中的两个不同的字段是互斥的，可将这两个字段声明为联合的一部分，而不是结构的一部分，以减小分配空间的总量。

例如实现一个二叉树的数据结构，每个叶子节点都有一个double的数据，而每个内部节点都有指向两个孩子节点的指针但无数据。
简单的声明如下:

struct node {
	struct node *left;
	struct node *right;
	double data;
};

每个节点需要16字节，浪费一半的字节；不妨定义如下，并引入枚举类型，区分联合中可能的不同选择，共需要12个字节。

typedef enum {LEAF,INTERNAL} nodetype_t;
struct node {
	nodetype_t type;
	union {
		struct {
			struct node *left;
			struct node *right;
		} internal;
		double data;
	} info;
}

访问不同数据类型的位模式。如我们以一种数据类型来存储联合中的参数，又以另一种数据类型来访问它(注意此时的字节顺序)

例如以两个4字节的无符号位的形式创建一个8字节的形式：

double bit2double(unsigned w0,unsigned w1){
	union {
		double d;
		unsigned u[2];
	} temp;
	
	temp.u[0]=w0;
	temp.u[1]=w1;
	return temp.d;
}

在小端法机器上，参数w0是d的低4位字节;在大端法机器中，参数w0是d的高4位字节。

C. 长度为0的数组
刚才上面有个例子有一个char s[0]-长度为4的数组。默认地零数组在标准C和C++是不允许的，如果使用的话编译时会产生错误。但在GNU C99中，这种用法是合法的，它最典型的用法是置于结构体中的最后一个字段，并且在前面至少有一个其他字段，因而GCC编译时不会产生任何警告或错误。我们称这个数组为柔性数组。

例如我们想定义一个可变长度的结构体，这时候我们就可以用到零数组。下面是使用指针和零数组构建变长数组的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*零数组方式*/
typedef struct {
	int len;
	char body[0];
} data_t1;

/*指针方式*/
typedef struct {
	int len;
	char *body;
} data_t2;

int main(){
	printf("零数组方式的结构体大小为: %d\n",sizeof(data_t1));
	printf("指针方式的结构体大小为: %d\n",sizeof(data_t2));

	int len=10;
	data_t1 *d1=(data_t1 *)malloc(sizeof(data_t1)+len);//len个数据类型为T的元素，柔性数组申请空间时采用一次性分配一次性释放原则
	d1->len=len;
	strcpy(d1->body,"success!");
	int i,size=strlen(d1->body);
	

	data_t2 *d2=(data_t2 *)malloc(sizeof(data_t2));
	d2->len=len;
	d2->body=(char *)malloc(sizeof(char)*len);//指针方式还需要分配指针指向的内容，释放也要分别释放
	memset(d2->body,'a',len);

	for(i=0;i<size;i++)
		printf("%c",d1->body[i]);
	printf("\n");
	free(d1);

	for(i=0;i<len;i++)
		printf("%c",d2->body[i]);
	printf("\n");
	free(d2->body);
	free(d2);
	return 0;
}

对应的输出结果如下(64位系统):

零数组方式的结构体大小为: 4
指针方式的结构体大小为: 16
success!
aaaaaaaaaa

我们再用gcc -g test.c -o test & gdb test查看，有如下结果:

从上面的结果可以看出:

零长度数组定义在结构体内，但并不占用结构体的空间(可用sizeof(某结构体或者char[0])测试，可比较指针方式是否占用空间)。可理解为这是一个没有内容的占位符标识，分配了实质内容后变成了一个有长度的数组
它能够为结构体内的数据分配一段连续的内存，并可以一次性讲内存释放。对比指针，既需要释放指针指向的内存块，又需要释放结构体指针。
分配连续的内存是有利于提高访问速度，并减少了一定量的内存碎片，指针则不可。

文章3

汇编语言编写的代码和机器代码接近，和机器密切相关，现在通常我们已经不会用它来编写程序了。但它仍然很重要，特别是希望能够了解程序是如何转换成机器代码来运行的时候。本篇总结汇编语言的部分知识和C程序如何编译成机器代码。

程序编码

汇编语言中不区分数据类型，将存储器看作一个很大的按字节寻址的数组。程序存储器包含程序的目标代码、操作系统需要的一些信息、运行时栈和用户分配的存储器块。程序存储器用虚拟地址寻址，由操作系统负责管理虚拟地址空间，将虚拟地址转换为物理地址。

gcc 命令使用 -S 选项可以产生汇编代码，使用-c 选项会编译代码产生目标文件， -O2 选项为优化级别。

例：

/* a.c */
int accum = 0;

int sum(int x, int y)
{
    int t = x + y;
    accum += t;
    return t;
}

$ gcc -O2 -S a.c    # 生成a.s汇编文件
$ gcc -O2 -c a.c    # 生成a.o目标文件

生成的汇编文件中 sum 函数为：

sum:
    pushl   %ebp
    movl    %esp, %ebp
    movl    12(%ebp), %eax
    addl    8(%ebp), %eax
    addl    %eax, accum
    popl    %ebp
    ret

可以用反汇编器来根据目标代码来生成类似于汇编代码的格式：

$ objdump -d a.o
...
00000000 <sum>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   8b 45 0c                mov    0xc(%ebp),%eax
   6:   03 45 08                add    0x8(%ebp),%eax
   9:   01 05 00 00 00 00       add    %eax,0x0
   f:   5d                      pop    %ebp
  10:   c3                      ret

sum 函数有17个字节，还可以用 gdb 查看它的字节表示：

$ gdb a.o
(gdb) x/17xb sum
0x0 <sum>:      0x55    0x89    0xe5    0x8b    0x45    0x0c    0x03    0x45
0x8 <sum+8>:    0x08    0x01    0x05    0x00    0x00    0x00    0x00    0x5d
0x10 <sum+16>:  0xc3

x/17xb 表示“检查17个十六进制字节”。得到的结果和 objdump 的相同。

在主文件中调用 sum 函数：

/* m.c */
int main()
{
    return sum(1, 3);
}

编译生成可执行文件：

$ gcc -O2 -o m a.o m.c

反编译 m 文件，可以看到函数 sum 和 a.o 目标文件中的有两个不同：一是虚拟空间地址不同，二是 accum 全局变量现在已由具体的地址代替。

$ objdump -d m
...
080483a0 <sum>:
 80483a0:       55                      push   %ebp
 80483a1:       89 e5                   mov    %esp,%ebp
 80483a3:       8b 45 0c                mov    0xc(%ebp),%eax
 80483a6:       03 45 08                add    0x8(%ebp),%eax
 80483a9:       01 05 b0 95 04 08       add    %eax,0x80495b0
 80483af:       5d                      pop    %ebp
 80483b0:       c3                      ret

GAS指令

Intel用字表示16位数据类型，32位数称为双字，64位数称为四字。见前一篇中C数据类型的大小的表。GAS中每个操作都有一个字符后缀，表示操作数的大小。

IA32 CPU中包含一组8个存储32位值的寄存器，它们用来存储整数数据和指针。所有8个寄存器可以以16位和32位来访问，前四个寄存器还可以独立访问两个低位字节。

/media/note/2012/03/15/linux-machine-level/fig1.png

整数寄存器

大多数指令具有操作数，指示操作要引用的源数据值和放置结果的目的位置。操作数有三种：

立即数，即常数值，写为 $ 加一个整数。
寄存器，表示某个寄存器的内容，用E_a表示寄存器a，引用R[E_a]表示它的值。
存储器引用，根据地址访问某个存储器位置，用M[Addr]表示存储在存储器中地址Addr开始的值的引用。

伸缩因子s必须是1、2、4、8。

类型	格式	操作数值	名称
立即数	$Imm	Imm	立即数寻址
寄存器	E_a	R[E_a]	寄存器寻址
寄存器	Imm	M[Imm]	绝对寻址
寄存器	(E_a)	M[R[E_a]]	间接寻址
寄存器	Imm(E_b)	M[Imm+R[E_b]]	（基址+偏移量）寻址
寄存器	(E_b,E_i)	M[R[E_b]+R[E_i]]	变址
寄存器	Imm(E_b,E_i)	M[Imm+R[E_b]+R[E_i]]	寻址
寄存器	(,E_i,s)	M[R[E_i]*s]	伸缩化的变址寻址
寄存器	Imm(,E_i,s)	M[Imm+R[E_i]*s]	伸缩化的变址寻址
寄存器	(E_b,E_i,s)	M[R[E_b]+R[E_i]*s]	伸缩化的变址寻址
寄存器	Imm(E_b,E_i,s)	M[Imm+R[E_b]+R[E_i]*s]	伸缩化的变址寻址

数据传送

最常用的指令是数据传送指令。IA32限制传送指令的两个操作数不能都指向存储器位置。

指令	效果	描述
`movl S,D`	D <- S	传送双字
`movw S,D`	D <- S	传送字
`movb S,D`	D <- S	传送字节
`movsbl S,D`	D <- S（符号扩展）	传送符号扩展的字节
`movzbl S,D`	D <- S（零扩展）	传送零扩展的字节
`pushl S`	R[%esp] <- R[%esp] - 4 M[R[%esp]] <- S	压栈
`popl D`	D <-M[R[%esp]] R[%esp] <- R[%esp] + 4	出栈

movsbl 和 movzbl 复制字节，并扩展为32位。

IA32的栈向低地址方向增长，压栈减小栈指针的值并存内容到存储器中，出栈相反。按惯例，将栈倒着画，栈顶放在下面。

pushl    %ebp
相当于：
subl     $4,%esp
movl     %ebp,(%esp)

popl     %eax
相当于：
movl     (%esp),%eax
addl     $4,%esp

算术和逻辑

下表中包含了四类整数操作：加载有效地址、一元操作、二元操作和移位操作。

指令	效果	描述
`leal S,D`	D <- &S	加载有效地址
`incl D`	D <- D + 1	加1
`decl D`	D <- D - 1	减1
`negl D`	D <- -D	取负
`notl D`	D <- ~D	取补
`addl S,D`	D <- D + S	加
`subl S,D`	D <- D - S	减
`imull S,D`	D <- D * S	乘
`xorl S,D`	D <- D ^ S	异或
`orl S,D`	D <- D \| S	或
`andl S,D`	D <- D & S	与
`sall k,D`	D <- D << k	左移
`shll k,D`	D <- D << k	左移（等价于sall）
`sarl k,D`	D <- D >> k	算术右移
`shrl k,D`	D <- D >> k	逻辑右移

除 leal 外，每条指令都有以 w 和 b 结尾的对字和字节操作的版本。

加载有效地址指令 leal 并不引用存储器，而是将有效地址写到目的操作数，目的操作数必须是寄存器。

下表中是一些特殊的算术操作：64位的乘积和整数除法。

指令	效果	描述
`imull S`	R[%edx]:R[%eax] <- S * R[%eax]	有符号64位乘法
`mull S`	R[%edx]:R[%eax] <- S * R[%eax]	无符号64位乘法
`cltd S`	R[%edx]:R[%eax] <- R[%eax]（符号扩展）	转换为四字
`idivl S`	R[%edx] <- R[%edx]:R[%eax] mod S R[%eax] <- R[%edx]:R[%eax] / S	有符号除法
`divl S`	R[%edx] <- R[%edx]:R[%eax] mod S R[%eax] <- R[%edx]:R[%eax] / S	无符号除法

控制

程序执行通常还需要控制操作执行的顺序。汇编语言提供了非顺序控制流的机制，基本操作是跳转到程序的另一部分。

CPU中有一组单个位的条件码寄存器，描述最近的算术或逻辑操作的属性。主要包括：

CF ：进位标志，最近的操作使最高位产生了进位，可用来检查无符号操作数的溢出。
ZF ：零标志，最近的操作得到的结果为0。
SF ：符号标志，最近的操作得到的结果为负数。
OF ：溢出标志，最近的操作导致一个二进制补码溢出。

leal 指令不改变条件码，其他的算术和逻辑操作都会设置条件码。此外，下面的操作只设置条件码：

指令	基于	描述
`cmpl S2,S1`	S1 - S2	比较双字
`testl S2,S1`	S1 & S2	测试双字

cmpl 和 testl 指令都有对应的w 和 b 结尾的字和字节版本。

可以根据条件码的某种组合来设置整数寄存器或执行条件分支指令。

下面的指令根据条件码的组合将一个字节设置为0或1，可以用 movzbl 指令对高位字节清零来得到32位结果。

指令	同义名	效果	设置条件
`sete D`	`setz`	D <- `ZF`	相等/零
`setne D`	`setnz`	D <- `~ZF`	不等/非零
`sets D`		D <- `SF`	负数
`setns D`		D <- `~SF`	非负数
`setg D`	`setnle`	D <- `~(SF^\|OF)&~ZF`	大于（有符号>）
`setge D`	`setnl`	D <- `~(SF^\|OF)`	大于等于（有符号>=）
`setl D`	`setnge`	D <- `SF^\|OF`	小于（有符号<）
`setle D`	`setng`	D <- `(SF^OF)\|ZF`	小于等于（有符号<=）
`seta D`	`setnbe`	D <- `~CF&~ZF`	超过（无符号>）
`setae D`	`setnb`	D <- `~CF`	超过或相等（无符号>=）
`setb D`	`setnae`	D <- `CF`	低于（无符号<）
`setbe D`	`setna`	D <- `CF\|ZF`	低于或相等（无符号<=）

跳转指令使执行切换到程序中的一个新位置，跳转的目的地通常用标号指明。当跳转条件满足时，指令会跳转到一条带标号的目的地。

指令	同义名	跳转条件	描述
`jmp Label`		1	直接跳转
`jmp *Operand`		1	间接跳转
`je Label`	`jz`	`ZF`	相等/零
`jne Label`	`jnz`	`~ZF`	不等/非零
`js Label`		`SF`	负数
`jns Label`		`~SF`	非负数
`jg Label`	`jnle`	`~(SF^OF)&~ZF`	大于（有符号>）
`jge Label`	`jnl`	`~(SF^OF)`	大于等于（有符号>=）
`jl Label`	`jnge`	`SF^OF`	小于（有符号<）
`jle Label`	`jng`	`(SF^OF)\|ZF`	小于等于（有符号<=）
`ja Label`	`jnbe`	`~CF&~ZF`	超过（无符号>）
`jae Label`	`jnb`	`~CF`	超过或相等（无符号>=）
`jb Label`	`jnae`	`CF`	低于（无符号<）
`jbe Label`	`jna`	`CF\|ZF`	低于或相等（无符号<=）

jmp 指令是无条件跳转。可以是直接跳转，以一个标号作为跳转目标，如 .L1 ；也可以是间接跳转，跳转目标从寄存器或存储器中读出，如 *(%eax) 。

条件跳转只能是直接跳转。

汇编代码中跳转目标以符号标号书写，汇编器和链接器会产生跳转目标的适当编码。最常用的编码是PC相关的，即以目标指令的地址和紧跟在跳转指令后面的那条指令的地址的差作为编码，这样的好处是指令编码简洁，且目标代码存储位置变化时不必改变。另一种编码方法是给出绝对地址。

C语言控制流翻译成汇编代码的结构，通常都是以跳转实现。不同的编译器或同一编译器的不同优化级别产生的汇编代码的结构往往都是不同的。下面只就一些典型的处理方式做分析，实际当中会有一定不同。

C语言的条件语句是用有条件跳转和无条件跳转结合起来实现的。

C语言if-else语句：                      汇编实现的结构：

if (test-expr)                              t = test-expr;
    then-statement                          if (t)
else                                            goto true;
    else-statement                          else-statement
                                            goto done;
                                        true:
                                            then-statement
                                        done:

C语言中的三种循环也是以条件测试和跳转的组合来实现，大多数会根据循环的 do-while 形式来产生循环代码。

C语言do-while语句：                     汇编实现的结构：
do                                      loop:
    body-statement                          body-statement
while (test-expr);                          t = test-expr;
                                            if (t)
                                                goto loop;

C语言while语句：                        汇编实现的结构：
while (test-expr)                           t = test-expr;
    body-statement                          if (!t)
                                                goto done;
                                        loop:
                                            body-statement
                                            t = test-expr;
                                            if (t)
                                                goto loop;
                                        done:

C语言for语句：                          汇编实现的结构：
for (init-expr; test-expr; update-expr)     init-expr;
    body-statement                          t = test-expr;
                                            if (!t)
                                                goto done;
                                        loop:
                                            body-statement
                                            update-expr;
                                            t = test-expr;
                                            if (t)
                                                goto loop;
                                        done:

C语言的 switch 语句的实现在分支较多和值的跨度较小时会使用跳转表。跳转表是一个数组，表项i是代码段的地址，使用跳转表使代码可以快速跳转到要执行的分支，和分支数无关。

跳转表类似下面这样声明：

        .section        .rodata    只读数据
        .align 4
        .align 4
.L8:                               下面是不同的case
        .long   .L2
        .long   .L3
        .long   .L4
        .long   .L5
        .long   .L2
        .long   .L6
        .long   .L2
        .long   .L7

过程

过程调用包括数据和控制的传递，还在进入时为过程的局部变量分配空间，退出时释放空间。IA32提供了转移控制的指令，数据传递和局部变量的分配释放则通过操纵程序栈实现。

栈用来传递过程参数、存储返回信息、保存寄存器和用于本地存储。为单个过程分配的部分栈称为栈帧。寄存器 %ebp 作为帧指针，寄存器 %esp 作为栈指针，栈帧以这两个指针定界。程序执行时，栈指针可以移动。

/media/note/2012/03/15/linux-machine-level/fig2.png

栈帧结构

若P调用Q，Q的参数放在P的栈帧中。调用时，P的返回地址压入栈中形成P的栈帧的末尾，返回地址是程序从Q返回时应该继续执行的地方。Q的栈帧从保存的帧指针开始，后面是其他寄存器的值和不能放在寄存器中的局部变量。栈向低地址方向增长。

下面是过程调用和返回的指令：

指令	描述
`call Label`	过程调用
`call *Operand`	过程调用
`leave`	为返回准备栈
`ret`	从过程调用中返回

调用可以是直接的和间接的， call 指令将返回地址入栈，并跳转到被调用过程的起始处，返回地址是call 后面的指令的地址。 leave 指令使栈指针指向call 存储的返回地址。 ret 指令从栈中弹出地址，并跳转到那里。寄存器%eax 可以用来返回值。

leave
等价于：
movl    %ebp, %esp
popl    %ebp

程序寄存器组被所有过程共享。寄存器 %eax 、 %edx 、 %ecx 为调用者保存寄存器，由P保存，Q可以覆盖这些寄存器而不破坏P的数据。寄存器%ebx 、 %esi 、%edi 为被调用者保存寄存器，Q需要在覆盖它们之前将值保存到栈中，并在返回前恢复它们。

int swap(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
    return *x + *y;
}

int func()
{
    int a = 1234;
    int b = 4321;
    int s = swap(&a, &b);
    return s;
}

        .p2align 4,,15
.globl swap
        .type   swap, @function
swap:
        pushl   %ebp                压入帧指针
        movl    %esp, %ebp          将帧指针设为栈指针指向位置
        movl    8(%ebp), %edx       读取x
        movl    12(%ebp), %ecx      读取y
        pushl   %ebx                压入%ebx（被调用者保存寄存器）
        movl    (%edx), %eax        读取*x
        movl    (%ecx), %ebx        读取*y
        movl    %ebx, (%edx)        将*y写入x指向存储器位置
        movl    %eax, (%ecx)        将*x写入y指向存储器位置
        addl    (%edx), %eax        *x+*y
        popl    %ebx                恢复%ebx
        popl    %ebp                弹出帧指针（%esp等于原值）
        ret                         返回
        .size   swap, .-swap
        .p2align 4,,15
.globl func
        .type   func, @function
func:
        pushl   %ebp                压入帧指针
        movl    $5555, %eax         保存计算结果（编译器-O2优化）
        movl    %esp, %ebp          将帧指针设为栈指针指向位置
        popl    %ebp                弹出帧指针（%esp未变）
        ret                         返回
        .size   func, .-func

数组

设有数据类型 T ， L 为T 的字节大小。

C中的数组声明 T a[N] 在存储器中分配了 L*N 字节的连续区域，设 x 为起始位置，声明还引入了标识符 a ，作为指向数组开头的指针，指针的值为 x 。数组元素 i 的存放地址为 x + L*i 。

C中指针运算的值会根据指针引用的数据类型的大小进行调整。若 p 指针指向类型 T 的数据， p 的值为 x ，则 p+i 的值为 x + L*i 。

对于循环中数组的引用，编译器优化通常会用指针运算代替循环变量来遍历数组，用最后的数组元素的地址和指针的比较作为测试条件。

对于固定大小的数组，编译器会进行多种优化，如使用指针变量来访问，用移位和加法代替乘法指令。动态分配的数组在编译时不能确定大小，需要用 calloc 等函数在堆中创建，必须使用乘法指令。

typedef int *matrix;

int matrix_e(matrix a, int i, int j, int n)
{
    return a[(i*n) + j];
}

matrix_e:
        pushl   %ebp
        movl    %esp, %ebp
        movl    20(%ebp), %eax          读取i
        imull   12(%ebp), %eax          计算i*n
        movl    8(%ebp), %edx           读取a
        addl    16(%ebp), %eax          计算i*n+j
        popl    %ebp
        movl    (%edx,%eax,4), %eax     读取a[i*n+j]
        ret

结构和联合

结构的实现类似于数组，组成部分存储在连续区域，指向结构的指针即结构的第一个字节的地址。编译器保存关于每个结构类型的信息，指示每个域的字节偏移。

struct rec {
    int i;
    int j;
    int a[3];
    int *p;
} *r;
r->p = &r->a[r->i + r->j];

movl    4(%eax), %edx       读取r->j
addl    (%eax), %edx        加上r->i
leal    8(,%edx,4), %edx    计算&r->a[r->i+r->j]
movl    %edx, 20(%eax)      存入r->p

联合的语法和结构一样，但它的不同的域引用相同的存储器块。

内嵌汇编

现在已经很少使用汇编代码写程序了，但是在一些如访问寄存器或获取条件码等的场合，仍然需要汇编代码。

可以编写独立的汇编代码文件，然后编译它并和C代码链接起来。GCC也支持将汇编和C代码混合起来，即内嵌汇编。

内嵌汇编像过程调用一样写代码：

asm(code-string);

code-string 为字符串形式的汇编代码序列，编译器将它插入到生成的汇编代码中，错误检查会由汇编器来执行。

asm 有一个扩展版本，它可以指定汇编代码序列的操作数和要被覆盖的寄存器。

asm(code-string[ : output-list[ : input-list[ : overwrite-list]]]);

code-string 由用 ; 分隔的汇编代码指令序列组成，输入输出操作数用引用 %0 、...、 %9 表示，操作数根据它们第一次在 input-list 和output-list 中出现的顺序编号。输入输出列表由, 分隔的操作数对组成，每个操作数对由空格分隔的操作数类型的字符串和括号包含的操作数组成。 = 表示赋值， r 表示整数寄存器。操作数是C表达式。寄存器要在前面加 % 。

int umul(unsigned x, unsigned y, unsigned *dst)
{
    int res;
    /*
     * movl     x,%eax              读取x
     * mull     y                   无符号乘法乘以y
     * movl     %eax,*dst           存储结果的低4字节到*dst
     * setae    %dl                 设置低位字节
     * movzbl   %dl,res             零扩展设为res
     */
    asm("movl %2,%%eax; mull %3; movl %%eax,%0; setae %%dl; movzbl %%dl,%1"
        : "=r" (*dst), "=r" (res)   /* 输出 */
        : "r" (x), "r" (y)          /* 输入 */
        : "%eax", "%edx"            /* 覆盖 */
        );
    return res;
}

umul:
        pushl   %ebp
        movl    %esp, %ebp
        movl    8(%ebp), %ecx       读取x
        pushl   %ebx
        movl    12(%ebp), %ebx      读取y
#APP
# 4 "asm.c" 1
        movl %ecx,%eax; mull %ebx; movl %eax,%ebx; setae %dl; movzbl %dl,%ecx
# 0 "" 2
#NO_APP
        movl    16(%ebp), %eax      读取dst
        movl    %ebx, (%eax)        保存*dst
        movl    %ecx, %eax          设res为结果
        popl    %ebx
        popl    %ebp
        ret

对齐

通常计算机系统对基本数据类型的可允许的地址做了一些限制，要求地址必须是某个值k（常为2、4、8）的倍数。对齐简化了处理器和存储器系统之间接口的硬件设计。

Linux要求2字节数据类型的地址必须是2的倍数，更大的数据类型的地址必须是4的倍数。Microsoft Windows要求任何k字节数据类型的地址必须是k的倍数。

编译器在汇编代码中指明全局数据所需的对齐，如跳转表中的 .align 4 ，它使该指令后面的数据从4的倍数的地址开始。

malloc 等分配存储器的库函数必须设计为返回的指针能满足最糟情况的对齐限制。

对于结构，它的起始地址和域都有一些对齐要求。如：

struct s {          /* 地址示例：x为间隙           */
    char c;         /* bf9483e0: cx-------------- */
    short s[2];     /* bf9483e2: --s0s1xx-------- */
    int i;          /* bf9483e8: --------iiii---- */
    char d;         /* bf9483ec: ------------dxxx */
};

缓冲区溢出

C对数组引用不做边界检查，同时局部变量和状态信息（寄存器值和返回指针等）都存放在栈中，这使得越界的数组写操作会破坏存储在栈中的状态信息，程序使用被破坏的状态时就会出现严重的错误。

常见的状态破坏称为缓冲区溢出，就是实际保存内容的大小超过了缓冲区大小，导致写越界。缓冲区溢出能被用来让程序执行非本意的函数，这是最常见的通过计算机网络攻击系统安全的方法。

GDB调试器

GDB支持对机器级程序的运行时评估和分析。一般先运行 objdump 来获得程序的反汇编版本，以帮助确定断点等。断点可以设置在函数入口后面，或某个地址。使用gdb 执行程序，遇到一个断点时，程序会停下来，将控制返回给用户。在断点处，可以查看各个寄存器和存储器。还可以单步跟踪程序，一次执行几条命令，或前进到下一个断点。

下面是一些常用的命令：

开始和停止
  quit                      退出gdb
  run                       运行程序（设置命令行参数）
  kill                      停止程序
断点
  break func                设置断点在func函数入口
  break *0x80483c7          设置断点在地址0x80483c7
  delete 1                  删除断点1
  delete                    删除全部断点
执行
  stepi                     执行一条指令
  stepi n                   执行n条指令
  nexti                     执行一条指令（可以通过子例程调用）
  continue                  恢复执行
  finish                    运行直到当前函数返回
检查代码
  disas                     反汇编当前函数
  disas func                反汇编func函数
  disas 0x80483b7           反汇编在地址0x80483b7附近的函数
  disas 0x80483b7 0x80483c7 反汇编在指定地址范围的代码
  print /x $eip             十六进制打印程序计数器
检查数据
  print $eax                十进制打印%eax的内容
  print /x $eax             十六进制打印%eax的内容
  print /t $eax             二进制打印%eax的内容
  print 0x100               打印0x100的二进制表示
  print /x 100              打印100的十六进制表示
  print /x ($ebp+8)         十六进制打印%ebp+8的内容
  print *(int *) 0xbffff760 打印地址0xbffff760的整数
  print *(int *) ($ebp+8)   打印地址%ebp+8的整数
  x/2w 0xbffff760           检查地址0xbffff760开始的双字（4字节）
  x/20xb func               检查func函数20字节的十六进制表示
有用的信息
  info frame                当前栈帧的信息
  info registers            全部寄存器的值
  help                      gdb帮助

mathZHA

关注

0
点赞
踩
19

收藏

觉得还不错? 一键收藏
1
评论
程序的机器级表示

原文在文章1点击打开链接，文章2点击打开链接，还有文章3点击打开链接。（学渣从前天开始看深入理解计算机系统，作为数学党想了解一点计算机知识的框架，此外豆瓣的书评在这里->点击这里打开链接。看到第三章有这么一句：传递指令的两个操作数不能都指向存储器位置，不懂，就搜搜了发现几篇文章，先复制过来，留着慢慢看）。文章1x86主要寄存器程序计数器(32位,%eip)：PC整数
复制链接

扫一扫