最近评论
正在载入评论列表...
这个附录主要讨论高级语言中最常见的逻辑和控制流结构，并讲述在IA-32汇编语言中的实现。我的主要目的是给出一些在逆向IA-32汇编语言代码时常会遇到的一些典型的汇编代码序列供大家查询。
本附录首先详细阐述了IA-32汇编语言中的逻辑，其中包括操作数是如何比较的、以及条件转移指令是怎样使用不同的条件代码的。接下来，我详细介绍了各种常用的控制流构造，其中包括循环和一些不同的条件块，并举例说明它们在汇编语言中是怎样实现。其后的在第A.3节中讨论了非分支逻辑，并阐述了最常见的非分支逻辑代码序列。最后，我简要地讨论了工作集调整（working-set tuning）对Windows应用程序的逆向过程的影响。
A.1 理解低层逻辑
软件中将普通的袖珍计算器与发展成熟的计算机区别开来的最基本要素是执行逻辑指令和条件指令代码序列的能力。下面一节将讲述逆向工程中最常见的低层逻辑构造，并解
释它们确切的意思。我们首先看一下汇编语言中比较两个操作数的过程，这是相当重要的构造块，几乎在所有的逻辑语句中都要用到它。然后，我们接着讨论IA-32汇编语言中的条件代码，指令集里的每一个条件指令都会用到这些条件代码。
A.1.1 较操作数
绝大多数的逻辑语句都涉及对二个或者二个以上的操作数进行比较。通常，比较指令的后面会跟着一串指令，它们会根据比较结果的不同而执行不同的指令。下面几节将讲述IA-32汇编语言中的比较操作机制。对于有符号数和无符号数的比较来说，这一机制略有不同。
比较两个操作数的基本指令是CMP指令。CMP指令本质上来说就是用第一个操作数减去第二个操作数，并丢弃运算结果。只要改变处理器的标志位，这样就可以根据标志位决定下面应该执行哪一条指令。和其他许多指令一样，标志位的变化会随操作数的不同（有符号数还是无符号数）而不同。
如果你对IA-32中的标志位的细节还不是十分熟悉，那么我强烈建议你在继续读下去之前先看一下附录B中“算术标志位（Arithmetic Flags）”一节。
有符号比较
表A.1给出了用CMP指令比较两个有符号数的特性，记住：这张表同样适用于SUB指令（CMP实际上执行的是减法操作）。
表A.1 CMP指令和SUB指令的有符号数减法输出表（X表示左操作数，Y表示右操作数）
|
左操作数 |
右操作数 |
两个操作数的关系 |
影响的标志位 |
注 释 |
|
X >= 0 |
Y >= 0 |
X = Y |
OF=0 SF=0 ZF=1 |
因为两个操作数相等，所以结果为0 |
|
X > 0 |
Y >= 0 |
X > Y |
OF=0 SF=0 ZF=0 |
标志位都为0，表示减法结果为正，并且没有溢出 |
续表
|
左操作数 |
右操作数 |
两个操作数的关系 |
影响的标志位 |
注 释 |
|
X < 0 |
Y < 0 |
X > Y |
OF=0 SF=0 ZF=0 |
和前一个的情况一样，只是X和Y都是负整数 |
|
X > 0 |
Y > 0 |
X < Y |
OF=0 SF=1 ZF=0 |
SF为1表示（X－Y）的结果为负数，加上OF为0，表示Y大于X |
|
X < 0 |
Y >= 0 |
X < Y |
OF=0 SF=1 ZF=0 |
和前一个的情况是一样的，只是X是负数而Y是正数。还有，SF＝1和OF＝0两者结合起来表示Y大于X |
|
X < 0 |
Y > 0 |
X < Y |
OF=1 SF=0 ZF=0 |
这又是一种X是负数、Y是正数的情况，但是产生了溢出，并且结果为正 |
|
X > 0 |
Y < 0 |
X > Y |
OF=1 SF=1 ZF=0 |
当X是正数而Y是一个绝对值足够大的负数，结果产生了正溢出，OF和SF都被置1了 |
通过查看表A.1，我们清楚地了解了识别有符号整型数比较操作所得结果的基本规则。下面简单地总结了这些基本的规则：
, 任何时候只要标志位ZF被置1，就表明减法运算的结果为0，即两个操作数相等。
, 如果这三个标志位都为0，则表明第一个操作数比第二个操作数大，减法操作得到的结果为正，并且没有溢出。
, 当结果为负并且没有溢出（SF＝1且OF＝0），表明第二个操作数比第一个操作数大。
, 当产生溢出且结果为正，则可以肯定第二个操作数比第一个操作数大，因为实际上得到的结果为负，只是这个结果太小而使得目标操作数无法表示（因此产生了溢出）。
, 当产生了溢出并且结果为负，则第一个数一定比第二个数大，因为实际上得到的是一个非常大的正数结果（因此也产生了溢出）。
事实上没有必要背诵这两张比较输出表（表A.1和A.2），你只要把这两张表多看几遍，并确保正确理解了操作数比较过程是怎样影响标志位的就可以了。当代码中没有按照常规方法来使用标志位的时候，理解标志位在比较操作数中的变化就显得非常重要了。另外，了解在比较和减法指令中是怎样设置标志位的能够帮助你正确理解指令序列以及快速解读它们的含义。
无符号数的比较
表A.2给出了用CMP指令对两个无符号操作数进行比较对标志位的影响。和表A.1一样，这张表也适用于SUB（减法）指令。
表A.2 CMP指令和SUB指令的无符号数减法的输出表（X表示左操作数，Y表示右操作数）
|
两个操作数的关系 |
影响的标志位 |
注 释 |
|
X = Y |
CF=0 ZF=1 |
两个操作数相等，因此结果为0 |
|
X < Y |
CF=1 ZF=0 |
Y大于X，所以结果小于0，产生了溢出（CF＝1） |
|
X > Y |
CF=0 ZF=0 |
X大于Y，所以结果大于0，没有溢出（CF＝0） |
表A.2清楚地给出了无符号整型数进行比较运算所得结果的基本规则。显然，操作无符号数更简单一些。下面把这些规则总结一下：
, 不管在什么情况下，只要ZF＝1，就表示减法操作的结果为0，也就意味着进行比较的两个操作数相等。
, 当两个标志位都为0时，说明第一个操作数比第二个操作数大，因为比较的结果为正，且没有溢出。
, 当比较的结果产生溢出时，可以肯定第二个操作数比第一个操作数大，因为比较结果是一个非常小的数，使得目标操作数无法表示出来。
A.1.2 条件代码（Conditional Codes）
条件代码指的是附加在某些条件指令之后用来定义指令执行的代码。
对于一个逆向工作者来说理解条件代码是非常重要的，因为实际上每个条件代码序列都会涉及一个或多个条件代码。有时这些条件指令的意义是很直观的，请看下面的代码：
在这个例子中，很明显，如果EAX寄存器中的数等于7的话，JE（如果相等就跳转）指令就会使指令流跳转到SomePlace。这个例子太简单了，你甚至不需要理解CMP指令及条件码的具体细节就能看懂它。但是对于我们这些逆向工作者来说就很不幸了，我们所遇到的条件代码中只有很少一部分用这种直观的方式给出的。理解条件代码是怎样使用标志位的对于正确理解程序的逻辑是非常重要的。下面几节中我们将列举每一种条件代码，并解释它们用到了哪些标志位以及为什么要用这些标志位。
下面几节中列出的都是单独的条件代码，而实际上条件代码通常是作为条件指令后缀使用的。条件代码是不能单独使用。
有符号数条件代码
表A.3列出了IA-32中用于有符号操作数的条件代码。需要指出的是：所有的有符号数的溢出都是通过溢出标志位OF（overflow flag）检测的。这是因为算术指令是用OF标
志位来指示溢出的。
表A.3 CMP指令和SUB指令的有符号数条件代码表
|
助记符 |
标志位 |
满足条件 |
注 解 |
|
If Greater (G) If Not Less or Equal (NLE) |
ZF = 0 且 ((OF=0 且 SF = 0) 或 (OF = 1 AND SF = 1)) |
X>Y |
用ZF标志位来确定两个操作数不相等。同时使用SF标志位测试结果是无溢出的正结果还是有溢出的负结果。如果是后一种情况则表明第二个操作数是一个很小的负整数，使得减法的结果太大导致目的操作数无法表示（因此产生溢出） |
|
If Greater or Equal(GE) If Not Less (NL) |
(OF = 0 且 SF = 0) 或 (OF = 1 且 SF = 1) |
X>＝Y |
与前面的条件代码类似，只是它不测试ZF标志位，所以当两个操作数相等时也满足该条件代码 |
|
If Less (L) If Not Greater or Equal (NGE) |
(OF = 1 且 SF = 0) 或 (OF = 1 且 SF = 1) |
X<Y |
如果OF＝1且SF＝0，则表明X比Y小，而且结果太小以至于目的操作数无法表达（你得到的是有溢出的正结果）。另一种情况是OF＝0且SF＝1，同样表示X比Y小，只是结果是一个没有溢出的负数 |
续表
|
助记符 |
标志位 |
满足条件 |
注 解 |
|
If Less or Equal (LE) If Not Greater (NG) |
ZF = 1 或 ((OF = 1 且 SF = 0) 或 (OF = 0 AND SF = 1)) |
X<＝Y |
与上前一个条件代码情况差不多，只是还要测试ZF标志位，因此如果两个操作数相等的话也满足该条件代码 |
无符号数的条件代码
表A.4给出了IA-32为无符号数意义的条件代码。要注意，在所有的无符号数条件代码中，溢出都是用进位标志位CF（carry flag），这是因为在算术指令中无符号数的运算结果是否溢出是用CF标志位来表示的。
表A.4 无符号数的条件代码
|
助记符 |
标志位 |
满足条件 |
注 解 |
|
If Above (A) If Not Below or Equal (NBE) |
CF = 0 且 ZF = 0 |
X > Y |
使用CF标志位来确定第二个操作数是不大于第一个操作数大（因为比第一个操作数大则ZF会被置1），同时用ZF标志位来确认两个操作数相等 |
|
If Above or Equal (AE) If Not Below (NB) If Not Carry (NC) |
CF = 0 |
X >= Y |
与上面的条件代码类似，只是这里只检测CF标志位，因此当两个操作数相等时也满足该条件代码 |
|
If Below (B) If Not Above or Equal (NAE) If Carry (C) |
CF = 1 |
X < Y |
如果CF被置1，我们知道此时第二个操作数比第一个大，因为溢出就表示结果为负 |
续表
|
助记符 |
标志位 |
满足条件 |
注 解 |
|
If Below or Equal (BE) If Not Above (NA) |
CF = 1 或 ZF = 1 |
X <= Y |
和上面的条件代码一样，只是还要测试ZF标志位，因此两个操作数相等的情况也满足该条件代码 |
|
If Equal (E) If Zero (Z) |
ZF = 1 |
X = Y |
ZF被置1，我们知道结果肯定是0，即两个操作数相等 |
|
If Not Equal (NE) ZF=0 If Not Zero (NZ) |
ZF = 0 |
Z != Y |
如果ZF被清0，我们知道结果为非零，即两个操作数不相等 |
A.2 控制流和程序
计算机程序中绝大多数逻辑是利用分支来实现的。分支是最常见的程序构造，不管是不是用高级语言。程序测试一个或多个逻辑条件，并根据测试的结果转移到程序的不同部分去执行。识别出分支并其含义及目的是最基本的代码级逆向工程任务之一。
接下来的几小节将介绍最常见的控制流构造以及程序布局。我们将从一个例程的讨论开始，讨论它在汇编语言中是怎样表示的，然后讨论最常见的控制流构造，并比较高级语言中表示和低级语言中表示的区别。这里讨论的控制流构造有：单分支条件语句，双分支条件语句，多分支条件语句以及循环等。
A.2.1 解密函数
程序中最基本的构架块是例程，或者说函数。从逆向工程的观点来看，函数是很容易辩识的，因为函数都拥有“序言（prologues）”和“尾声（epilogues）”。编译器会给几乎所
有的函数都加上标准的初始化序列。这些初始化的具体代码与你使用的编译器有关，也与其他因素比如调用约定有关。调用约定将在附录C中讨论。
在IA-32处理器中，函数几乎都是使用CALL指令来调用的。CALL指令将当前的指令指针压入堆栈，然后跳转向该函数的地址。利用CALL指令，我们可以很容易地把函数调用和其他无条件跳转指令区别开来。
内部函数
当被调函数的实现代码与主调函数在同一个二进制可执行文件中时，被调函数即为内部函数。当编译器为一个内部函数生成调用代码时，通常直接把被调函数的地址嵌入到代码中。因此，我们可以很容易地识别出内部函数。下面是一个常见的内部函数调用的例子。
导入函数
当一个模块调用了在另外一个二进制可执行模块中实现的函数的时候，就发生了导入函数调用。导入函数调用非常重要，因为在编译过程中，编译器无法确定到哪里找导入函数，所以无法把导入函数的地址直接嵌入代码中（像处理内部函数那样）。
通常，导入函数的调用是通过使用导入目录（Import Directory）和导入地址表（Import Address Table，IAT）来实现的（详见第3章）。导入目录是在运行时使用的，用它来解析函数名（即在目标可执行模块中匹配函数）。IAT则用来存放目标函数的真实地址。主调函数可以从IAT中加载函数的指针对函数进行调用。下面的例子是一个典型的导入函数调用：
注意在指针前面的“DWORD PTR”——这个修饰词很重要，因为它告诉CPU不是跳转到IAT_Pointer的地址上去，而是跳转到IAT_Pointer所指向的地址上去。另外，还要记住的是这个指针通常不会有名字（当然这取决于所用的反编译器），通常只是一个指向IAT的地址。
识别导入函数调用比较简单，这是因为除了这种类型的调用外，其他函数极少会使用一个硬编码函数指针间接调用。但是，我还是建议大家在逆向的早期就确定IAT的位置，并用它来确认函数是不是导入的。定位IAT相当容易，而且可以用各种各样的工具来定位
IAT（转储模块的PE头部并给出IAT的地址）。关于用于储可执行模块PE头部的工具，见第4章。
另外还有一些反汇编器和调试器可以自动地指出导出函数调用（通过在内部检测IAT地址），这样一来你就省去了找导入函数调用的麻烦了。
A.2.2 单分支条件
在大多数程序中，逻辑的最基本形式是由一个条件和一个紧随其后的分支条件组成。在高级语言中，程序员写一条带有条件的if语句和一段满足该条件时就会执行的条件代码块。下面是一个简单的例子：
从低级语言的角度来看，实现这一语句需要一个逻辑测试来判断SomeVariable的值是不是0，如果SomeVariable的值不是0，就执行一个条件跳转跳过这个条件代码块。图A.1描述了这一代码片断对应到汇编语言中的样子。
图A.1中的汇编代码使用TEST指令测试EAX寄存器中的值是否为0。这里TEST指令所执行的是将EAX寄存器与自己进行按位“AND”操作，并根据AND的结果设置标志位（AND的结果被舍弃了）。这是一种测试EAX寄存器中的值是否为0的比较高效的方法，因为TEST指令会根据按位AND操作的结果设置零标志位ZF（zero flag）。注意这里的条件被取反了：在源代码中，程序测试的是SomeVariable等于0是否成立，但是编译器把条件取反了，因此条件指令（在这里是一个跳转指令）测试的是SomeVariable为非零是否成立。我们是从编译器生成的二进制代码在内存中组织的顺序与它在源代码中的顺序一样这个事实推断出来这一结论的。因此，如果SomeVariable的值为非零，那么编译器就必须跳过条件语句块、直接执行其后的代码。
结论是：在单分支条件语句中，你必须要逆向出条件跳转的含义，才能弄清楚真正的高级逻辑意图。
图A.1 单分支条件代码序列的高级语言/低级语言视图
A.2.3 双分支条件
高级语言的另一项基本功能是允许程序员使用双分支条件语句。在高级语言中，最典型的就是使用if-else这对关键字（keyword pair）来实现双分支条件。双分支条件与单分支条件的区别在于：当if语句中的条件不满足时，双分支条件语句要执行另一个代码块，执行完之后才会去执行“if-else”语句后面的代码。之所以把这种结构称为双分支条件，是因为程序流被分成了两条可能的路径：一条是“if”块，另一条是“else”块。
我们简单看一下编译器是如何编译双分支条件语句的。首先，在双分支条件中，分支条件指向的是“else”块，而不是指向条件语句后边接着的代码。其次，条件本身几乎总是被取反（因此只有在条件不满足时才会跳转到“else”语句块），而主条件块（primary conditional block，即指if块）就放在条件跳转之后（因此当条件满足时就会执行这段条件代码）。条件块总是以一个无条件跳转结束，这样就跳过了“else”语句块——这是一个很好的识别双分支条件语句的标志。“else”块放在条件块末尾，紧接着无条件跳转之后。图A.2展示了普通的if-else语句在汇编语言中的样子。
图A.2 双分支条件的高级语言/低级语言视图。
注意无条件JMP正好就在函数调用之后。第一个条件就是从这个地方跳过else块转而执行后面的代码的。在反汇编程序中辨认简单的“if-else”条件语句的基本模式是：确定紧跟在条件语句块后面的代码是不是以一个无条件跳转语句结束。
大多数高级语言还支持一种略微复杂的双分支条件语句，即两个代码块要各用一个独立的条件语句。这通常是将“if”和“else if”两个关键词组合使用来实现的（“if”和“else if”各用一个独立的条件语句）。这样，如果不满足第一个条件，程序就跳转到第二个条件语句并测试这个条件，如果两个条件都不满足，程序就直接跳过整个条件块。如果满足了其中的一个条件，程序就会执行相应的条件块，执行完后接着执行下一个程序语句。图A.3给出了这种控制流构造的高级语言/低级语言视图。
A.2.4 多选一条件
有时候，程序员会写一些很长的有多个条件的语句，满足不同的条件就会执行不同的代码块。高级语言中实现多选一条件语句的其中一个方法就是使用“switch”语句块（我们稍后讨论它），当然，也可以使用常规的“if”语句块来实现。程序员有时候必须使用“if”语句块的原因是“if”语句使我们能够实现更加灵活的条件语句。“switch”语句块实现不了复杂的条件，只能使用硬编码的常量。相对于switch语句，一连串的“else-if”语句允许你对每一个块使用任意复杂的条件——的确灵活多了。
图A.3 有两个条件语句的双分支条件的高级语言/低级语言视图。
识别多选一条件块的基本方法与上一节中识别普通的双分支条件块的方法非常相似，区别就在于是编译器添加了额外的“可选块”，可选块由一个或多个逻辑测试、真正的条件代码块、以及可以跳转到整个多选一条件块结束处的JMP指令组成。当然只有在条件满足的情况下才会执行JMP指令。“switch”块几种条件可以共用同一代码块。与“switch”块不同，“else-if”块中每个条件对应一个代码块。图A.4展示了一个四条分支条件代码序列，其中包括一个“if”条件块和三个备选的“else-if”路径。
A.2.5 复合条件
在实际的程序中，程序员经常会在一个条件判断语句中使用多个条件。在决定是否执行某个条件代码块之前要测试两个或者更多的条件，这种情况是非常常见的。对于逆向者来说，这样的代码解读起来难度就比较大了，因为为逻辑测试组合（combination of logical checks）生成的低级语言代码通常都比较难解读。下面几节中我们将介绍几种典型的复合条件以及怎样解读它们。我们先讨论构建复合条件的几个最常见的逻辑运算符，然后再从低级语言和高级语言的角度讲解几种不同的复合条件块。
图A.4 多选一执行路径条件代码的高级语言/低级语言视图
逻辑运算符
高级语言中有专门的操作符，这种操作符允许程序员在单个条件语句中使用复合条件。当要判断条件不止一个时，代码必须指明多个条件是怎样组合在一起的。
组合多个逻辑语句最常用的操作符是AND（与）和OR（或）操作符（你可不要把按位逻辑操作符混作一谈）。
顾名思义，AND（在C和C＋＋中记为“&&”）就是两个条件都必须满足整个条件才
会被认为是“真”。在汇编语言中识别这样的代码通常比较容易，因为你会看到两个连续的条件都根据条件跳转到同一个地方。下面是一个简单的例子：
在这个代码片断中，两个条件跳转都指向同一个代码地址（AfterCondition），这一事实揭示了这是一个组合逻辑条件。这段代码的思路很简单：首先测试第一个条件，如果不满足就直接跳转到AfterCondition的地址；如果满足第一个条件，才会测试第二个条件，如果不满足则还是跳转到AfterCondition的地址。条件代码块就放在第二个条件分支之后（因此如果在两个跳转都没有执行的时候就可以立即执行条件代码块）。解读真正的复合条件和前边讲的单分支条件的思路是一样的，它们的测试条件也被取反了。在这个例子里，测试Variable1的值“不等于100”就是原始代码中测试Variable1的值是否“等于100”。基于这些信息，你就可以重构出这个代码片断的源代码了：
图A.5展示了上面的高级语言代码（High-Level Code）与前面的汇编语言代码（Assembly Language Code）的映射关系。
图A.5 用AND操作符组合两个条件的复合条件语句的高级语言/低级语言视图
另一个常用的逻辑操作符是OR操作符，OR操作符的含义是只要其中的一个条件满足整个复合条件就成立。OR操作符的意思是如果第一个条件满足或是第二个条件满足整个复合条件语句就满足。在C和C++语言中OR操作符是用“||”符号来表示的。在逆向过程中，判断包含OR操作符的条件语句要比判断AND操作符的条件代码略微复杂一些。实现OR操作符的直接方法是对每个条件（这里不对条件取反）使用一个条件跳转，并加一个跳过整个条件代码块（在两个条件都不满足的情况下）的跳转指令。下面是这种复合条件的例子：
图A.6展示了前面的代码片断与原来的源代码之间的映射关系。
图A.6 用OR操作符组合两个条件的复合条件语句的高级语言/低级语言视图
跟前面一样，这段代码中最值得注意的是条件跳转指令都指向相同的代码。你要记住的是，OR复合逻辑的条件跳转实际指向的是条件代码块（与我们前面讨论的AND复合逻辑恰恰相反，AND复合逻辑的条件跳转指向的是条件代码块之后的代码）。GCC和其他几个编译器都采用这种方法，这种方法的好处在于（至少从逆向工程的角度来看）相当易读和直观。但它的运行性能要差一些，因为只有所有条件都不满足才会执行到最后那条JMP指令。
其他一些带有优化功能的编译器，如Microsoft的编译器采用了一种略有不同的方法来实现OR操作符，从而避免了这个额外的JMP指令的问题。Microsoft的思路是：只将第二个测试条件取反，并让它指向条件代码块之后的代码，而第一个测试条件仍然指向条件代码块本身。图A.7图解了在使用这种方法进行编译的情况下，同一个逻辑会变成什么样子。
第一个条件测试了Variable1是否“等于100”，这和它在源代码中的测试条件是一样的。第二个条件测试了Variable2是否“不等于50”。这样做是因为我们希望第一个条件满足时就执行条件代码，第二个条件（被取反了）满足时不执行跳转。在第二个条件不满足时，程序就跳过条件代码块。
|
图A.7 采用更高效的OR操作符版本来组合两个条件的高级语言/低级语言视图
简单的条件组合
如果碰到用逻辑操作符组合两个以上测试条件的情况下会是怎样的呢？通常，这种情况只是在处理只有两个条件的情况下所使用策略的扩展。对于GCC编译器来说，只是在那句无条件跳转指令之前再加一个条件测试罢了。
在图A.8中所示的代码片断中，Variable1、Variable2与前边例子中相同的数值进行了比较，只是这里我们还要让Variable3和0进行比较。只要所有的测试条件都是用OR操作符连接的，编译器就会简单地再加一条指向条件块的条件跳转。与前边的情况一样，编译器总是在紧接着最后的条件分支指令之后放置一条无条件跳转指令。这条无条件跳转指令会在所有条件都不满足的情况下跳过条件块、直接到达条件块之后的代码的。
对于一些编译优化技术来说（对Microsoft等编译器而言），方法是一样的，只是不使用无条件跳转，只将最后一个测试条件取反。其余的测试条件都直接以指向条件代码块的直接条件跳转来实现。图A.9给出了采用第二种技术来编译图A.8中的代码的结果。
图A.8 采用OR操作符组合三个条件的复合条件语句的高级语言/低级语言视图
图A.9 采用更高效的OR操作符版本组合三个条件的条件语句的高级语言/低级语言视图
其思路很简单。当同时使用多个OR操作符时，编译器会产生多个连续的条件跳转，每个条件跳转在条件满足的情况下都跳向条件代码块。最后一个条件被取反了，如果这个条件满足的话就跳转到条件代码块之后的代码执行，因此，如果原条件（未被取反的条件）满足的话，就不会执行跳转，而是执行最后一个条件跳转后面紧接着的条件代码块。在前面的范例中，最后一个检验测试的是“Variable3不等于0”是否成立，所以这里使用了JE指令。
下面我们来看看用AND操作符组合多于两个的测试条件的情况下会怎样（见图A.10）。在这种情况下，编译器只是增加了更多的取反了的测试条件，当它们满足的时候就跳过条件代码块（记住测试条件被取反了），如果不满足就继续测试下一个条件（或者如果是最后一个测试条件的话就转向条件代码块本身执行）。
复杂的条件组合
高级程序设计语言允许程序员使用多个逻辑操作符组合任意多个测试条件。这就是说程序员可以创建全是用逻辑操作符组合的复杂条件语句组合。
图A.10 采用AND操作符组合的三个条件的复合条件语句的高级语言/低级语言视图
程序员可以使用的测试条件组合数不胜数，我们不可能把每一个都讲一遍。相反，我们简单看一个组合的例子，并试着找出正确解读这类语句的总的原则。
这个例子与前面使用OR逻辑操作符（优化后的）的代码完全相同，只是增加了一个测试Variable3是否等于0的条件。如果Variable3等于0，则不执行条件代码块。下面是这段汇编语言代码在高级语言中的表示。
要确定出阅读汇编语言表示的复杂条件组合的通用方法并非一件容易的事情，但是，阅读过程中我们要找的最基本的要素是每个条件分支跳向的目标地址。使用OR操作符的复合条件通常会直接跳转到条件代码块，并且不需要对测试条件取反（除了最后一个测试条件，它指向的是条件代码块后面的代码，因此要取反）。比较来看，使用AND操作符的复合条件中，测试条件会被取反，并且在测试条件成立的情况下都跳转到条件代码块后面的代码块执行。在分析复杂的复合条件语句时，你必须使用这些基本的规则来试着解读每个测试条件，并理解它们之间是怎样连接的。
A.2.6 n-路分支条件（Switch块）
Switch块（或者称为n-路分支条件块）常常用于同一个操作数取得不同值的时候需要采用不同的操作的情况。Switch语句块实质上是让程序员创建有关所有可能的取值以及相应的响应代码的表。需要注意的是，一段响应代码可以对应多个取值。
编译器有几种处理Switch语句的方法，具体使用哪一种方法取决于Switch块的大小以及接收取值的范围。下面几节中我们将介绍两种最常见的n-路分支的实现：表实现和树实现。
表实现
对大型Switch块来说最高效的实现方法（从运行时的观点来看）是生成指针表。表实现的思路是：编译Switch语句中的每个代码块，并把指向每一个代码块的指针记录到指针表中。之后，在Switch块执行的时候，Switch块所操作的操作数就被用作指针表的索引，处理器就根据操作数的取值跳到正确的代码块。要注意的是，这个过程并不是函数调用，而是一个经过指针表的无条件跳转。
指针表通常放在包含该Switch块的函数之后，但并非总是如此——这取决于所采用的编译器。当有一个函数表放在代码区（code section）的中间时，你基本可以确信这就是一张Switch块的指针表。实际上，代码区内的硬编码指针表并不常见。
图A.11演示了怎样用指针表实现n-路分支条件。源代码中第一个case常量是1（一个case常量对应一种情况），最后一个case常量是5，所以指针表中应该支持5个不同的case块。其中default块并没有作为指针表的一部分实现，因为default块没有具体的触发值——任何一个不在1到5之间的取值都会导致程序跳转到default块执行。为了实现高效的指针
表查找，编译器把ByteValue的值减去1后再与4进行比较。如果ByteValue的值大于4，编译器将无条件的跳转到default块执行。否则，编译器直接执行相应的跳转到具体的条件块的无条件JMP指令。这条JMP指令是基于表实现的n-路分支条件中最独特的地方，它使得我们在逆向过程中能够更容易地识别出代码中的n-路分支条件。不同于你在逆向中常常碰到的其他无条件跳转所采用的立即硬编码地址，这种类型的JMP指令采用了动态计算内存地址，（在反汇编代码中这个地址通常是用括号括起来的）的方法来获取目标地址（这实际上是表查找操作）。
当你查看每个条件块的代码时，注意一下每个条件cases都以一个无条件JMP指令结束，该JMP指令的功能是跳转到Switch块之后的代码执行。有一个例外的情况，即case #3，它不是以break指令结束的。这表明当执行完case #3后，程序会直接转向case #4。在使用表实现的情况下这会顺利地执行下去，因为编译器是按照顺序在内存中存放各个case的。Case #4的代码总是放在紧接着case #3之后的位置，这样编译器就可以避免执行无条件JMP指令。
树实现
当Switch块的分支条件并不适合用表实现的话，编译器会采用二叉树搜索策略来尽可能快地找到要找的单元。二叉树搜索是计算机科学中的一个基本概念。
基于表实现的n-路分支条件的取值范围
通常情况下，当你遇到一个完全是用单独的跳转表实现的Switch块时，你可以放心地假定在源代码中这个Switch块的各个case常数之间的数值间距非常小。如果这些常数之间的间距很大，表实现会浪费很多内存，因为这个表要包含很多无用的单元，从而使表变得很大。不过，有时候编译器可能会为一个Switch块创建几张表，并在每张表中存放取值比较接近的一组case的地址。如果Switch块中各个case常数之间较大间距的情况不太多的话，这一方案还是比较有效的。
图A.11 Switch块的表实现
二叉树实现的基本思路是：根据要查找项的取值大小将它们分成个数基本相同的两组，并记录每一组的取值范围。对每一组再重复这个分组过程，直至分到单独的项为止。在查找的时候，你首先确定你要找的值在两个大组中的哪一个（表明那个组中会包含你要找的项）。然后，你再在前一步确定的组内确定哪个子组中会包含你要找的项，就这样不断重复，直到找到你要找的项。
要用二叉树实现Switch块，编译器必须首先把Switch块表示成二叉树。它的基本思路是：由编译器会在生成的代码的时候首先测试给定值是在第一组中还是第二组中，而不是在运行时用这个给定值与每一个可能的case进行比较。然后编译器跳转到另一个代码区，与这个稍小一点的子组（subgroup）里的值进行测试比较。这一过程将一直重复进行，直至找到正确的项或者退出了条件块（如果没有找到和要找的值匹配的case的话）。
我们来看一下这段用C语言实现的Switch块，并考察一下编译器是怎样将它变换成二叉树的。
图A.12演示了编译器是怎样把前面的Switch块转化成二叉树的，并给出了编译器为实现每个二叉树结点所生成的汇编语言代码。
图A.12 Switch块的树实现以及汇编语言代码
基于树实现的n-路分支条件有一个独特的特点——要对一个寄存器执行多次减法，这一点使得我们在阅读反汇编代码时比较容易识别出它。这些减法的后面通常跟着的是跳向特定case块的条件跳转（你可以在图A.12中的“501_Or_Below”case中清楚地看到这种布局）。编译器通常从传给条件块的原始值开始，逐渐从原始值中减去某些值（这些值通常都是case块的值），并不断测试结果是不是为0。这是用最少的代码来确定要跳转到哪一个case块的一种高效的方法。
A.2.7 循环
你可以把循环看作是我们前边讨论过的条件代码块，只不过它是不断地重复执行直到条件不再满足为止。循环通常（而不是总是）会包含一个某种类型的计数器，用以控制离循环结束还剩多少次迭代。基本上任何一种高级语言的循环都可以分为两类：先测试循环（pretested loops，其逻辑测试在循环体之前，“循环体”的代码会被重复执行）和后测试循环（posttestd loops，逻辑测试在循环体之后）。
让我们来看看这些类型循环，并考察一下它们在汇编语言中是怎么表示。
先测试循环
尽管先测试循环在效率上要比后测试循环稍稍差一些，但是它可能是使用得最广泛的循环构造。先测试循环的效率稍差的原因是：汇编语言代码必须用两个跳转指令来表示一个先测试循环，一个是在循环一开始的条件分支指令（当该条件不再满足时就终止循环），另一个是在循环结尾处的无条件跳转指令——用来跳转回循环的开始处。我们来看一个简单的先测试循环的例子，看看编译器是怎样实现它的：
你可以容易地看出这是一个先测试循环，因为在循环的开始处先测试了c是不是小于1000，然后才开始执行循环体。大多数编译器编译前面这段代码都会生成下面的汇编语言代码：
好像尽管源代码中测试条件位于循环体之前，编译器认为把它的位置换一下比较合适。这是因为在循环之后再测试计数器会在性能上会稍有提高（相对比较小）。就像我所解释的那样，把先测试循环改成后测试循环意味着编译器可以去掉循环结尾处的无条件JMP指令。
这个后测试循环实现中存在一个潜在的危险。如果计数器从一个越界的值（out-of-bounds value）开始计数会怎样？这可能会导致各种问题，因为循环体使用循环计数器来访问数组。程序员希望在循环体执行之前就测试条件，而不是之后！但是在这个例子中不会产生这种问题，因为计数器在循环开始之前就被显式地初始化为0了，编译器知道这个值是0，没有测试的必要。如果计数器的值来自一个未知的数据源（比如说是从一个其他未知的函数传递过来的一个参数），编译器可能就得把逻辑测试放在原来的位置：这段代码开始的位置。
我们来试着把前面的C语言循环中的计数器c改成一个外部传入的值，并重新编译这个循环。这种情况下Microsoft编译器的输出结果如下：
看来，在这种情况下编译器还要尽量避免使用这两个跳转指令。编译器并没有把比较指令放在循环的开始处，也没有在结尾处加无条件跳转指令，它几乎还维持原样，只是在循环的开始处加了另一个测试条件。这个在循环开始之前的测试（这个条件只测试一次，因为它不在循环体内）可以确保在计数器的值是非法的情况下不进入循环。循环的其余部分都维持原样。
我们这里讨论这个特例，是为了说明“for”循环就等效于我们这里所讲的先测试循环。
后测试循环
如果在高级语言中直接实现后测试循环，而编译器生成的也是后测试循环，那么会对最终的汇编语言代码产生什么样的影响呢？毫不意外——影响非常小。
当程序中有一个“do…while()：循环时，编译器会生成一段和前面小节中的代码序列非常相似的代码。唯一的区别就是：用“do…while()”循环编译器就不必担心在第一次循环中循环测试条件是否满足了。它被放在了循环的末尾，因此必须在循环的末尾进行测试。上一种情况下我们将计算器的初始值改为一个未知的值，从而使得编译器在循环开始处增加了一条测试指令，“do…while()”循环是不需要这样做的。这就是说后测试循环的测试逻辑总是放在循环体之后，与其在源代码中的位置是一致的。
循环跳出条件
循环跳出（Loop Break）指的是循环体内部的代码把循环结束（在C和C++语言中使用break关键字来实现循环跳出），其跳出所满足的条件即为循环跳出条件。break关键字的作用就是中断循环，并跳转到循环体之后的代码。下面是在前面代码的基础上加入了一句break语句后的汇编代码：
这段代码与上一例略有不同，因为尽管计数器还是来自于一个未知的数据源，但却只是在循环的结尾处测试了它的值。这就表明它是一个后测试循环。另外，代码中还加了一个新的测试：在初始化当前数组元素之前检查它是不是为0，如果它为“非零”，则跳转到
AfterLoop。这就是那条break语句——这个名字比过去在少数几种程序设计语言中曾经非常流行的goto命令更好听些。
由此，你可以很容易地推断出其源代码的基本样子：
循环跳过本次循环语句
在C和C++语言中跳过本次循环的语句是用continue关键字来实现的。该语句跳过循环当前的迭代操作，直接跳转到循环的条件语句判断是否要执行下一次迭代，还是直接推出循环。循环的计数器（如果用到计数器的话）通常不会进行增量运算，因为实现计数器增量运算的代码会和循环体的其余部分一起被跳过了，当然，具体情况还取决于循环的类型。这也是for循环与while循环的区别之一。在for循环中，实现计数器增量运算的代码被当作是循环逻辑语句的一部分，因此在for循环中的continue不会跳过计数器增量运算代码的。我们来看看下面这段编译器为一个带有跳过本次循环的循环结构生成的汇编语言代码：
这段代码和你在前边例子中看见的代码基本上是一样的，只是用continue命令代替了break命令。注意一下条件语句是怎样跳转到NextCycle并跳过计数器的增量运算的。然后这段程序测试了计数器的值，如果计数器小于1000的话，则跳回到循环开始处继续循环。
下面是稍做修改后的代码：
这里唯一的不同点在于：NextCycle位置被提前了，放在了计数器增量运算代码的前面。这就是说这段代码与前面代码不一样了，continue语句会让计数器先做增量运算再执行循环逻辑。这意味着这个循环可能是用for关键词实现的。实现这种类型的循环代码当然也可以不用for循环，比如用while或者“do…while”循环并将计数器增量运算放在条件语句内（使用了“++”操作符）。这样的话，逻辑语句可能会是这样：
循环展开
循环展开（Loop Unrolling）是一种代码级整形（code-shaping）的优化技术，该技术不依赖于任何具体的CPU和指令集，也就是说它实际上是一种以生成更加高效的机器码为目标的高级代码重构技术。下面这段汇编语言代码是一个部分展开的循环：
这个循环显然是一个部分展开的循环，最明显的标志就是每次迭代中计数器会增加3。
实际上，编译器所做的就是将循环体复制了三次，因此，每次迭代事实上完成的是三次迭代的工作而不是一次。计数器的增量运算代码也被改为每迭代一次增加3而不是1。这大大提高了代码的执行效率，因为循环的运行开销被大大地减少了——原来CMP和JL指令要执行0x3e7（即999）次，现在只需执行0x14d（即333）次。
另一种更为大胆的循环展开技术是干脆把循环去掉，要循环几次就将循环体复制几次。当然，这一技术是否可行还取决于迭代的次数（还要在循环展开之前知道迭代的次数）。
A.3 无分支逻辑
一些带有编译优化的编译器具有生成无分支逻辑的特殊优化技术。所有这些技术的主要目标是：在实现给定的逻辑语句时，消除或者至少减少所需的条件跳转。有关为什么要尽可能减少代码中的跳转次数这个问题，我们在第2章中第2.5.2节“现代处理器的硬件执行环境”中已经回答过了。简而言之，处理器管线（processor pipeline）的使用要求处理器在遇到条件跳转时必须要猜测或预测该跳转是否会执行，并根据这一猜测来决定把哪些指令（是紧跟在条件跳转之后的那些指令还是跳转目标地址处的那些指令）加到管线的末尾。如果猜测错误的话，就会将整个管线清空并重新填满接下来要执行的指令。在这些情况下，浪费时间的多少很大程度上取决于处理器的内部设计和管线的长度，但对于大多数应用管线技术的CPU，重新填满管线是一项非常费时的操作。
一些编译器用复杂的算术运算和条件指令来实现特殊的优化方法，再用这些优化方法来消除或减少实现源代码中的逻辑所需的条件转移指令。这种优化技术一般应用于那些根据条件对操作数执行一条或多条算术或赋值操作的代码。其思想是：将两条或者更多的条件执行路径转化为一段顺序执行的算术运算代码，运算的结果不变，但是不需要条件跳转。
常用的编译器优化输出的无分支逻辑主要有两种类型。一种是在不改变运算结果的情况下将逻辑语句转换成纯算术代码。这一技术有很大的局限，只能应用于相对简单的代码序列上。对于逻辑稍微复杂一些的代码，编译器有时就要采用一些特殊的条件指令了（如果目标CPU支持这种特殊的条件指令的话）。实现无分支逻辑的两种主要方法将在接下来几小节中讨论。
A.3.1 纯算术实现
某些逻辑语句可以直接转换成一系列算术运算，根本就不需要使用条件语句。有一些巧妙的数学技巧可以让编译器把源代码中的分支逻辑转换成简单的算术运算序列。考虑一下下面这段代码：
上面这一段由编译器生成的代码在IA-32程序非常常见，很多逆向工程人员都花费了大量的时间去解读它的意思。鉴于这种代码到处可见，你应当好好读一下这段代码，并确保自己完全理解它的工作原理。
这段代码开始第一条指令是将局部变量（EAX寄存器）和0x00001000作一个简单的逻辑“AND（与）”操作，操作结果存放在EAX寄存器中（AND指令通常都将结果存放到第一个操作数中，即左操作数）。然后接着执行了一条NEG指令，这是一条不太常用的指令。NEG是一个简单的取反指令，用来对操作数的算术符号取反——有时候也称它为2的补码（two’s complement。译注：1的补码与NOT指令对应，是逻辑取反指令）。从数学的观点来看，NEG指令执行下面一个简单的操作
这段代码中有趣的是SBB指令。SBB是一条带借位的减法指令，这就是说SBB将第二个操作数（即右操作数）加上标志位CF，然后将结果用第一个操作数来减。下面是SBB的伪代码：
注意前边的代码中将SBB指令用于对同一个操作数执行减运算，即用EAX寄存器减去EAX，如果不考虑标志位CF的话，这条指令在数学上是没有任何意义的。因为将CF加到了第二个操作数上，所以结果只取决于CF。如果“CF == 1”，那么EAX将变成-1。如果“CF == 0”，那么EAX将变成0。显然在第一条NEG指令之后EAX的值就SBB操作无关了。问题是，为什么编译器还要“劳驾”NEG指令呢？
Intel处理器的文档中声明NEG指令除了对操作数作符号取反外，它还要根据操作数的值设置CF标志位的值。如果执行NEG指令时操作数为0，则CF将被置为0。如果操作数
为非零，则CF将被置为1。看上去好像有些编译器喜欢将NEG指令提供的这种附加功能用作测试操作数的值是否为0的一种巧妙的方法。我们快速回顾一下这段代码的每一步：
, 用NEG来测试源操作数是否为0，测试的结果存放在CF标志位中。
, 用SBB指令将结果从CF中取出存放到一个可用的寄存器中。当然，由于SBB指令的性质，如果NEG的源操作数为非0的话，测试结果记录到CF中后再SBB一下，结果就变成了-1而不是1。有些语言用“1”表示True，而其他语言则用“-1”表示True。
, 由于这段代码是C/C++编译器生成的，这两种高级语言都是用“1”表示True的，所以就需要一条NEG指令，只是这次NEG实际上是用来对操作数的符号取反的。如果操作数为“-1”，则将它变为“1”。如果操作数是“0”则保持不变。
下面的伪代码将有助于你更好地理解上面讲述的每一步：
实际上，这段代码所做的就是测试EAX寄存器中的一个特定的位（0x00001000），如果是1则返回1，如果是0则返回0。这真是太妙了，竟然全用的是算术指令——没有用到一条条件指令。我们把这段代码翻译回C语言表示：
可读性更好了，不是吗？作为一名逆向工程人员，我们会经常碰到一些类似这样可读性很差、不会引起人们注意的代码。知道并理解这些底层代码技巧对我们来说非常有用，因为它们在编译器生成的代码中会频繁出现。
下面我们来看另外一个例子，这个例子比前边那个还要复杂些，是一个有关用纯算术运算实现高级逻辑构造的例子。
你应该注意到了这段代码中也使用了NEG/SBB组合，只是这次的功能要更复杂一些。代码一开始调用了一个函数，并将函数的返回值减去4；然后使用NEG和SBB指令来测试结果是不是零，这和你在上一个例子中看到的是一样的。如果SomeFunc函数的返回值减去4后等于0了，SBB指令将把EAX寄存器置为0；如果返回值减去4后为非零，SBB将把EAX置为-1（即十六进制数0xffffffff）。
接下来的两条指令是这段代码中比较巧妙的地方。我们先从那条AND指令说起。因为SBB指令将会把EAX寄存器置为0或者0xffffffff，我们可以把接下来的AND指令看作一个条件赋值语句（很像我们后面要讨论的CMOV指令）。通过给EAX“与”上一个常数，代码实际上等价于：“如果SBB的计算结果为0就什么也不做；如果结果为-1，则将EAX置为指定的常数。”做完这些工作后，代码将无条件地给EAX加上54，并将结果返回给主调函数。
我们所面临的挑战是试着解读出整段代码的含义。很显然这段代码对SomeFunc函数的返回值做了某种变换，并将变换后的值返回给主调函数。我们试着分析一下这段代码的要点。似乎返回值只能是两个值中的一个：如果SBB的计算结果是0（也就是说SomeFunc的返回值是4），EAX将被置为54；如果SBB的计算结果是0xffffffff，EAX将被置为2——因为AND指令将会把EAX置为-52，后边的ADD指令会把EAX中的值变为2。
这段代码比较了两个整数，并在两个数相等的情况下返回一个值，在不相等的情况下返回另一个值（没有使用一个分支条件）。下面是这段汇编语言代码的C语言版本：
A.3.2 预测执行
用算术序列实现无分支逻辑是一种用处非常有限的技巧。为了实现更棒的无分支逻辑，编译器会采用条件指令（假如目标CPU架构提供这种的指令的话）。条件指令的基本想法是：编译器有时可以使用一类特殊的指令——仅在特定的情况出现的时候才会执行，而不是让代码根据条件转向两个不同的代码区中执行。如果条件不满足，程序就简单地忽略掉这些指令继续往下运行。IA-32的指令集没有提供通用的、可以使所有指令都变成条件指令的条件执行前缀（conditional execution prefix）。为了有条件地执行操作，IA-32提供了专门的条件执行指令。
某些CPU架构（如Intel推出的IA-64的64位架构）允许指令集中几乎所有的指令根据条件执行。在IA-64（也称为Itanium2）中使用一组64个判定寄存器（predicate register）来实现条件指令，每个判定寄存器用来存储一个指定某个特定的条件是True或False的布尔值。在指令前面可以加上某个判定寄存器的名字作为前缀。相应的判定寄存器中的值为“True”时CPU才会执行这条指令，否则CPU就将它作为一条NOP指令来对待。
下面几小节中我们将讨论两组IA-32指令，它们能在IA-32处理器中实现无分支逻辑。
A.3.2.1 条件设置指令（SETcc）
SETcc是一组指令集，这组指令执行与条件跳转指令（Jcc这组指令）相同的逻辑标志位测试，只是不执行跳转，它只执行逻辑测试并把结果存放在一个操作数中。下面是一个怎样在实际代码中使用SETcc的简单例子。假定某个程序员写了这样一行代码：
在这个例子中并不是完全符合C语言规范的，前边这句代码与下面这句代码
唯一区别在于前边这句代码总是返回一个Boolean量。如果result等于0，将返回1，否则不管result的值是多少都返回0。对于第二个例子，返回值就是存储在result中的值。
如果没有无分支逻辑，编译器就会产生如下的代码或者是非常相似的代码：
如果使用SETcc指令，编译器就可以生成无分支逻辑。在这个例子中，SETNE指令将用来完成上边代码中的JNE指令（译注：原文误为JE指令）的工作：
|
在这里使用SETNE指令为我们提供了一个很棒的无分支逻辑。如果“result == 0”，EAX寄存器将被置为0，否则EAX将被置为1。当然，就像Jcc指令，每个SETcc指令的具体条件（即“cc”对应的条件）都符合我们本附录前面讨论过的条件代码。
A.3.2.2 条件传送指令（CMOVcc）
CMOVcc指令是IA-32指令集中另一个预测执行特性。CMOVcc指令根据条件把第二个操作数拷贝给第一个操作数。具体的测试条件取决于所使用的具体的条件代码。和SETcc一样，CMOVcc也有很多版本——其中我们在本附录中讲过的每条条件代码对应一条CMOVcc指令。下面的代码演示了一个使用CMOVcc指令的简单例子：
前边这段代码（由Intel公司的C/C++编译器生成）演示了CMOVcc指令的一个巧妙的运用。这段代码的思路是：EAX寄存器必须根据EDX寄存器中的值接收两个不同的值中的一个——其中一个可能的值存放在ECX中而另一个放在EAX中。代码测试EDX是否
现代编译器中的CMOV指令
CMOV指令在逆向常见的由编译器生成的程序时基本上见不到，这可能是因为在早期的IA-32处理器中没有CMOV指令，而最早提供CMOV指令的是Pentium Pro处理器。因此，大多数编译器为了避免卷入向后兼容性的问题中，都不愿意使用CMOV指令。有意思的是，即使这些编译器被专门设置成是为更晚推出的处理器生成代码，编译器仍然不喜欢使用CMOV指令。实际使用CMOV指令的C/C++编译器只有两个——Intel公司的C++编译器和GCC编译器（GNU的C编译器）。当前最新版本的Microsoft C/C++ Optimizing编译器（版本为13.10.3077）即使在目标处理器已经显式定义为新一代的处理器的情况下，也不会使用CMOV指令。
满足条件值（这里条件值是0），并用CMOVE（如果相等的话就执行条件传送）实现在相等的情况下将ECX中的值加载给EDX。如果相等条件不满足，条件传送（conditional move）就不会执行，因此EAX会保留其原来的值（是1,000）。如果条件传送真的执行了，就将2,000赋给EAX。从这些分析，你基本上可以容易地推断出下面这段近似的代码了：
A.4 工作集调整对逆向工程的影响的作用
工作集调整（working-set tuning）指的是重新安排可执行模块中代码布局的过程，该过程将调用最频繁的代码块集中到模块的开始位置。这样做的目的是延迟对较少调用代码的加载，从而使得使用最频繁的程序部分通常都驻留在内存中。它的优点是极大地减少了内存开销，并且提高了程序的启动速度。工作集调整不仅可以应用于程序，也可以应用于操作系统。
A.4.1 函数级的工作集调整
常用的工作集调整是基于函数级重新组织的调整。当程序启动后，工作集调整器程序（working-set tuner program）会考察哪些函数使用得最频繁，然后它根据这些信息重新组
织各个函数在二进制文件中的顺序，以保证最常用的函数被放在模块的最前面，而不常用的函数被放在模块的末尾处。这样，操作系统就可以把最常用的代码块一直“留”在内存中，而模块的其余部分只在需要的时候才会被加载到内存中（然后在不再需要的时候就立即把它清除出内存）。
在逆向过程中遇到的大多数情况下，函数级的工作集调整不会对逆向过程造成任何影响，它只会为我们提供一个有关程序的小暗示：一个函数的地址相对于模块开始处的距离（靠近程度）表明了这个函数的使用频度。函数越靠近模块的起始位置，它使用的频度就越高。那些放在模块结尾处（即放在高地址位的函数）的函数就很少被调用，而且，这些函数很可能在出现不正常的情况才会用到功能，比如程序出错。图A.13通过图片解释了这个概念。
A.4.2 代码级的工作集调整
代码级的工作集调整是更高级的工作集调整形式，通常需要编译器显式支持（explicit support）该功能才可以。代码级工作集调整的基本想法是：调整过程中将条件代码调整到数中（而不是独立的函按照函数的使用状况进行调整），这样就可以实现比函数级调整更加高效的程序。工作集调整器程序会统计程序中每个条件的使用情况，并据此重新排列条件代码块在二进制模块中的位置。
对于逆向工程人员来说，代码级工作集调整为他们提供了某个条件代码块在正常运行时会被执行到的可能性。然而，这种调整方法带来的主要问题是无法在二进制模块中看到完整的函数（被分成了很多块）。因为对代码块的移动已经超出了它们所属函数的边界，对这样的代码进行逆向表现出来一些奇怪的现象。要引起注意的是，函数都被分解成多个代码块并分散在整个模块中，当你看到一个独立的代码片断时，很难确定它是放在模块另一端的某个函数的一部分；在这段代码的前边和后边的片断都和它没有任何的关联。有一个辨识这种相互独立的代码片断之间联系的技巧你可能会用得到，就是观察代码片段末尾的无条件JMP指令。通常这个独立的代码片断会跳回其所属函数的函数体，从而暴露出函数的位置。在其他的情况下，独立的代码片断直接返回（return），这样我们就无法搞清楚它的函数主体了。图A.14通过图片解释了代码级工作集调整对代码在二进制可执行文件中布置的影响。
图A.13 函数级的工作集调整对二进制可执行文件中代码的影响
图A.14 代码级的工作集调整对同一个二进制可执行文件中代码的影响
