《64位汇编语言的编程艺术》兰德尔·海德著

蘭雅

《64 位汇编语言艺术》是专门使用 Windows 下的 MASM 汇编程序编写的，本书的所有示例源代码清单都包含在一个 .zip 文件中。源代码采用 MASM 格式，可使用 Microsoft MASM 汇编程序进行汇编/编译。

《64 位汇编语言艺术》汇编示例源码文件:

Windows MSVC版: ArtOfAsmV1.zip https://bbs.lyvba.com/assets/files/2024-11-03/1730596869-441156-artofasmv1.zip
Linux Gcc版: AoA1Linux.zip https://bbs.lyvba.com/assets/files/2024-11-03/1730641037-286351-aoa1linux.zip

《64 位汇编语言艺术》（Ao64A）是 Randall Hyde 的经典著作《汇编语言艺术》的现代更新版。

这本全新的教材以 64 位 Intel/AMD x86-64 架构为特色，并教授在 Windows 下使用 Microsoft MASM 汇编器进行汇编语言编程。主题包括基本汇编语言编程和机器组织、整数运算、浮点运算、SIMD（SSE/AVX）编程、字符串和位操作。对于希望学习 x86-64 汇编语言编程的人来说，这是一本非常全面的书。

🐠 掌阅APP 上可以免费预读前三章，对于大多数人已经够用了。

手机APP搜索《64 位汇编语言艺术》，或者电脑直接使用这个链接直接看，

https://m.zhangyue.com/readbook/13168998/1.html?showDownload=1%3Fivk_sa%3D1024320u

拼夕夕上有很便宜的影印版

《64位汇编语言的编程艺术》 PDF 版，等哪位好心人.......

The Art of 64-Bit Assembly 在线版: https://lyvba.com/The_Art_of_64-Bit_Assembly/

💯 感谢 jyy操作系统互助群网友，帮我找了英文版 The Art of 64-Bit Assembly.epub

蘭雅

`programShell.asm` 的中文注释

; 注释由分号字符到行末的所有文本组成。

; ".CODE" 指令告诉 MASM 后面的语句
; 将放入为机器指令（代码）保留的内存区域。

        .CODE

; 这里是 "main" 函数。
; （此示例假设汇编语言程序是一个
; 独立的程序，拥有自己的 main 函数。）

main    PROC

; << 机器指令在这里放置 >>
        
        ret	; 返回到调用者
	
main    ENDP

; END 指令标记源文件的结束。

        END

使用 MSVC2022 中的 `ml64.exe` 微软宏汇编编译器 ( Macro Assembler x64) 编译第一个汇编程序

ml64 programShell.asm  /link /subsystem:console /entry:main

PowerShell 执行自己建立的汇编程序和输出返回值

.\programShell.exe

$LASTEXITCODE

运行第一个MASM和C++的混合程序

本书通常将汇编语言模块（包含一个或多个使用汇编语言编写的函数）与调用它的C/C++主程序相结合。由于由汇编语言和C++语言组成的混合程序的编译及执行过程与独立MASM程序的略有不同，因此本节将演示如何创建、编译和运行这样一个混合程序。

程序清单1-2提供了调用汇编语言模块的C++主程序。

// 列表 1-2
//
// 一个简单的 C++ 程序，用于调用汇编语言函数。
// 需要包含 stdio.h，以便该程序可以调用 "printf"。

#include <stdio.h>

// extern "C" 命名空间防止 C++ 编译器
// 进行“名称修饰”。

extern "C"
{
    // 这是该程序将调用的外部函数，
    // 用汇编语言编写：
    
    void asmFunc(void);
};

int main(void)
{
    printf("调用 asmMain:\n");
    asmFunc();
    printf("从 asmMain 返回\n");
}

程序清单1-3 汇编语言模块

; 列表 1-3：
; 一个简单的 MASM 模块，包含一个空函数，
; 供列表 1-2 中的 C++ 代码调用。

        .CODE
        
; "option casemap:none" 语句告诉 MASM
; 所有标识符区分大小写（而不是映射为
; 大写）。这是必要的，因为 C++ 的标识符
; 是区分大小写的。

        option  casemap:none

; 这里是 "asmFunc" 函数。

        public  asmFunc
asmFunc PROC

; 空函数仅返回到 C++ 代码
        
        ret     ; 返回到调用者
        
asmFunc ENDP
        END

编译和运行命令，运行结果如图

ml64 /nologo /c .\listing1-3.asm
cl /nologo .\listing1-2.cpp .\listing1-3.obj
.\listing1-2.exe

Linux 系统 gcc 编译汇编版 Hello World，生成可执行文件极小

在使用 Linux 系统调用的汇编代码中，通常需要指定入口函数 _start，因为它是程序的起始点。操作系统在加载可执行文件时，会查找这个特定的符号并从那里开始执行。

使用 `_start` 的原因

程序入口：_start 是程序的默认入口点，操作系统会从这个地址开始执行代码。
系统调用：在直接使用系统调用时，程序不需要标准 C 库，因此 _start 是一个合适的入口点，因为它可以直接与内核交互。

如何指定 `_start`

在汇编代码中，您已经通过 .global _start 声明了 _start 作为全局符号。编译和链接时，链接器会自动将其视为入口点。

示例 hello.s 源码

.global _start

.text
_start:
    // write(1, message, 13)
    mov     $1, %rax                # 系统调用 1 是 write
    mov     $1, %rdi                # 文件句柄 1 是 stdout
    mov     $message, %rsi          # 字符串地址
    mov     $13, %rdx               # 字节数
    syscall                         # 调用操作系统执行写入

    // exit(0)
    mov     $60, %rax               # 系统调用 60 是 exit
    xor     %rdi, %rdi              # 返回码 0
    syscall                         # 调用操作系统退出

message:
    .ascii  "Hello, world\n"

链接时指定入口点

如果您需要手动指定入口点（通常不需要），可以在链接时使用 ld 的 -e 选项：

gcc -c  hello.s
ld -o hello hello.o -e _start

总结

在大多数情况下，只需在汇编中定义 _start 并使用默认链接设置即可，无需额外指定。

vip

第1章汇编语言的第一个程序

本章是一个“快速入门”章节，可以让读者尽快开始编写基本的汇编语言程序。通过本章的学习，读者应该了解MASM的基本语法，以及后续章节中学习汇编语言新功能所需的先决条件。

注意： 本书使用在Windows环境下运行的MASM，因为它是迄今为止编写x86-64汇编语言程序最常用的汇编器。此外，英特尔文档通常使用与MASM语法兼容的汇编语言示例。读者在现实世界中遇到的x86源代码，就很有可能是使用MASM编写的。也就是说，还有许多其他流行的x86-64汇编器，包括GNU汇编器（gas）、Netwide汇编器（NASM）、Flat汇编器（FASM）等。这些汇编器所使用的语法与MASM不同（gas的语法与其区别最大）。在某种程度上，如果读者经常使用汇编语言，就可能会遇到使用其他汇编器编写的源代码。不要因此感到焦躁不安，因为一旦掌握了使用MASM的x86-64汇编语言，学习各种汇编器之间的语法差异就没那么困难了。

本章将涵盖以下内容：

●MASM程序的基本语法

●英特尔中央处理器（central processing unit，CPU）的体系结构

●如何为变量保留内存

●使用机器指令控制CPU

●将MASM程序与C/C++代码相链接，以便可以调用C标准库中的例程

●编写一些简单的汇编语言程序

1.1 先决条件

学习使用MASM进行汇编语言程序设计需要如下的先决条件：一个64位版本的MASM和一个文本编辑器（用于创建和修改MASM源文件）、链接器、各种库文件，以及C++编译器。

如今，只有当C++、C#、Java、Swift或Python代码运行速度太慢，而且需要提高代码中某些模块（或函数）的性能时，软件工程师才会采用汇编语言。在现实世界中使用汇编语言时，通常会编写C++或其他高级语言（HLL）代码来调用汇编语言。在本书中，我们也将采用相同的模式。

使用C++的另一个原因是C标准库。虽然不同的个体为MASM创建了若干实用的库（典型的例子请参见http://www.masm32.com/），但没有一套公认的标准库。为了使MASM程序能够方便地访问C标准库，本书提供了一个简短的C/C++主函数示例，该函数调用使用MASM汇编语言编写的单个外部函数。编译C++主程序和MASM源文件将生成一个可运行的文件，用户可以运行和测试该文件。

学习汇编语言需要掌握C++吗？答案是并非必需。本书将为读者提供运行示例程序所需的C++代码。尽管如此，汇编语言并不是入门程序设计语言的最佳选择，因此本书假设读者对其他计算机程序设计语言，例如C/C++、Pascal（或Delphi）、Java、Swift、Rust、BASIC、Python或任何其他命令式及面向对象的程序设计语言有一定的了解。

1.2 在计算机上安装 MASM

MASM是微软公司的产品，它是Visual Studio开发工具套件的一部分。因为MASM是微软的工具集，所以读者需要运行某个版本的Windows（在编写本书时，Windows 10是最新版本，不过Windows 10以后的任何新版本也都可能满足要求）。附录A提供了如何安装Visual Studio社区版的完整说明。Visual Studio社区“免费”版包括MASM和Visual C++编译器，以及其他使用者需要的工具。有关更多详细信息，请参阅附录A。

1.3 在计算机上安装文本编辑器

Visual Studio包含一个文本编辑器，可以用来创建和编辑MASM与C++程序。为了获取MASM，用户必须安装Visual Studio包，因此会自动获得一个产品质量级别的程序员文本编辑器，可以用于编辑汇编语言源文件。

当然，用户也能使用任何可以直接处理ASCII文件（或UTF-8）的编辑器，例如https://www.masm32.com/上提供的文本编辑器，来创建MASM和C++源文件。文字处理程序（例如Microsoft Word）不适用于编辑程序源文件。

1.4 MASM 程序的结构剖析

一个典型的（并且可以独立运行的）MASM程序如程序清单1-1所示。

程序清单 1-1 一个简单的 shell 程序（ programShell.asm 文件）

；注释是从一个分号字符开始到行尾的所有文本。

；“.code”伪指令指示MASM该指令后的语句位于保留给机器指令（代码）的内存段（section）中。

.code

；以下是“main”主函数的定义。

；（本示例假定该汇编语言程序是一个独立可运行的程序，拥有自己的main主函数。）

main PROC

；此处包含机器指令

ret；返回到调用方

main ENDP

；END伪指令标记源代码文件的结束。

END

典型的MASM程序包含一个或多个段，段表示内存中出现数据的类型。这些段以MASM语句（例如“.code”或“.data”）开始。变量和其他内存值均位于数据段（data section）中，汇编语言过程中的机器指令位于代码段（code section）中。在汇编语言源文件中，不同的段是可选的，因此特定的源文件中并非包含每种类型的段。例如，程序清单1-1只包含一个代码段。

在程序清单1-1中，“.code”语句是一条汇编伪指令。汇编伪指令的功能是指示MASM有关程序的一些信息，并不是实际的x86-64机器指令。具体而言，“.code”伪指令指示MASM将其后面的语句分组到一个特殊的内存段中，而这个内存段是专门为机器指令预留的。

1.5 运行第一个 MASM 程序

按程序设计语言界的惯例，用新学语言写的第一个程序是“Hello，world！”程序，该程序出自Brian Kernighan和Dennis Ritchie编写的 The C Programming Language （Prentice Hall出版社，1978年），随后开始流行。“Hello，world！”程序的主要目标是提供一个简单的示例，让学习一种新程序设计语言的人可以使用该示例了解如何使用该语言提供的工具去编译和运行程序。

遗憾的是，在汇编语言中，编写类似于“Hello，world！”这样简单的程序却需要先学习大量的汇编知识。为了打印字符串“Hello，world！”，必须学习一些机器指令和汇编伪指令，还需要学习Windows的系统调用方法。就这一点而言，可能给刚开始使用汇编语言的程序员提出了过高的要求。当然，对于那些迫不及待想挑战并自行完成这个编程任务的人，可以参见附录A中的示例程序。

程序清单1-1中的程序shell实际上是一个完整的汇编语言程序。用户可以编译（汇编）并运行该程序，程序不产生任何输出。启动后，程序会立即返回Windows。但是，该程序确实可以运行，它将作为一种机制，向用户展示如何汇编、链接和运行一个汇编语言源文件。

MASM是一个传统的命令行汇编器，这意味着用户需要从Windows命令行提示符窗口运行MASM（用户可以通过运行cmd.exe程序打开Windows命令行）。为了执行此操作，请在Windows命令行提示符窗口或者shell窗口中输入以下内容：

C：\> ml64 programShell.asm/link/subsystem：console/entry:main

以上命令指示MASM对programShell.asm程序（注意，程序清单1-1被保存为programShell.asm文件）进行汇编，生成一个可执行文件，并将结果进行链接以生成一个控制台应用程序（用户可以从命令行运行这个应用程序），然后在汇编语言源文件的标签main处开始执行。假设汇编和链接的过程中没有发生错误，则可以通过在命令行提示符窗口中键入以下命令来运行所生成的结果程序：

C：\> programShell

Windows立即响应一个新的命令行提示符（因为programShell应用程序在开始运行之后立即将控制权返回给Windows）。

1.6 运行第一个 MASM 和 C++ 的混合程序

本书通常将汇编语言模块（包含一个或多个使用汇编语言编写的函数）与调用它的C/C++主程序相结合。由于由汇编语言和C++语言组成的混合程序的编译及执行过程与独立MASM程序的略有不同，因此本节将演示如何创建、编译和运行这样一个混合程序。程序清单1-2提供了调用汇编语言模块的C++主程序。

程序清单 1-2 示例 C/C++ 程序（ listing1-2.cpp 文件），该程序调用了汇编语言函数

//程序清单1-2

//一个简单的C++程序，该程序调用了一个使用汇编语言编写的函数。

//需要包含stdio.h头文件，以便程序能够调用“printf”函数。

#include<stdio.h>

//extern“C”命名空间可以防止C++编译器的“名称篡改”。

extern"C"

{

//以下是使用汇编语言编写的外部函数，本程序将调用该函数：

void asmFunc（void）；

}；

int main（void）

{

printf（"Calling asmMain：\n"）；

asmFunc（）；

printf（"Returned from asmMain\n"）；

}

程序清单1-3是可独立运行MASM程序的改进版，其中包含asmFunc（）函数，此函数被C++程序调用。

程序清单 1-3 MASM 程序（ listing1-3.asm 文件），被程序清单 1-2 中的 C++ 程序调用

；程序清单1-3

；一个简单的MASM模块，包含一个空函数，被程序清单1-2中的C++代码调用。

.CODE

；（有关option伪指令的说明，请参见后续正文。）

option casemap：none

；以下是“asmFunc”函数的定义。

public asmFunc

asmFunc PROC

；空函数，直接返回到C++代码。

ret；返回到调用方

asmFunc ENDP

END

相对于原始的programShell.asm源文件，程序清单1-3包括三处修改。首先，有两个新的语句，即option语句和public语句。

option语句指示MASM将区分所有符号的大小写。这是非常必要的操作，因为在默认情况下，MASM不区分大小写，并将所有标识符映射为大写（意味着asmFunc（）函数将转换为ASMFUNC（））。而C++是区分大小写的程序设计语言，会将asmFunc（）和ASMFUNC（）视为两种不同的标识符。因此，必须指示MASM区分标识符的大小写，以免混淆C++程序的语义。

注意： MASM标识符可以以美元符号（$）、下划线（_）或字母字符开头，后面跟零个或多个字母、数字字符、美元符号或下划线字符。标识符本身不能由$字符组成（$符号在MASM中具有特殊意义）。

public语句声明asmFunc（）标识符将对MASM源文件和目标文件的外部可见。如果没有该语句，那么只能在MASM模块内访问asmFunc（），C++编译就会报错：asmFunc（）是一个未定义的标识符。

程序清单1-3和程序清单1-1之间的第三个区别是，函数名从main（）更改为asmFunc（）。如果在汇编代码中使用名称main（），则由于C++程序中也包含一个名称为main（）的函数，因此C++编译器和链接器会出现混乱。

为了编译和运行这些源文件，可以使用如下所示的命令：

ml64命令使用了“/c”选项，该选项表示“仅编译”，并且不尝试运行链接器（如果运行链接器则将失败，因为listing1-3.asm不是一个可独立运行的程序）。MASM的输出是一个目标代码文件（listing1-3.obj），该文件作为下一个命令中Microsoft Visual C++（MSVC）编译器的输入。

cl命令在listing1-2.cpp文件上运行MSVC编译器，并将汇编代码（listing1-3.obj）进行链接。MSVC编译器的输出是一个可执行文件listing1-2.exe，从命令行执行该程序就会产生预期的输出结果。

1.7 英特尔 x86-64 CPU 系列简介

到目前为止，读者已经学习了一个可以编译并运行的MASM程序。然而，该程序没有执行任何操作，只是将控制权返回到Windows。在进一步学习真正的汇编语言之前，必须先了解硬件方面的知识。读者必须了解英特尔x86-64 CPU系列的基本结构，否则将无法理解机器指令。

英特尔CPU系列通常被归类为冯·诺依曼体系结构的计算机。冯·诺依曼计算机系统包含三个主要的组成部分：中央处理器（CPU）、内存（memory）和输入/输出（I/O）设备。这三个组件通过系统总线（包括地址总线、数据总线和控制总线）互连。图1-1中的方框图显示了这三个组件之间的关系。

CPU通过在地址总线上放置一个数值，来选择一个内存位置或者I/O设备端口位置（每个位置都有一个唯一的数字地址），从而与内存或I/O设备通信。然后，CPU、内存和I/O设备这三个组件通过将数据放在数据总线上，实现数据传输。控制总线包含确定数据传输方向（从内存到I/O设备或从I/O设备到内存）的信号。

图1-1 冯·诺依曼计算机系统的方框图

在CPU中，寄存器（register）用于操作数据。x86-64 CPU的寄存器可分为四种类型：通用寄存器（general-purpose register）、专用应用程序访问寄存器（special-purpose application-accessible register）、段寄存器和专用内核模式寄存器（special-purpose kernel-mode register）。由于段寄存器在现代64位操作系统（例如Windows）中使用不多，因此本书中将不加讨论。专用内核模式寄存器用于编写操作系统、调试器和其他系统级的工具。这种软件构造远远超出了本书的讨论范围。

x86-64（英特尔系列）CPU提供多个通用寄存器供应用程序使用。通用寄存器包括如下几类。

●16个64位寄存器，对应的名称如下：RAX、RBX、RCX、RDX、RSI、RDI、RBP、RSP、R8、R9、R10、R11、R12、R13、R14和R15。

●16个32位寄存器，对应的名称如下：EAX、EBX、ECX、EDX、ESI、EDI、EBP、ESP、R8D、R9D、R10D、R11D、R12D、R13D、R14D和R15D。

●16个16位寄存器，对应的名称如下：AX、BX、CX、DX、SI、DI、BP、SP、R8W、R9W、R10W、R11W、R12W、R13W、R14W和R15W。

●20个8位寄存器，对应的名称如下：AL、AH、BL、BH、CL、CH、DL、DH、DIL、SIL、BPL、SPL、R8B、R9B、R10B、R11B、R12B、R13B、R14B和R15B。

遗憾的是，以上列举的68个寄存器都不是独立的寄存器。实际上，x86-64的64位寄存器覆盖在32位寄存器上，32位寄存器覆盖在16位寄存器上，16位寄存器覆盖在8位寄存器上。表1-1显示了这些寄存器之间的关系。

表 1-1 x86-64 上的通用寄存器

通用寄存器不是独立的寄存器，使得修改其中1个寄存器可能引发对其他寄存器的修改。例如，修改EAX寄存器的内容可能也会正好修改AL、AH、AX和RAX寄存器的内容。这一连锁反应现象需要引起足够的重视。在汇编语言初级程序员编写的程序中，一个常见的错误是寄存器值的损坏，这是程序员没有完全理解表1-1中所示关系的后果。

除通用寄存器外，x86-64还提供专用寄存器，包括在x87浮点单元（floating-point unit，FPU）中实现的8个浮点寄存器（floating-point register）。英特尔将这些寄存器命名为ST（0）到ST（7）。与通用寄存器不同，应用程序不能直接访问这些寄存器，它会将浮点寄存器文件视为一个可以包括8个项的栈，并只访问栈最上面的一个或两个项（有关更多的详细信息，可以参阅6.5节的相关内容）。

每个浮点寄存器的宽度为80位，包含一个扩展精度实数值（以下简称扩展精度）。尽管多年来英特尔在x86-64 CPU中增加了其他浮点寄存器，但FPU寄存器在代码中仍然很常用，因为这些寄存器支持这种80位的浮点格式。

20世纪90年代，英特尔推出了MMX寄存器集和指令，以支持单指令多数据（Single Instruction，Multiple Data，SIMD）操作。MMX寄存器集由8个64位的寄存器组成，覆盖FPU上的ST（0）至ST（7）寄存器。英特尔选择覆盖FPU寄存器，是因为这种方式使得MMX寄存器能够立即与多任务操作系统（例如Windows）兼容，而无须针对这些操作系统进行任何代码更改。遗憾的是，这种选择意味着应用程序不能同时使用FPU指令和MMX指令。

英特尔在x86-64的后续版本中通过添加XMM寄存器集解决了以上问题，因此用户很少看到使用MMX寄存器和指令集的现代应用程序。如果用户真想使用MMX寄存器和指令集，也不是不可以，但还是建议使用XMM寄存器（和指令集），同时将MMX寄存器保持为FPU模式。

为了打破MMX寄存器和FPU寄存器之间冲突带来的限制，AMD/英特尔增加了16个128位的XMM寄存器（XMM0到XMM15）和SSE/SSE2指令集。每个寄存器可以配置为4个32位的浮点寄存器，2个64位的双精度浮点寄存器，或者16个8位、8个16位、4个32位、2个64位或1个128位的整数寄存器。在x86-64 CPU系列的后续版本中，AMD/英特尔将寄存器的大小增加了一倍，每个寄存器的大小变为256位（并将这些寄存器重命名为YMM0到YMM15），以支持8个32位的浮点数值或者4个64位的双精度浮点数值（整数运算仍限制为128位）。

RFLAGS（或FLAGS）寄存器是一个64位寄存器，它封装了多个1位的布尔值（真/假）。RFLAGS寄存器中的大多数位或者是为内核模式（操作系统）函数保留的位，或者是应用程序程序员不关心的位。编写汇编语言应用程序的程序员特别关注其中的8个位（或称为标志）：溢出（overflow）、方向（direction）、中断（interrupt）、符号（sign）、零（zero）、辅助进位（auxiliary carry）、奇偶校验（parity）以及进位（carry）标志。图1-2显示了RFLAGS寄存器低16位中各个标志位的布局。

图1-2 RFLAGS寄存器的布局（位于RFLAGS寄存器的低16位）

在图1-2中，4个标志特别重要，分别是溢出、进位、符号和零标志，统称为条件码（condition code）。这些标志的状态允许用户测试先前计算的结果。例如，比较两个值后，条件码标志将告知用户第一个值是否小于、等于或大于第二个值。

对于那些刚刚学习汇编语言的人而言，他们惊讶于一个重要事实，即x86-64 CPU上几乎所有的计算都涉及寄存器。例如，为了将两个变量相加并将总和存储到第三个变量中，就必须将其中一个变量加载到寄存器中，将第二个操作数与寄存器中的数值相加，然后将寄存器中的值存储到目标变量中。在几乎所有的计算中，都需要以寄存器作为中介。

用户还应该知道，尽管寄存器被称为通用寄存器，但用户不能将任何寄存器用于任何目的。所有x86-64寄存器都有自己的特殊用途，从而限制了寄存器在某些上下文中的使用。例如，RSP寄存器有一个非常特殊的用途，可以有效地防止用户将其用于任何其他用途（该寄存器是堆栈指针）。同样，RBP寄存器也有一个特殊用途，限制了其作为通用寄存器的作用。目前，用户应该避免使用RSP和RBP寄存器进行一般的计算任务；另外，请记住，其余寄存器在程序中不能完全互换。

1.8 内存子系统

内存子系统（memory subsystem）保存程序变量、常量、机器指令和其他信息等数据。内存由内存单元（或称为内存位置）组成，每个内存单元都保存着一小段信息。系统可以将来自这些小的内存单元的信息组合成更大的信息片段。

x86-64支持字节可寻址内存（byte-addressable memory），这意味着基本内存单元是一个字节，足以容纳单个字符或者（非常）小的整数值（我们将在第2章中详细讨论）。

可以把内存想象成一个线性字节数组，第一个字节的地址为0，最后一个字节的地址为2 ³² -1。对于安装了4GB内存的x86处理器 [1]^ ，以下伪Pascal数组声明是对内存的最佳近似表示：

Memory：array[0..4294967295]of byte；

C/C++和Java用户可能更喜欢以下的语法：

byte Memory[4294967296]；

例如，为了执行等价于Pascal语句“Memory[125]：=0；”的操作，CPU将值0放在数据总线上，将地址125放在地址总线上，并断言写入线（该操作通常将该写入线设置为0），如图1-3所示。

为了执行等价于语句“CPU：=Memory[125]；”的操作，CPU将地址125放置在地址总线上，并断言读取线（因为CPU正在从内存读取数据），然后从数据总线读取结果数据（请参见图1-4）。

图1-3 内存写入操作

图1-4 内存读取操作

为了存储更大的值，x86使用一系列连续的内存位置。图1-5显示了x86如何在内存中存储字节、字（2个字节）和双字（4个字节）。对象的内存地址是其第一个字节的地址（即最低地址）。

图1-5 内存中字节、字和双字的存储方式

1.9 在 MASM 中声明内存变量

在汇编语言中，虽然可以使用数字地址引用内存，但这样做非常麻烦，而且容易出错。与其在程序中声明如下语句：“获取内存地址192处的32位值，获取内存地址188处的16位值”，不如采用这个声明更加优雅：“获取变量elementCount的内容，获取变量portNumber的内容”。使用变量名而不是内存地址，可以使程序更易于编写、阅读和维护。

为了创建（可写入的）数据变量，必须将数据变量放在MASM源文件的数据段中，数据段使用“.data”伪指令定义。该伪指令指示MASM：以下所有语句（直到下一个“.code”伪指令或其他段定义伪指令出现）将定义数据声明，并被分组到内存的读取/写入段中。

在“.data”段中，MASM允许用户使用一组数据声明伪指令来声明变量对象。数据声明伪指令的基本形式如下：

label directive？

其中，label是一个合法的MASM标识符，directive是表1-2中显示的一个伪指令。

表 1-2 MASM 数据声明伪指令

问号（？）操作数指示MASM：当程序加载到内存中时，对象是没有显式值的（默认初始化为0）。如果要使用显式值对变量进行初始化，则可以使用具体的初始值替换问号操作数。例如：

hasInitialValue sdword-1

表1-2中的一些数据声明伪指令（带有s前缀的伪指令）具有有符号版本。在大多数情况下，MASM会忽略此前缀。用户编写的机器指令会区分有符号和无符号操作，MASM本身则通常不关心变量是取有符号值还是无符号值。事实上，MASM允许以下两种情况：

.data

u8 byte-1；允许负的初始值

i8 sbyte 250；虽然+128是最大的有符号字节值，但此处仍然使用250

MASM关心的只是初始值是否放入一个字节中。即使“-1”不是一个无符号值，也可以放入内存的一个字节中。即使“250”超出了一个有符号8位整数的数值范围（请参阅2.7节的相关内容），MASM也会接受该初始值，因为它可以放入一个字节变量中（作为一个无符号数值）。

可以在单个数据声明伪指令中，为多个数据值保留存储空间。字符串多值数据类型对本章至关重要（后面的章节将讨论其他数据类型，如第4章中的数组）。用户可以使用如下byte伪指令在内存中创建以null结尾的字符串：

；0（null）结尾的C/C++字符串。

strVarName byte 'String of characters'，0

请注意，字符串后面包含“，0”。在任何数据声明（不仅仅是字节声明）中，都可以在操作数字段中放置多个数据值，并用逗号分隔各数据值，MASM将为每个操作数定义一个指定大小和值的对象。对于字符串值（在本例中字符串值包括在单引号中），MASM为字符串中的每个字符定义一个字节（加上一个零字节，表示字符串末尾的“，0”操作数）。MASM允许用户使用单引号或双引号来定义字符串，并且必须使用与字符串开头相同的分隔符（单引号或双引号）终止字符串。

1.9.1 将内存地址与变量关联

使用MASM这样的汇编器/编译器的一个优势在于，用户不必关心数值形式的内存地址。用户只须在MASM中声明一个变量，MASM会将该变量与一组唯一的内存地址相关联。例如，假设用户定义了以下声明段：

.data

i8 sbyte ？

i16 sword ？

i32 sdword ？

i64 sqword ？

MASM将在内存中查找一个未使用的（8位）字节，并将其与变量i8相关联；查找两个未使用且连续的字节，并将这两个字节与变量i16相关联；查找四个未使用且连续的字节，并将这四个字节与变量i32相关联；查找八个未使用且连续的字节，并将这八个字节与变量i64相关联。用户只需要按名称引用这些变量，通常不必关心变量所关联的数值地址。不过，用户应该知道是MASM完成了这些关联操作。

当MASM处理“.data”段中的声明时，将为每个变量分配连续的内存位置。假设前面声明的变量i8位于内存地址101，则MASM将把表1-3中出现的地址分配给变量i8、i16、i32和i64。

当数据声明语句中有多个操作数值时，MASM会按照值在操作数字段中出现的顺序将值输出到连续的内存位置。与数据声明关联的标签（如果存在）将与第一个（最左侧）操作数值的地址相关联。具体请参见第4章。

表 1-3 变量地址分配

1.9.2 将数据类型与变量关联

在汇编过程中，MASM将数据类型与用户定义的每个标签（包括变量）相关联。这对于汇编语言来说属于相当高级的操作，因为大多数汇编器只是将一个值或地址与一个标识符相关联。

在大多数情况下，MASM使用变量的大小（字节）作为其数据类型（请参见表1-4）。

表 1-4 MASM 数据类型

后续章节将全面讨论proc、label、constant和text类型。

1.10 在 MASM 中声明（命名）常量

MASM允许用户使用“=”伪指令声明明示常量（manifest constant，也被称为明显常量）。明示常量是一个符号名称（标识符），MASM将该符号名称与一个值相关联。无论符号名称出现在程序中的何处，MASM都将直接使用与符号名称对应的值替换该符号名称。

明示常量的声明采用以下形式：

label=expression

其中，label是一个合法的MASM标识符，expression是一个常量算术表达式（通常是单个字面常量值）。以下示例定义符号名称dataSize等于256：

dataSize=256

大多数情况下，MASM的“equ”伪指令是“=”伪指令的同义词。就本章而言，以下语句大体上等同于上面的常量声明：

dataSize equ 256

常量声明（等同于MASM术语）可以位于MASM源文件的任何位置，但必须位于常量首次使用之前。常量声明可以在“.data”段中、“.code”段中，也可以在任何段之外。

1.11 基本的机器指令

根据用户定义机器指令的方式，x86-64 CPU系列提供了多达几百条到数千条的机器指令。但是大多数汇编语言程序使用大约30条到50条机器指令，而且只需要几条指令就可以编写若干有意义的程序。本节介绍少量机器指令，以便用户可以立即开始编写简单的MASM汇编语言程序。

1.11.1 mov 指令

毫无疑问，mov指令是最常用的汇编语言语句。在典型的程序中，25%到40%的指令都是mov指令。顾名思义，这条指令将数据从一个位置移动到另一个位置。mov指令的通用MASM语法形式如下所示：

mov destination_operand，source_operand

source_operand（源操作数）可以是（通用）寄存器、内存变量或常量。destination_operand（目标操作数）可以是寄存器或者内存变量。x86-64指令集不允许两个操作数都是内存变量。在高级程序设计语言（例如Pascal或C/C++）中，mov指令大致相当于以下的赋值语句：

destination_operand=source_operand；

mov指令的两个操作数必须大小相同。也就是说，用户可以在两个字节（8位）对象、字（16位）对象、双字（32位）对象或者四字（64位）对象之间移动数据，但是不能混合操作数的大小。表1-5列出了mov指令的所有合法操作数组合。

建议用户仔细研究一下表1-5，因为大多数通用x86-64指令都使用此语法。

表 1-5 x86-64 mov 指令的合法操作数组合

（续）

①reg _n 表示 n 位寄存器，mem _n 表示 n 位内存位置。

②常量必须足够小，以便可以放入指定的目标操作数。

在表1-5中，需要注意一个重要事项：x86-64仅允许将32位的常量值移动到64位的内存单元（对32位的常量值进行符号扩展，达到64位。有关符号扩展的更多信息，请参见2.8节中的相关内容）。允许64位常量操作数的唯一一条x86-64指令是将64位常量移动到64位寄存器的指令。x86-64指令集中的这种不一致性会令人感到恼火，但是仍然推荐使用x86-64！

1.11.2 指令操作数的类型检查

MASM对指令操作数强制执行某些类型检查，特别是要求指令操作数的大小必须一致。例如，对于以下的代码，MASM将生成错误信息：

i8 byte ？

mov ax，i8

问题在于，用户试图将8位变量（i8）加载到16位寄存器（AX）中。由于两者的大小不兼容，因此MASM假定这是程序中的逻辑错误，并报告错误信息。

在大多数情况下，MASM将忽略有符号变量和无符号变量之间的差异。对于以下两条mov指令，MASM不会报错：

i8 sbyte ？

u8 byte ？

mov al，i8

mov bl，u8

MASM关心的只是我们是否将字节变量移动到了字节大小的寄存器中。区分这些寄存器中有符号和无符号值的任务则交给应用程序。MASM甚至允许以下的操作：

r4v real4 ？

r8v real8 ？

mov eax，r4v

mov rbx，r8v

同样，MASM真正关心的只是内存操作数的大小，至于将浮点变量加载到通用寄存器（通常保存整数值）中的操作，MASM将不加干涉。

在表1-4中，包含proc、label和constant类型。如果用户试图在mov指令中使用proc（过程）或label（标签）保留字，则MASM将报告错误信息。过程或标签类型与机器指令的地址相关联，而不是与变量相关联，况且将过程加载到寄存器中是没有任何意义的。

但是，用户可以指定一个constant符号名称作为指令的源操作数，例如：

someConst=5

mov eax，someConst

由于常量没有大小，因此MASM对常量操作数进行的唯一类型检查是验证常量是否可以放入目标操作数中。例如，MASM将拒绝执行以下的代码：

wordConst=1000

mov al，wordConst

1.11.3 add 和 sub 指令

x86-64中的add和sub指令分别对两个操作数进行加法和减法运算。这两条指令的语法与mov指令几乎相同：

add destination_operand，source_operand

sub destination_operand，source_operand

但是，常量操作数的最大值限制为32位。如果目标操作数为64位，CPU仅允许32位的立即源操作数（则它将该操作数进行符号扩展至64位。有关符号扩展的详细信息，请参见2.8节中的相关内容）。

add指令执行以下的操作：

destination_operand=destination_operand+source_operand

sub指令执行以下的操作：

destination_operand=destination_operand-source_operand

有了这三条指令，再加上一些MASM的控制结构，用户就可以编写复杂的汇编程序了。

1.11.4 lea 指令

有时用户需要将变量的地址加载到寄存器中，而不是加载该变量的值。为此，可以使用lea（load effective address，加载有效地址）指令。lea指令采用以下的语法形式：

lea reg64，memory_var

这里，reg64是任何通用的64位寄存器，memory_var是变量名。请注意，该指令与memory_var的类型无关，不要求其类型为qword变量（与mov、add和sub指令一样）。每个变量都有一个与其相关联的内存地址，并且该地址始终为64位。以下示例将strVar字符串中第一个字符的地址加载到RCX寄存器中：

strVar byte"Some String"，0

lea rcx，strVar

lea指令大致相当于C/C++的一元运算符“&”（address-of，取地址）。上述汇编程序示例在概念上等同于以下C/C++代码：

char strVar[]="Some String"；

char ^* RCX；

RCX=&strVar[o]；

1.11.5 call 和 ret 指令以及 MASM 过程

为了进行函数调用（以及编写自己的简单函数），用户需要使用call和ret指令。

ret指令在汇编语言程序中的作用与return语句在C/C++中的作用相同：该指令从汇编语言过程（汇编语言中称函数为过程）中返回控制权。本书暂且使用ret指令的变体，该变体没有操作数：

ret

ret指令允许使用单个操作数，但与C/C++语言不同，操作数不指定函数返回值。

用户可以使用call指令调用MASM过程。这个指令可以采取两种形式，最常见的语法形式如下：

call proc_name其中，proc_name是用户想要调用的过程的名称。

正如我们已经讨论的若干代码示例所示，MASM过程包含以下代码行：

proc_name proc然后是过程主体（通常以ret指令结束）。在过程结束时（通常紧随ret指令之后），使用以下语句来结束过程：

proc_name endp

endp伪指令上的标签必须与用户为proc语句提供的标签相同。

在程序清单1-4中的独立汇编语言程序中，主程序调用myProc过程，该过程将立即返回到主程序，然后主程序立即返回到Windows。

程序清单 1-4 汇编语言程序中的用户定义过程示例

用户可以使用以下命令编译以上的程序，并尝试运行该程序：

C：\> ml64 listing1-4.asm/link/subsystem：console/entry：main

Microsoft（R）Macro Assembler（x64）Version 14.15.26730.0

Assembling：listing1-4.asm

Microsoft（R）Incremental Linker Version 14.15.26730.0

/OUT：listing1-4.exe

listing1-4.obj

/subsystem：console

/entry：main

C：\> listing1-4

1.12 调用 C/C++ 过程

编写自定义的过程并对其加以调用，是一种非常有效的程序设计方式，但本章引入过程的原因并不是让用户编写自定义过程，而是训练用户具备调用C/C++过程（函数）的能力。编写自定义的过程，以将数据转换并输出到控制台是一项相当复杂的任务（目前为止可能远远超出用户的能力范围）。不过，用户可以调用C/C++语言中的printf（）函数来生成程序输出，并在运行程序时验证程序是否确实在执行某些操作。

如果用户在汇编语言代码中调用printf（），而不提供printf（）过程的定义，那么MASM会给出如下的错误信息：“使用了未定义的符号”。为了在源文件外部调用过程，需要使用MASM的externdef伪指令。externdef伪指令的语法形式如下所示：

externdef symbol ： type

此处，symbol是用户想要定义的外部符号，type是该符号的类型（定义外部过程时，类型是proc）。为了在汇编语言源文件中定义printf（）符号，可以使用以下语句：

externdef printf：proc

当定义外部过程符号时，应将externdef伪指令放在“.code”段中。

externdef伪指令不允许向printf（）过程指定需要传递的参数，call指令也不提供指定参数的机制。取而代之的是，用户可以使用x86-64的寄存器RCX、RDX、R8和R9，向printf（）函数传递最多4个参数。printf（）函数要求第一个参数是格式字符串的地址。因此，在调用printf（）之前，应该将字符串的地址加载到RCX寄存器，注意，该字符串以零结尾。如果格式字符串包含任何格式说明符（例如，%d），则必须在寄存器RDX、R8和R9中传递适当的参数值。第5章将详细讨论过程参数，包括如何传递浮点值以及4个以上的参数。

1.13“Hello，world！ ”程序

至此（本章前面包含大量篇幅），我们终于学习了足够知识，可以编写程序“Hello，world！”，如程序清单1-5所示。

程序清单 1-5“Hello，world！ ”程序的汇编语言代码

在上述汇编语言代码中，包含两条“魔法”语句，本章暂不做进一步的解释。只需要接受这样一个事实：需要在函数开始时从RSP寄存器中减去56，然后在函数结束时将该值累加回RSP，才能正常地调用C/C++函数。第5章将更全面地解释这些语句的作用。

程序清单1-6中的C++函数调用汇编代码，并使得printf（）函数可用。

程序清单 1-6 用于“ Hello，world！ ”程序的 C++ 代码

在作者本人的计算机上编译和运行此代码所需的一系列步骤如下所示：

我们终于可以在控制台上输出“Hello，world！”字符串啦！

1.14 在汇编语言中返回函数结果

在上一节中，我们学习了向使用汇编语言编写的过程传递多达4个参数的方法。本节将描述其相反的过程：向调用过程的调用方代码返回值。

在纯汇编语言中（也就是一个汇编语言过程调用另一个汇编语言过程），严格而言，传递参数和返回函数结果是调用方（caller）和被调用方（callee）过程共享的约定。被调用方或者调用方可以选择函数结果出现的位置。

从被调用方的角度来看，返回值的过程确定调用方可以在哪里找到函数结果，并且调用该函数的调用方都必须尊重该选择。如果过程在XMM0寄存器（这是返回浮点结果的常用位置）中返回函数结果，那么调用该过程的调用方必须期望在XMM0中找到结果。而另一个不同的过程可以在RBX寄存器中返回其函数结果。

从调用方的角度来看，选择是相反的。现有代码期望函数在特定位置返回其结果，而被调用的函数必须遵守该期望。

遗憾的是，如果没有适当的协调机制，则一段代码可能会要求它调用的所有函数在一个位置返回函数结果，同时一组现有的库函数可能会坚持在另一个位置返回自己的函数结果。显然，这些函数与调用代码不兼容。虽然有一些方法可以处理这种情况[通常通过编写位于调用方和被调用方之间能够移动返回结果的外观（facade）代码]，但最好的解决方案是确保各位编程人员在编写代码之前就在何处可以找到函数返回结果等事项达成协议。

此协议被称为应用程序二进制接口（application binary interface，ABI）。某种程度上，ABI是不同代码段之间的一种契约，描述调用约定（在哪里传递值，在哪里返回值，等等）、数据类型、内存使用和对齐，以及其他属性。CPU制造商、编译器编写者和操作系统供应商都提供自己的ABI。出于显而易见的原因，本书使用了Microsoft Windows ABI。

再次强调，必须充分理解在编写自己的汇编语言代码时，在过程之间传递数据的方式完全取决于用户自身。使用汇编语言的好处之一是，用户可以根据具体的过程来确定相应的接口。如果遵循ABI协议，那么用户只需要在调用自己无法控制的代码时（或者在外部代码调用自己的代码时）担心。本书涵盖了在Microsoft Windows下编写汇编语言（特别是与MSVC接口的汇编代码）的内容，因此在处理外部代码（Windows和C++代码）时，必须使用Windows/MSVC ABI。微软ABI指定，传递给printf（）（或者任何C++函数）的前4个参数必须传递到RCX、RDX、R8和R9中。

Windows ABI还声明，函数（过程）会返回RAX寄存器中存储的整数和指针值（可以放入64位中）。因此，如果某些C++代码希望汇编程序返回一个整数结果，则汇编程序在返回之前需要将整数结果加载到RAX中。

为了演示汇编程序如何返回函数结果，我们将使用程序清单1-7中的C++程序（c.cpp文件，这是本书之后演示大多数C++/汇编示例时使用的C++程序）。这个C++程序包括两个额外的函数声明：getTitle（）（由汇编语言代码提供），该函数返回一个指向包含程序标题的字符串的指针（由C++代码打印这个标题）；以及readLine（）（由C++程序提供），汇编语言代码可以调用该函数从用户处读取一行文本（然后放入汇编语言代码的字符串缓冲区中）。

程序清单 1-7 调用汇编语言程序的通用 C++ 代码

try-catch语句块将捕获汇编代码生成的任何异常，当程序异常中止时，用户将得到某种提示。

程序清单1-8提供的汇编代码演示了汇编语言中的一些新概念，第一个新概念是如何将函数的结果返回C++程序中。汇编语言函数getTitle（）返回一个指向字符串的指针，调用方的C++代码将该字符串作为程序的标题进行打印。在“.data”段中，包含一个字符串变量titleStr，该变量初始化为该汇编代码的名称（即“Listing 1-8”）。getTitle（）函数将该字符串的地址加载到RAX寄存器中，并将该字符串指针返回到C++代码中。C++代码在运行汇编代码之前和之后均会打印标题（具体请参见程序清单1-7）。

该程序还演示了如何从用户处读取一行文本。汇编代码调用C++代码中定义的readLine（）函数，readLine（）函数需要两个参数：字符缓冲区的地址（C字符串）和最大缓冲区长度。程序清单1-8中的代码通过RCX寄存器将字符缓冲区的地址传递给readLine（）函数，并通过RDX寄存器将最大缓冲区长度传递给readLine（）函数。最大缓冲区长度必须包含两个额外字符的空间，用于存放换行符和零终止字节。

最后，程序清单1-8演示了如何声明一个字符缓冲区（即一个字符数组）。在“.data”段中，包括以下声明：

input byte maxLen dup（？）

“maxLen dup（？）”操作数指示MASM复制（？）（即未初始化的字节）maxLen次。maxLen是一个常量，由源文件开头的等于伪指令“=”设置为256。（有关更多详细信息，请参阅4.9.1节中的相关内容。）

程序清单 1-8 返回函数结果的汇编语言程序

为了编译和运行程序清单1-7与程序清单1-8中的代码，可以使用如下的命令：

命令行中的选项“/Felisting1-8.exe”指示MSVC将可执行文件命名为listing1-8.exe。如果没有指定“/Fe”选项，那么MSVC将可执行文件命名为c.exe（因为程序清单1-7中的通用示例C++文件名保存为c.cpp，该文件在c.cpp之后）。

1.15 自动化构建过程

到目前为止，每当编译和运行程序时，都需要键入较长的命令行，用户可能会觉得有些麻烦。当用户开始向ml64和cl命令中添加更多命令行选项时，尤其感觉如此。请考虑以下的两个命令：

ml64/nologo/c/Zi/Cp listing1-8.asm

cl/nologo/O2/Zi/utf-8/EHa/Felisting1-8.exe c.cpp listing1-8.obj

listing1-8

“/Zi”选项指示MASM和MSVC将额外的调试信息编译到代码中。“/nologo”选项指示MASM和MSVC在编译期间跳过打印有关版权以及版本的信息。MASM的“/Cp”选项指示MASM在编译时不区分大小写（以便用户在编写汇编语言源文件中不需要使用“options casemap：none”伪指令）。“/O2”选项指示MSVC优化编译器生成的机器代码。“/utf-8”选项指示MSVC使用utf-8 Unicode进行编码（这是ASCII兼容的编码），而不是utf-16编码（或者其他字符编码）。“/EHa”选项指示MSVC处理处理器生成的异常（例如内存访问故障——汇编语言程序中一种常见的异常）。“/Fe”选项指定可执行的输出文件名。每当用户想要构建一个示例程序时，键入所有这些命令行选项将是一项艰巨的工作。

最简单的解决方案是创建一个批处理文件，使构建过程自动化。例如，用户可以在文本文件中键入前面的3个命令行，将该文本文件命名为l8.bat，然后只须在命令行中键入l8即可自动执行这3个命令。这省去了大量的键入工作，还不容易出错。

将这3个命令放入批处理文件的唯一缺点是，该批处理文件只适用于listing1-8.asm源文件，在编译其他程序时用户必须创建一个新的批处理文件。幸运的是，很容易创建一个用于处理任何单个汇编程序源代码文件的批处理文件，该批处理文件对汇编程序源文件进行编译，并链接到通用c.cpp程序。请考虑下面的build.bat批处理文件：

echo off

ml64/nologo/c/Zi/Cp%1.asm

cl/nologo/O2/Zi/utf-8/EHa/Fe%1.exe c.cpp%1.obj

这些命令中的“%1”项用于指示Windows命令行处理器，使用命令行参数（特别地，命令行参数数字1）代替%1。如果从命令行键入以下的内容：

build listing1-8

那么，Windows将执行以下3个命令：

echo off

ml64/nologo/c/Zi/Cp listing1-8.asm

cl/nologo/O2/Zi/utf-8/EHa/Felisting1-8.exe c.cpp listing1-8.obj

使用这个build.bat文件，只须在build命令行上指定汇编语言源文件名（不带.asm后缀），即可编译多个项目。

build.bat在编译并链接程序后，不会运行它。用户可以通过在批处理文件末尾附加一行包含%1的内容，将运行功能添加到批处理文件中。但是，当编译因为C++或汇编语言源文件中的错误而失败时，批处理文件也会尝试运行程序。因此，在使用批处理文件构建程序后，最好手动运行所生成的程序，如下所示：

C：\> build listing1-8

C：\> listing1-8

可以肯定的是，手动方式稍微多一些键入操作，但从长远来看更安全。

微软公司提供了另一个从命令行控制编译的有用工具：makefiles。这是一个比批处理文件更好的解决方案，因为makefiles允许用户根据前面步骤的成功情况，有条件地控制流程中的执行步骤（例如运行可执行文件）。但是，使用微软公司的make程序（nmake.exe）超出了本章的知识范围。make程序是一个值得学习的好工具（第15章将简单介绍该工具的基础知识）。然而，批处理文件对于本书大部分内容中出现的简单项目来说已经足够了，并且使用者只需要很少的额外知识或培训。如果用户有兴趣了解有关makefiles的更多信息，请参阅第15章或者1.17节。

1.16 微软 ABI 注释

微软ABI是一个程序中各个模块之间的契约，用于确保模块（特别是使用不同程序设计语言编写的模块）之间的兼容性。在本书中，C++程序将调用汇编语言代码，汇编模块将调用C++代码，因此汇编语言代码必须遵守微软ABI的契约。

即使编写独立的汇编语言代码，也仍然会调用C++代码，因为将（毫无疑问地）调用Windows应用程序编程接口（application programming interface，API）。Windows API函数都是使用C++编写的，所以对Windows的调用必须遵循Windows ABI的契约。

由于遵循微软ABI的契约非常重要，因此本书每一章（如果适用的话）的最后都包括一小节，重点讨论本章介绍的或者大量使用的微软ABI组件。本节介绍微软ABI中的几个概念：变量大小、寄存器的用途和栈对齐。

1.16.1 变量大小

尽管在汇编语言中处理不同的数据类型完全取决于汇编语言程序员（以及对使用在该数据上的机器指令的选择），但在C++和汇编语言程序之间保持数据大小（以字节为单位）的一致性是至关重要的。表1-6列出了几种常见的C++数据类型和对应的汇编语言类型（类型中蕴含数据大小信息）。

表 1-6 C++ 和汇编语言类型

（续）

尽管MASM提供有符号类型声明（sbyte、sword、sdword和sqword），但汇编语言指令不区分无符号类型变体和有符号类型变体。可以使用无符号指令序列处理有符号整数（sdword），也可以使用有符号指令序列处理无符号整数（dword）。在汇编语言源文件中，这些不同的伪指令主要发挥文档辅助功能，用以帮助描述程序员的意图。

程序清单1-9是一个简单的程序，用于验证这些C++数据类型的大小。

注意： %2zd格式字符串显示size_t类型值（sizeof运算符返回size_t类型的值）。这样可以避免MSVC编译器产生警告信息（如果仅使用%2d，则会生成警告信息）。大多数编译器可以使用%2d。

程序清单 1-9 输出常见 C++ 数据类型的大小

程序清单1-9的build命令和输出结果如下所示：

1.16.2 寄存器的用途

汇编语言过程（包括汇编语言主函数）中寄存器的用途（register usage）也受某些微软ABI规则的约束。在一个过程中，微软ABI对寄存器的用途有如下说明。

●调用函数的代码可以通过寄存器RCX、RDX、R8和R9，将前四个（整数）参数分别传递给函数（过程）。程序可以通过寄存器XMM0、XMM1、XMM2和XMM3传递前四个浮点参数。

●寄存器RAX、RCX、RDX、R8、R9、R10和R11是易失性（volatile）寄存器，这意味着函数（过程）不需要在函数（过程）调用中保存寄存器的值。

●寄存器XMM0/YMM0到XMM5/YMM5也是易失性寄存器。函数（过程）不需要在调用过程中保存这些寄存器的值。

●寄存器RBX、RBP、RDI、RSI、RSP、R12、R13、R14和R15是非易失性（nonvolatile）寄存器。过程（函数）必须在调用过程中保存这些寄存器的值。如果一个过程修改了其中一个寄存器的值，则该过程必须在第一次修改之前保存寄存器的值，并在从函数（过程）返回之前从保存的位置恢复寄存器的值。

●寄存器XMM6到XMM15是非易失性寄存器。函数必须在调用其他函数（过程）期间保存这些寄存器的值（即当过程返回时，这些寄存器必须包含在进入该过程时所具有的相同值）。

●使用x86-64浮点协处理器指令的程序，必须在过程调用中保存浮点控制字的值。此类程序还应清除浮点栈的内容。

●任何使用x86-64方向标志位的过程（函数），必须在从过程（函数）中返回时清除该标志位。

微软C++期望函数返回值出现在以下两个位置。整数（和其他非标量）结果返回到RAX寄存器（最多64位）。如果返回值类型小于64位，则RAX寄存器的高位未定义。例如，如果函数返回短整型（16位）结果，则RAX寄存器中的第16位至第63位可能包含垃圾数据。微软的ABI规定，浮点（和向量）函数返回结果必须返回到XMM0寄存器。

1.16.3 栈对齐

在本章的源代码程序清单中，包含一些“魔法”指令，这些“魔法”指令基本上是从RSP寄存器中加或者减一个值。这些指令与栈对齐有关（这是微软ABI契约的要求）。本章（以及随后的几章）在代码中提供了这些指令，但没有做进一步解释。有关这些指令用途的更多详细信息，请参见第5章。

1.17 拓展阅读资料

本章涵盖了很多相关知识。虽然还有很多关于汇编语言程序设计的知识需要读者学习，但本章结合HLL（特别是C/C++），为读者提供了足够的信息，让读者可以开始编写真正的汇编语言程序。

本章涵盖了许多主题，其中三个主要的主题是x86-64 CPU体系结构、简单MASM程序的语法，以及与C标准库的接口。

以下资源提供了有关makefiles的更多信息：

●Wikipedia：https://en.wikipedia.org/wiki/Make_（software）。

● Managing Projects with GNU Make （Robert Mecklenburg,O'Reilly Media，2004）。

● The GNU Make Book （John Graham-Cumming，No Starch Press,2015）。

● Managing Projects with make （Andrew Oram and Steve Talbott,O'Reilly&Associates,1993）。

●微软自由开发者提供的网站:https://visualstudio.microsoft.com/free-developer-offers/。

有关MASM的更多信息：

●微软官网的C++、C以及汇编器文档：https://docs.microsoft.com/en-us/cpp/assembler/masm/masm-for-x64-ml64-exe？view=msvc-160/。

● The Waite Group's Microsoft Macro Assembler Bible （涵盖MASM 6。虽然MASM 6仅针对32位汇编语言程序设计，但是该书仍然包含大量有关MASM的参考信息）：https://www.amazon.com/Waite-Groups-Microsoft-Macro-Assembler/dp/0672301555/。

有关ABI的更多信息：

●最完善的文档请参考Agner Fog的个人主页：https://www.agner.org/optimize/。

●以下微软网址也包含微软ABI调用约定的详细信息：https://docs.microsoft.com/en-us/cpp/build/x64-callingconvention？view=msvc-160。也可以在互联网上搜索Microsoft calling conventions关键词以获得更多信息。

1.18 自测题

1.Windows命令行解释器程序的名称是什么？

2.MASM可执行程序文件的名称是什么？

3.三条主要系统总线的名称是什么？

4.哪些寄存器覆盖了RAX寄存器？

5.哪些寄存器覆盖了RBX寄存器？

6.哪些寄存器覆盖了RSI寄存器？

7.哪些寄存器覆盖了R8寄存器？

8.哪个寄存器保存条件码标志位？

9.以下数据类型各占用多少个字节？

a.word

b.dword

c.oword

d.带一个“4 dup（？）”操作数的qword

e.real8

10.如果一个8位（字节）内存变量是mov指令的目标操作数，那么哪些源操作数是合法的？

11.如果mov指令的目标操作数是EAX寄存器，那么可以加载到该寄存器中的最大常量（以位为单位）是多少？

12.对于add指令，请填写下表中指定的所有目标操作数对应的最大常量大小（以位为单位）。

13.lea指令的目标（寄存器）操作数大小是多少？

14.lea指令的源（内存）操作数大小是多少？

15.用于调用过程或函数的汇编语言指令名称是什么？

16.用于从过程或函数返回的汇编语言指令名称是什么？

17.ABI表示什么含义？

18.在Windows ABI中，在何处返回以下的函数操作结果？

a.8位字节值

b.16位字值

c.32位整数值

d.64位整数值

e.浮点值

f.64位指针值

19.在何处将第一个参数传递给微软ABI兼容函数？

20.在何处将第二个参数传递给微软ABI兼容函数？

21.在何处将第三个参数传递给微软ABI兼容函数？

22.在何处将第四个参数传递给微软ABI兼容函数？

23.汇编语言中的哪种数据类型对应于C/C++程序设计语言中的long int？

24.汇编语言中的哪种数据类型对应于C/C++程序设计语言中的long long unsigned？

[1] 以下讨论将使用较旧的32位x86-64处理器的4GB地址空间。运行现代64位操作系统的典型x86-64处理器最多可访问2 ⁴⁸ 个内存位置，或使用的地址空间略高于256TB。

vip

第2章计算机数据表示和运算

在尝试学习汇编语言的过程中，许多初学者会在学习二进制和十六进制数制系统时遇到困难。虽然二进制数字、十六进制数字与通常所用的数字之间的确存在一些差异，但它们的优点远远大于缺点。因此，理解二进制和十六进制数制系统非常重要，它们可以简化对许多其他主题的讨论，包括位运算、有符号数字的表示、字符代码和打包数据主题。

本章讨论几个重要概念，具体包括以下内容：

●二进制和十六进制数制系统

●二进制数据的组织形式（位、半字节、字节、字和双字）

●有符号和无符号数制系统

●二进制值的算术、逻辑、移位和循环移位运算

●位字段和打包数据

●浮点数和二进制代码的十进制格式

●字符数据

以上内容都是基本知识，学习本书其余的章节内容离不开读者对这些概念的理解。如果读者已经从其他课程或者研究中熟悉了这些术语，那么至少应该在进入下一章之前浏览一下这些知识。如果读者对本章的知识并不熟悉，或者只是一知半解，那么应在继续之前仔细学习本章内容。本章的所有内容都很重要！请千万不要跳过任何一个知识点。

2.1 数制系统

大多数现代计算机系统都不使用十进制（以10为基数），而是通常采用二进制或者二进制补码（two's complement）的数制系统。

2.1.1 十进制数制系统的回顾

长期以来，人们一直使用十进制数制系统，因此可能会想当然地认为所有数字都是十进制数。现在，当看到像123这样的数字时，不要去考虑数值123，而是在大脑中考虑它总共代表多少项。实际上数字123在十进制数制系统中的表示如下：

（1×10 ² ）+（2×10 ¹ ）+（3×10 ⁰ ）

或者

100+20+3

在十进制的位置数制系统中，小数点左侧的每一位数字都代表一个数值，它们是0～9之间的数字乘以10的递增次方幂；小数点右侧的每一位数字也都代表一个数值，它们是0～9之间的数字乘以10的递增负次方幂。例如，123.456可以表示为：

（1×10 ² ）+（2×10 ¹ ）+（3×10 ⁰ ）+（4×10 ^-1^ ）+（5×10 ^-2^ ）+（6×10 ^-3^ ）

或者

100+20+3+0.4+0.05+0.006

2.1.2 二进制数制系统

在大多数现代的计算机系统中都采用二进制逻辑进行运算。计算机使用两个电平（通常是0V和+2.4～5V）表示数值，这两个电平正好可以表示两个不同的数值。这两个数值可以是任意两个不同的数值，但通常表示二进制数制系统中的两个数值0和1。

二进制数制系统与十进制数制系统的原理类似，不同之处在于二进制数制系统中仅存在0和1（而不是0～9），并且使用的是2的幂（而不是10的幂）。因此，将二进制数字转换为十进制数字非常容易。对于二进制字符串中的每个1，都要乘上2 ⁿ ，其中 n 是从0开始计数的1所在的位置。例如，二进制数11001010 ₂ 可以表示为：

（1×2 ⁷ ）+（1×2 ⁶ ）+（0×2 ⁵ ）+（0×2 ⁴ ）+（1×2 ³ ）+（0×2 ² ）+（1×2 ¹ ）+（0×2 ⁰ ）

=128 ₁₀ +64 ₁₀ +8 ₁₀ +2 ₁₀

=202 ₁₀

总而言之，首先必须找到所有2的幂，然后将这些幂相加，结果就等于十进制数字。

将十进制数字转换为二进制数字要稍微复杂一些，一种简单方法是“偶/奇—除2”（even/odd—divide-by-two）算法。该算法使用以下的步骤。

（1）如果数字为偶数，则得到一个0。如果数字为奇数，则得到一个1。

（2）将数字除以2，并舍弃小数部分或余数。

（3）如果商为0，则算法完成。

（4）如果商不是0并且是奇数，则在当前二进制串前插入1；如果数字为偶数，则在当前二进制串前面加0。

（5）返回到步骤（2），并重复操作步骤。

虽然在高级计算机程序设计语言中，二进制数不太重要，但它们在汇编语言程序中随处可见。所以读者必须熟悉二进制数。

2.1.3 二进制约定

从最纯粹的意义上讲，每个二进制数都可以包含无限多位的数字，或者称为二进制位（bit，简称位，是binary digit的缩写）。例如，我们可以使用以下任意一种方式来表示数字5：

101　00000101　0000000000101　…　000000000000101

二进制数之前可以包含任意数量的前导0，而不改变其值的大小。由于x86-64通常使用8位的组，所以我们将使用前导0把所有二进制数扩展到4或者8的倍数位。按照这个约定，我们将5表示为01012或000001012。

对于较大的二进制数，为了增加其可读性，我们将每4位分为一组，组之间使用下划线分隔。例如，我们将1010111110110010写成1010_1111_1011_0010的形式。

注意： MASM不允许在二进制数的中间插入下划线。在较大数内部使用下划线分隔只是本书为便于阅读而采用的约定。

我们将按如下方式对每个二进制位进行编号。

（1）二进制数中最右边的位编号为第0位。

（2）从右向左的每一个二进制位连续编号。

一个8位的二进制数使用第0位～第7位的位置编号：

X ₇ X ₆ X ₅ X ₄ X ₃ X ₂ X ₁ X ₀

一个16位的二进制数使用第0位～第15位的位置编号：

X ₁₅ X ₁₄ X ₁₃ X ₁₂ X ₁₁ X ₁₀ X ₉ X ₈ X ₇ X ₆ X ₅ X ₄ X ₃ X ₂ X ₁ X ₀

一个32位的二进制数使用第0位～第31位的位置编号，依此类推。

第0位称为低阶（low-order，LO）位，有些人将其称为最低有效位（least signifcant bit）。最左边的位称为高阶（high-order，HO）位，或者称为最高有效位（most signifcant bit）。我们将通过中间位各自的位置编号来引用这些位。

在MASM中，可以将二进制数指定为以字符b结尾的0或1串。请记住，MASM不允许在二进制数中使用下划线。

2.2 十六进制数制系统

不好的是，二进制数非常冗长。例如，202 ₁₀ 需要8个二进制位来表示，但只需要3个十进制位就可以表示。当处理较大的数时，使用二进制表示很快就会变得非常不适用。然而，计算机是采用二进制进行“思考”的，所以大多数时候使用二进制编码系统会非常方便。虽然我们可以在十进制表示和二进制表示之间进行转换，但这种转换并不是一项简单的任务。

十六进制（基数为16）数制系统解决了二进制系统中固有的许多问题：十六进制数非常紧凑，且向二进制数的转换非常简单，反之亦然。因此，大多数计算机系统工程师使用十六进制数制系统。

十六进制数的基数是16，用十六进制小数点左边的每个位乘以16的递增整数次幂就得到了对应的十进制数。例如，1234 ₁₆ 等于：

（1×16 ³ ）+（2×16 ² ）+（3×16 ¹ ）+（4×16 ⁰ ）

或者

4096+512+48+4=4660 ₁₀

每个十六进制位分别对应0～15 ₁₀ 之间16个数字中的某一个。因为只有10个十进制位，所以我们需要增加六个额外的数字来表示10 ₁₀ ～15 ₁₀ 对应的十六进制位。我们没有为这些数字创建新符号，而是分别使用字母A～F来表示。有效的十六进制数示例如下所示：

1234 ₁₆ DEAD ₁₆ BEEF ₁₆ 0AFB ₁₆ F001 ₁₆ D8B4 ₁₆

由于我们经常需要向计算机系统中输入十六进制数，而在大多数计算机系统中，我们不能使用下标来表示相关值的基数，因此需要采用一种不同的机制来表示十六进制数。我们将采用以下MASM约定。

（1）所有十六进制数均以数字字符开头，后缀为h。例如，123A4h和0DEADh。

（2）所有二进制数以b为后缀。例如，10010b。

（3）十进制数没有任何后缀字符。

（4）如果从上下文中可以很清楚地判别出基数，本书可能会省略后缀字符h或者b。

以下是一些使用MASM表示法的有效十六进制数示例：

1234h 0DEADh 0BEEFh 0AFBh 0F001h 0D8B4h

正如所见，十六进制数非常紧凑，并且可读性较好。此外，我们还可以轻松地在十六进制数和二进制数之间进行转换。表2-1提供了将十六进制数转换为二进制数所需的信息，反之亦然。

表 2-1 二进制与十六进制之间的转换

为了将十六进制数转换为二进制数，只需要将数中的每个十六进制数字替换为相应的4位二进制数字。例如，对于0ABCDh，可以根据表2-1对其中每个十六进制数字进行转换，如下所示：

将二进制数转换为十六进制数的方法也非常简单，以下为转换步骤。

（1）使用前导0填充二进制数，以确保该二进制数的位数是4的倍数。例如，给定二进制数1011001010，在该数字的左侧添加2位0，使其包含12位，即001011001010。

（2）将二进制数分成若干组，每组包含4位，例如，0010_1100_1010。

（3）在表2-1中查找这些组，并替换成对应的十六进制数字，因此得到2CAh。

这与十进制数和二进制数之间的转换（或者十进制数和十六进制数之间的转换）复杂度形成了鲜明的对比！

因为十六进制数和二进制数之间的转换是一个需要反复执行的操作，所以建议读者花点时间牢记其转换表（表2-1）。即使可以使用计算器进行转换，我们也会发现，在进行二进制数与十六进制数之间的转换时，手工转换会更快速，也更便捷。

2.3 关于数字与表示的注释

人们常常混淆了数字及其表示的概念。刚刚开始学习汇编语言的学生通常会提出这样一个疑问：“在EAX寄存器中有一个二进制数，如何将其转换为EAX寄存器中的十六进制数呢？”答案是：“不需要转换。”

尽管可以提出一个强有力的论点，即内存或寄存器中的数是用二进制表示的，但最好将内存或寄存器中的值视为抽象的数字量（abstract numeric quantity）。128、80h或10000000b等符号串并不是不同的数字，它们只是同一抽象数字量的不同表示，我们称该量为一百二十八。在计算机内部，数字就是一个数字，与其表示形式无关，仅当以人类可阅读的形式输入或输出值时，才会区分该值的表示形式。

数字量可供人类阅读的形式总是字符串。为了以人类可阅读的形式打印值128，必须将其转换为三字符序列“128”，这将提供数字量的十进制表示形式。如果需要，也可以将值128转换为三字符序列“80h”。这里跟“128”表示的是一个相同的值，但我们将其转换为不同的字符序列，因为（大概）我们希望使用十六进制表示法而不是十进制表示法来查看数值。同样，如果我们希望查看数值对应的二进制表示，就必须将这个数值转换成一个包含1个1和7个0的字符串。

纯汇编语言没有通用的打印或者输出函数，可以调用打印或输出函数在控制台上将数字量显示为字符串。我们可以编写自定义的过程来处理这个显示过程（本书稍后将讨论其中的一些过程）。目前，本书中的MASM代码依赖于C标准库的printf（）函数来显示数值。请阅读程序清单2-1中的程序，该程序将各种数值转换为其等价的十六进制数值。

程序清单 2-1 十进制数到十六进制数的转换程序

程序清单2-1使用了第1章中的c.cpp通用程序（以及build.bat通用批处理文件）。在命令行中，可以使用以下命令编译和运行这个程序：

C：\> build listing2-1

C：\> echo off

Assembling：listing2-1.asm

c.cpp

C：\> listing2-1

Calling Listing 2-1：

i=1，converted to hex=1

j=123，converted to hex=7b

k=456789，converted to hex=6f855

Listing 2-1 terminated

2.4 数据组织

单纯从数学的角度而言，一个数的表示可以取任意多位。而从另一个角度看，计算机通常使用特定数量的位来表示数。常见的二进制位组包括：1位一组（bit，位）、4位一组（nibble，半字节）、8位一组（byte，字节）、16位一组（word，字）、32位一组（double words或者dwords，双字）、64位一组（quad words或者qwords，四字）、128位一组（octal words或者oword，八字）等。

2.4.1 位

在二进制计算机中，最小的数据单位是位。使用单个二进制位，可以表示任意两个不同的数据项。例如，0和1、真和假、对和错。但是，二进制位并不限于表示二进制数据类型，它也可以表示数值723和1245，或者表示红色和蓝色，甚至表示红色和数值3256。可以使用单个二进制位表示任意两个不同的值，但只能表示两个值。

不同的二进制位可以代表不同的对象。例如，可以使用某个二进制位表示值0和1，而用另一个二进制位表示值true和false。那么该如何区分这些二进制位所代表的对象呢？答案是无法区分。这也阐明了计算机数据结构背后的全部思想：数据代表的对象取决于我们的定义。如果使用二进制位表示布尔值，则该位（根据我们的定义）表示true或者false。当然，我们必须保持前后表述的一致性。如果在程序的某一个位置点上使用某个二进制位表示true或者false，那么在后面的代码中就不应使用该位来表示红色或者蓝色。

2.4.2 半字节

半字节是由4个二进制位组成的数据类型。对于半字节，最多可以表示16个不同的值，因为4个二进制位最多可以组成16种不同的字符串：

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

1100

1101

1110

1111

半字节是一种有趣的数据结构，因为二进制编码十进制（Binary-coded decimal，BCD）数需要4个二进制位来表示，十六进制数中的单个位也需要4个二进制位来表示。在十六进制数的情况下，0、1、2、3、4、5、6、7、8、9、A、B、C、D、E和F都使用4个二进制位来表示。BCD使用10个不同的数字（0、1、2、3、4、5、6、7、8和9），同样需要4个二进制位表示（因为采用3个二进制位只能表示8个不同的值，而采用4个二进制位表示的其他6个值在BCD表示中从未被使用）。事实上，任何16个不同的值都可以用半字节表示，只是十六进制数和BCD数是半字节表示的主要用途。

2.4.3 字节

毫无疑问，x86-64微处理器所使用的最重要的数据结构是字节。字节由8个二进制位组成。x86-64上的主存和I/O地址都采用字节地址。这就意味着x86-64程序可以单独访问的最小项是由8个二进制位表示的数值。为了访问任何较小的数据，我们需要读取包含该数据的字节，并屏蔽掉不需要的二进制位。字节中的二进制位通常用0～7进行编号，如图2-1所示。

第0位是最低位，第7位是最高位。我们将根据位的编号来引用数值中所有的二进制位。一个字节正好包含两个半字节（参见图2-2）。

第0位～第3位构成低阶半字节，第4位～第7位构成高阶半字节。因为一个字节正好包含两个半字节，所以一个字节需要2个十六进制数来表示。

图2-2 一个字节中的两个半字节

因为一个字节包含8个二进制位，所以字节可以表示2 ⁸ （即256）个不同的数值。通常情况下，我们将使用一个字节来表示0～255范围内的数值、-128～+127范围内的有符号数值（具体请见2.7节中的相关内容）、ASCII IBM字符代码，以及其他特殊数据类型（只要这些数据类型的取值不超过256种）。许多数据类型包含的数据项都少于256个，因此8个二进制位通常就足够了。

由于x86-64是按字节寻址的计算机，对整个字节进行操作比对单个二进制位或半字节更为有效，因此使用一个整字节来表示不需要超过256个数据项的数据类型更为有效，甚至用不了8个二进制位就足以表示数据。

对于一个字节而言，其最重要的用途在于保存字符。无论是键盘上键入的字符，还是屏幕上显示的字符，再或者是打印机上打印的字符，它们都对应一个数字值。为了与世界其他地区通信，PC通常使用ASCII字符集或者Unicode字符集的变体。ASCII字符集包含128个有定义的编码。

在MASM程序中，字节也是我们可以创建的最小变量。为了创建一个字节变量，应该使用byte数据类型，如下所示：

.data

byteVar byte？

byte数据类型是半非类型化的数据类型。与字节对象关联的唯一类型信息是字节大小（一个字节）。可以将任意一个8位的二进制值（较小的有符号整数、较小的无符号整数、字符等）存储到字节变量中。最终由程序来控制存储在字节变量的对象类型。

2.4.4 字

字是由16个二进制位组成的数据类型。如图2-3所示，我们将一个字中的二进制位用0～15进行编号。与字节一样，第0位是低阶位。对于字而言，第15位是高阶位。当引用字中的其他位时，我们将使用其位置编号。

图2-3 字中的二进制位编号

一个字正好包含2个字节（因此，有4个半字节）。第0位～第7位构成低阶字节，第8位～第15位构成高阶字节（参见图2-4和图2-5）。

图2-4 一个字中的两个字节

图2-5 一个字中的半字节

使用16个二进制位可以表示2 ¹⁶ （即65536）个数值。这些数值可以是0～65535之间的值，也可以是通常情况下的有符号数值-32768～+32767，或者是取值不超过65536个的任何其他数据类型。

字主要用于表示“短”有符号整数值、“短”无符号整数值以及Unicode字符。无符号数值由对应于字中各个位的二进制值表示。有符号数值以二进制补码形式来表示数值（具体请参见2.8节中的相关内容）。作为Unicode字符，字最多可以表示65536个字符，允许在计算机程序中使用非罗马字符集。与ASCII一样，Unicode也是一种国际标准，允许计算机处理非罗马字符，例如汉字、希腊字母和俄语字母。

与字节一样，我们也可以在MASM程序中创建字变量。为了创建一个字变量，可以使用word数据类型，如下所示：

.data

w word ？

2.4.5 双字

顾名思义，一个双字由两个字组成。因此，双字的长度为32位，如图2-6所示。

图2-6 双字中的二进制位编号

很显然，1个双字可以分为1个高阶字和1个低阶字、4个字节或者8个不同的半字节（具体请参见图2-7）。

图2-7 双字中的半字节、字节和字

双字可以代表各种不同的对象。一般使用双字来表示32位的整数值（允许0～4294967295范围内的无符号数值，或者-2147483648～2147483647范围内的有符号数值）。32位的浮点数值也可以使用双字来表示。

可以使用dword数据类型创建一个双字变量，如下例所示：

.data

d dword ？

2.4.6 四字和八字

四字（64位）值也非常重要，因为64位整数、指针和某些浮点数据类型需要64个二进制位来表示。同样，现代x86-64处理器的SSE/MMX指令集可以处理64位的数值。当然，八字（128位）数值也非常重要，因为AVX/SSE指令集可以处理128个二进制位所表示的数值。MASM允许使用qword和oword数据类型来声明64位的数值以及128位的数值，如下所示：

.data

o oword ？

q qword ？

但是，不能使用标准指令（例如mov、add和sub）直接操作128位的整数对象，因为标准x86-64整数寄存器一次只能处理64位的数据。在第8章中，我们将讨论如何处理这些扩展精度值，第11章将讨论如何使用SIMD指令直接操作oword值。

2.5 位的逻辑运算

我们将使用十六进制数和二进制数，执行四种初级的逻辑运算（布尔函数）：AND（与）、OR（或）、XOR（异或）和NOT（非）。

2.5.1 逻辑与运算

逻辑与运算是一种二元运算（dyadic/binary operation，表示该运算只接受两个操作数）。这些操作数都是单独的二进制位。逻辑与运算的示例如下所示：

0 and 0=0

0 and 1=0

1 and 0=0

1 and 1=1

表示逻辑与运算的紧凑方法是使用真值表。真值表的形式如表2-2所示。

这就像我们在学校里学习的乘法口诀表一样，第一列中的值对应于逻辑与运算的左操作数，第一行中的值对应于逻辑与运算的右操作数。位于行和列相交处的数值（对于特定的一对输入值）是将对应第一行与第一列的两个数值进行逻辑与运算的结果。

表 2-2 逻辑与的真值表

用文字来表述，逻辑与运算的含义是：“如果第一个操作数为1，第二个操作数为1，那么结果为1；否则，结果为0。”我们也可以这样表述：“如果其中一个或两个操作数都是0，那么结果是0。”

可以使用逻辑与运算强制得到一个值为0的结果：如果其中一个操作数为0，则无论其他操作数如何，结果始终为0。例如，在表2-2中，第二行仅包含值0，第二列也仅包含值0。此外，如果一个操作数包含1，则结果恰好是另一个操作数的值。逻辑与运算的这些结果非常重要，特别是当我们想将某些位强制设为0时。我们将在下一节中，对逻辑与运算的这些用法进行深入研究。

2.5.2 逻辑或运算

逻辑或运算也是一种二元运算。其定义如下所示：

0 or 0=0

0 or 1=1

1 or 0=1

1 or 1=1

逻辑或运算的真值表如表2-3所示。

通俗而言，逻辑或运算的含义是：“如果第一个操作数或者第二个操作数（或两个操作数）为1，那么结果为1；否则，结果为0。”这也称为兼或运算或者同或运算（inclusive-or operation）。

表 2-3 逻辑或的真值表

如果逻辑或运算的一个操作数为1，那么无论另一个操作数的值是多少，结果始终为1。如果一个操作数为0，那么结果始终是另一个操作数的值。与逻辑与运算一样，这是逻辑或运算的一个重要附加作用，后面将证实这一点非常有用。

请注意，这种形式的逻辑兼或运算与标准文字“或者”的含义存在差异。考虑这样一个语句：“我将要去商店或者我将要去公园”。这句话意味着说话者将要去商店和公园中的一个地方，而不是两个地方都去。因此，文字中的逻辑或与计算机中的逻辑兼或的运算略有不同。事实上，文字中的或符合的是异或（XOR）运算的定义。

2.5.3 逻辑异或运算

逻辑异或运算也是一种二元运算。其定义如下所示：

0 xor 0=0

0 xor 1=1

1 xor 0=1

1 xor 1=0

逻辑异或运算的真值表如表2-4所示。

采用文字来表述，逻辑异或运算的含义就是：“如果第一个操作数或第二个操作数为1，且不是两者均为1，则结果是1；否则，结果是0。”逻辑异或运算比逻辑或运算更接近文字“或者”的意思。

表 2-4 逻辑异或的真值表

如果逻辑异或运算中的一个操作数是1，则结果总是另一个操作数的相反值。也就是说，假如一个操作数为1，那么如果另一个操作数为1，则结果为0；如果另一个操作数为0，则结果为1。如果第一个操作数为0，那么结果正好是第二个操作数的值。这个功能允许我们有选择地反转一个位串中的某些二进制位。

2.5.4 逻辑非运算

逻辑非运算是一元运算（monadic operation，意味着这个运算只接受一个操作数）：

not 0=1

not 1=0

逻辑非运算的真值表如表2-5所示。

表 2-5 逻辑非的真值表

2.6 二进制数和位串的逻辑运算

在上一节中，我们定义了单个位操作数的逻辑函数。由于x86-64使用8、16、32、64位或更多位构成的组，因此我们需要扩展这些函数的定义，以处理超过两个二进制位的数据。

x86-64上的逻辑函数按位（或逐位）进行运算。给定两个数值，这些函数对这两个值的第0位进行运算，产生结果的第0位；然后，函数对输入值的第1位进行运算，生成结果的第1位，依此类推。例如，要计算以下两个8位数字的逻辑与运算结果，则应单独对每列执行逻辑与运算：

1011_0101b

1110_1110b

----------

1010_0100b

同样，也可以将这种逐位运算的方法应用于其他逻辑函数。

如果要对两个十六进制数执行逻辑运算，那么首先应该将它们转换为二进制数。

在处理位串（例如二进制数）时，使用逻辑与/逻辑或运算强制二进制位为0或1的能力以及使用逻辑异或运算反转二进制位的能力非常重要。这些运算允许我们有选择地操纵位串中的某些位，而不影响其他位的值。

例如，如果有一个8位二进制值 X ，并且我们希望将其第4位～第7位设置为0，那么可以对值 X 与二进制值0000_1111b进行逻辑与运算，这种按位逻辑与运算会将 X 的最高4位强制设置为0，而保持 X 的最低4位的值不变。同样，可以对0000_0001b与 X 进行逻辑或运算，将 X 的低阶位强制设置为1；对0000_0100b与 X 进行逻辑异或运算，从而反转 X 的第2位。

使用逻辑与、逻辑或和逻辑异或运算，以这种方式操纵位串的方法，称为掩蔽（masking，也称为屏蔽）位串。我们之所以使用术语“掩蔽”是因为当我们希望将某些二进制位强制设置为0、1或其将其位取反时，可以使用某些值（1用于逻辑与，0用于逻辑或/异或）对某些位增加或者去除掩蔽。

x86-64 CPU提供了四条指令，用于对操作数执行这些位逻辑运算。这四条指令分别是and、or、xor和not。and、or和xor指令的语法与add和sub指令相同：

and dest ， source

or dest ， source

xor dest ， source

这些操作数与add指令的操作数具有相同的限制。具体而言，source（源操作数）必须是一个常量、内存或寄存器操作数，dest（目标操作数）必须是内存或寄存器操作数。此外，操作数的大小必须相同，并且不能两者都是内存操作数。如果目标操作数为64位，源操作数为常量，且该常量限制为32位（或更少的位数），则CPU将该值有符号扩展至64位（具体请参阅2.8节的相关内容）。

这些指令按位进行逻辑运算，计算等式如下：

dest= dest operator source

x86-64逻辑非指令的语法稍有不同，因为该指令只有一个操作数。逻辑非指令的语法采用以下形式：

not dest

逻辑非指令的计算等式如下：

dest=not（ dest ）

其中，dest操作数必须是寄存器或内存操作数。逻辑非指令将反转指定目标操作数中的所有的二进制位。

程序清单2-2中的代码读取用户输入的两个十六进制数，并计算它们的逻辑与、逻辑或、逻辑异或和逻辑非的运算结果。

程序清单 2-2 逻辑与、逻辑或、逻辑异或和逻辑非运算的示例

构建和运行此代码的结果如下所示：

顺便说一下，我们经常会看到以下“魔法”指令：

xor reg ， reg

对寄存器与其自身进行逻辑异或运算，会将该寄存器设置为0。除了8位寄存器外，相比将立即数常量转移到寄存器中的操作方式，xor指令通常更高效。请考虑以下代码：

xor eax，eax；机器代码只有2字节长

mov eax，0；机器代码长度根据寄存器的不同，通常为6字节长

在处理64位寄存器时，节省的空间甚至更大（因为立即数常量0的长度本身就是8个字节）。

2.7 有符号数和无符号数

到目前为止，我们将二进制数均视为无符号数。二进制数…00000表示0、…00001表示1、…00010表示2，依此类推，直到无穷大。 n 个二进制位可以表示2 ⁿ 个无符号数。那么应该如何表示负数呢？如果我们将一半可能的组合分配给负值，另一半分配给正值和0，那么用 n 位二进制就可以表示-2 ⁿ ^-1^ ～+2 ⁿ ^-1^ -1范围内的有符号数。因此，我们使用8位（字节）可以表示负值-128～-1以及非负值0～127；使用16位（字），可以表示-32768～+32767范围内的数值；使用32位（双字），可以表示-2147483648～+2147483647范围内的数值。

在数学以及计算机科学中，补码方法（complement method）将负数和非负数（0和正数）编码成两个相等的集合，这样它们就可以使用相同的算法（或硬件）执行加法运算，并产生正确的结果，因为这其中不需要考虑数值的符号是什么。

x86-64微处理器使用补码表示法来表示有符号数。在补码系统中，一个数的最高位是符号位（正是这个符号位将整数分成两个数量相等的集合）。如果符号位为0，则数为正（或0），并使用标准的二进制格式表示；如果符号位为1，则数为负（采用补码形式，这是一种神奇的格式，支持负数和非负数的加法，无需特殊硬件的支持，稍后将讨论）。下面是一些例子。

对于16位的数：

●8000h为负数，因为最高位为1

●100h为正数，因为最高位为0

●7FFFh为正数

●0FFFFh为负数

●0FFFh为正数

为了将正数转换为负数，可以使用以下算法。

（1）对该数的每一位取反（应用逻辑非函数）。

（2）将取反后的结果加1，并忽略最高位的任何进位。

利用这个算法生成的位模式，满足补码形式的数学定义。特别是，将使用此格式的负数和非负数相加，会产生预期的结果。

例如，计算-5的8位补码的过程如下：

●0000_0101b 5（二进制）

●1111_1010b 对所有二进制位分别取反

●1111_1011b 加1，得到结果

对-5的补码执行补码运算，结果将再次得到原始值0000_0101b：

●1111_1011b -5的补码

●0000_0100b 对所有二进制位分别取反

●0000_0101b 加1，得到结果（+5）

请注意，将+5和-5相加（忽略最高位上的任何进位），将会得到预期的结果0：

1111_1011b -5的补码

+0000_0101b 5

----------

（1）0000_0000b 忽略进位，结果为0

以下示例给出了一些正的16位有符号数和负的16位有符号数的示例：

●7FFFh：+32767，最大的16位正数

●8000h：-32768，最小的16位负数

●4000h：+16384

为了将示例数值转换为自己的负数（即对其取负），可以按照以下方法进行操作：

7FFFh：0111_1111_1111_1111b +32767

1000_0000_0000_0000b 对所有二进制位分别取反（8000h）

1000_0000_0000_0001b 加1（8001h或-32767）

4000h：0100_0000_0000_0000b +16384

1011_1111_1111_1111b 对所有二进制位分别取反（0BFFFh）

1100_0000_0000_0000b 加1（0C000h或-16384）

8000h：1000_0000_0000_0000b -32768

0111_1111_1111_1111b 对所有二进制位分别取反（7FFFh）

1000_0000_0000_0000b 加1（8000h或-32768）

8000h取反以后变成了7FFFh，再加1，就得到8000h！等等，这是怎么回事呢？-（-32768）等于-32768吗？当然不是。只是由于+32768的值不能使用16位有符号数表示，因此我们不能对最小的负数再进行取负运算。

通常情况下，我们不需要手动执行补码运算。x86-64微处理器提供一条指令neg（negate），来执行此操作：

neg dest

该指令完成“dest=-dest；”运算，并且操作数必须是内存位置或者寄存器。neg可以对字节、字、双字和四字大小的对象进行操作。因为这是一个有符号整数运算，所以只对有符号整数值进行运算才有意义。程序清单2-3中的代码演示了补码运算和对有符号8位整数值运行的neg指令。

程序清单 2-3 补码运算的示例

以下命令构建并运行程序清单2-3中的代码：

C：\> build listing2-3

C：\> echo off

Assembling：listing2-3.asm

c.cpp

C：\> listing2-3

Calling Listing 2-3：

Enter an integer between 0 and 127：123

Value in hexadecimal：7b

Invert all the bits（hexadecimal）：84

Add 1（hexadecimal）：85

Output as signed integer：-123

Using neg instruction：-123

Listing 2-3 terminated

除了补码运算（通过取反加1以及使用neg指令实现），该程序还演示了一个新功能：获取用户的数字输入。从用户处读取输入字符串（使用c.cpp源文件中的readLine（）函数），然后调用C标准库中的atoi（）函数，就可以完成数字输入。atoi（）函数需要单个参数（在RCX寄存器中传递），该参数指向包含整数值的字符串，此函数将该字符串转换为相应的整数并返回RAX中的整数值。

2.8 符号扩展和零扩展

将8位补码值转换为16位，或者将16位补码值转换为8位，可以通过符号扩展（sign extension）和符号缩减（sign contraction）运算来实现。

在将有符号值从一定数量的位扩展到更多数量的位时，只需将符号位复制到新格式的所有附加位中。例如，为了将8位数值符号扩展成16位数值，可以将8位数值的第7位复制到16位数值的第8～15位。为了将16位数值符号扩展成双字，可以将16位数值的第15位复制到双字的第16～31位。

在处理不同长度的有符号值时，必须使用符号扩展。例如，为了将字节数值累加到字数值中，必须先将字节数值符号扩展成字数值，再将两个值相加。其他运算（尤其是乘法和除法）可能需要符号扩展成32位，具体请参见表2-6。

为了将无符号值从一定数量的位扩展到更多数量的位，必须对无符号值进行零扩展，具体请参见表2-7。零扩展（zero extension）非常简单，只需要将0储存到较长操作数的HO字节中。例如，为了将8位值82h零扩展成16位值，可以将0附加到HO字节中，结果为0082h。

表 2-6 符号扩展

表 2-7 零扩展

2.9 符号缩减和饱和法

符号缩减用于将具有一定二进制位数的值转换为具有较少位数的相同值，这个操作稍微有点麻烦。给定一个 n 位数，如果 m < n ，则不一定可以将其转换成 m 位数。例如，考虑值-448。作为一个16位的有符号数，其十六进制形式表示为0FE40h，这个数的大小超过了8位可表示值的范围，因此无法将其符号缩减为8位（否则会造成溢出）。

为了正确地对一个值进行符号缩减，需要丢弃的高阶字节必须是全部包含0或者0FFh的字节，并且结果值的高阶二进制位必须与从数值中删除的每个位相匹配。以下是将16位数符号缩减成8位数的一些示例：

●0FF80h可以符号缩减到80h

●0040h可以符号缩减到40h

●0FE40h不能符号缩减到8位

●0100h不能符号缩减到8位

如果必须要将较长的对象转换为较短的对象，并且愿意承受可能的精度损失，则可以使用饱和（saturation）操作。在使用饱和操作对数值进行转换时，如果较长对象的值在较短对象的取值范围之内，那么可以将较长对象的值复制到较短的对象中；如果不在，则可以将较长对象的值设置为较短对象取值范围内的最大（或最小）值来剪裁该值。

例如，将一个16位有符号整数转换为8位有符号整数时，如果16位数值在-128～+127范围内，则将16位对象的低阶字节复制到8位对象中即可。如果16位数值大于+127，则将该值剪裁为+127，并将+127存储到8位对象中。同样，如果该数值小于-128，则将最终的8位对象剪裁为-128。

尽管将值剪裁到较短对象的数值界限会导致精度损失，但有时这是可以接受的，因为其他替代方法会引发异常，或者导致无法完成计算。对于许多应用，例如音频或视频处理，剪裁后的结果仍然可以被识别，因此这是一种合理的转换。

2.10 简要回顾：控制转移指令概述

到目前为止，我们给出的所有汇编语言示例都在没有使用条件执行（conditional execution）语句（即在执行代码时做出决策）的情况下按顺序运行。事实上，除了call和ret指令外，我们还没有涉及任何影响汇编代码顺序执行方式的方法。

然而，这本书正在迅速接近一个转折点：真正有趣的示例需要具有按照不同条件执行不同代码段的能力。本节将围绕条件执行以及将控制转移到程序其他部分的主题简单展开。

2.10.1 jmp 指令

也许最好从讨论x86-64的无条件转移控制指令jmp开始。jmp指令有几种语法形式，一种最常见的形式如下：

jmp statement_label

其中，statement_label（语句标签）是一个标识符，该标识符被附加到“.code”段中的机器指令上。jmp指令立即将控制转移到标签后面的语句。这在语义上等同于高级计算机程序中的goto语句。

以下示例中，mov指令的前面，就有一个语句标签：

stmtLbl：mov eax，55

与所有的MASM符号一样，语句标签具有两个相关联的主要属性：地址（即标签后面的机器指令的内存地址）和类型。类型为label，与proc伪指令的标识符类型相同。

语句标签不必与机器指令位于源代码行的同一物理行上。考虑下面的例子：

anotherLabel：

mov eax，55

这个例子在语义上等同于上一个例子。绑定到anotherLabel的值（地址）是标签后面的机器指令的地址。在这种情况下，即使mov指令出现在下一行，anotherLabel标签后面的指令也仍然是mov指令（anotherLabel标签后紧跟着mov指令，二者之间没有任何由其他MASM语句生成的代码）。

从技术上讲，也可以跳转到proc标签而不是语句标签。但是，jmp指令没有设置返回地址，因此如果该过程执行ret指令，则返回位置可能未定义。第5章将更详细地探讨返回地址。

2.10.2 条件跳转指令

虽然jmp指令的通用形式在汇编语言程序中是不可或缺的，但该指令不提供按条件执行不同代码段的能力，因此被称为无条件跳转（unconditional jump）。幸运的是，x86-64 CPU提供了大量条件跳转指令（conditional jump instruction），顾名思义，这些指令允许有条件地执行代码。

这些指令对FLAGS寄存器中的条件码标志位（请参阅1.7节中的相关内容）进行测试，以确定是否存在需要执行的语句分支。这些条件跳转指令对FLAGS寄存器中如下4个条件码标志位进行测试：进位、符号、溢出和零标志位。

x86-64 CPU提供了8条指令，分别测试这4个标志位（参见表2-8）。条件跳转指令的基本操作是：测试一个标志位，以检查该标志位的状态是设置（1）还是清除（0），如果测试成功，则跳转到目标标签；如果测试失败，程序将继续执行条件跳转指令后的下一条指令。

表 2-8 测试条件码标志位的条件跳转指令

为了使用条件跳转指令，必须先执行一条会影响一个（或多个）条件码标志位的指令。例如，无符号算术溢出将设置进位标志位（同样，如果没有发生溢出，进位标志位将被清除）。因此，可以在add指令之后使用jc指令和jnc指令，以查看计算过程中是否发生（无符号）溢出。例如：

mov eax，int32Var

add eax，anotherVar

jc overflowOccurred

；如果加法运算没有产生溢出，则继续执行后面的代码。

overflowOccurred：

；如果int32Var和anotherVar之和超出了32位的范围，则执行此代码。

并非所有指令都会影响标志位。到目前为止，在我们已经涉及的指令（mov、add、sub、and、or、not、xor和lea）中，只有add、sub、and、or、xor指令会影响标志位。add指令和sub指令影响的标志位如表2-9所示。

表 2-9 执行 add 指令或 sub 指令后的标志位设置

逻辑指令（and、or、xor和not）总是清除进位标志位和溢出标志位。这些指令将结果的最高位复制到符号标志位中，如果产生零或者非零结果，则设置或者清除零标志位。

除了条件跳转指令外，x86-64 CPU系列还提供一组条件移动指令，7.5节将介绍这些指令。

2.10.3 cmp 指令和相应的条件跳转

cmp（比较）指令可能是在条件跳转之前执行的最有用的指令。cmp指令与sub指令具有相同的语法，事实上，它还会从第一个操作数中减去第二个操作数，并根据减法的结果，设置条件码标志位。但是，cmp指令不会将减法的结果存储回第一个（目标）操作数。cmp指令的作用是根据减法的结果设置条件码标志位。

虽然可以在cmp指令之后立即使用jc/jnc、jo/jno、js/jns和jz/jnz指令（用以测试cmp指令如何设置各个标志位），然而标志位的名称在cmp指令的上下文中意义不大。从逻辑上讲，当看到以下指令时（请注意，cmp指令的操作数语法与add、sub和mov指令相同）：

cmp left_operand ， right_operand

可以将此指令解读为“比较left_operand（左操作数）和right_operand（右操作数）”。在进行比较后，我们通常会提出以下问题：

●左操作数是否等于右操作数？

●左操作数是否不等于右操作数？

●左操作数是否小于右操作数？

●左操作数是否小于或等于右操作数？

●左操作数是否大于右操作数？

●左操作数是否大于或等于右操作数？

到目前为止，我们讨论的条件跳转指令（直觉上）并没有回答上述任何问题。

x86-64 CPU系列提供了一组附加的条件跳转指令，如表2-10所示，允许我们测试这些比较条件。

表 2-10 在 cmp 指令之后使用的条件跳转指令

表2-10中可能需要注意的最重要的一点是，分别使用单独的条件跳转指令来测试有符号比较和无符号比较。考虑两个字节值0FFh和01h。从无符号的角度来看，0FFh大于01h。然而，当我们将这些数值视为有符号数时（使用补码编码系统），0FFh实际上是-1，这显然小于1。当将这些值视为有符号或无符号数值时，它们具有相同的位表示形式，但比较结果完全不相同。

2.10.4 条件跳转的同义词

有些指令是其他指令的同义词。例如，jb和jc是同一条指令（即这两条指令具有相同的机器码编码）。设置同义词指令是为了方便和可读性。例如，在cmp指令之后，jb比jc指令更有意义。MASM为各种不同的条件分支指令定义了若干同义词，从而使得编码更加容易。表2-11列出了这些同义词指令的一部分。

表 2-11 条件跳转指令的同义词指令

关于cmp指令，需要注意的是：该指令仅为整数比较设置标志位（这也将包含可以用整数编码的字符和其他类型）。具体而言，cmp指令不会比较浮点数值，也不会根据浮点数比较情况设置标志位。为了了解浮点运算（和浮点数比较）的更多信息，请参见6.5节中的相关内容。

vip

2.11 移位和循环移位

应用于位串的另一组逻辑运算是移位（shift）和循环（rotate）移位操作。这两种运算可以进一步细分为左移位（left shift）、循环左（left rotate）移位、右移位（right shift）和循环右（right rotate）移位。

左移位运算将位串中的每个位都向左移动一个位置，如图2-8所示。

第0位移动到第1位所在的位置，第1位中以前的值移动到第2位所在的位置，依此类推。我们将一个0移到第0位，而最高位中以前的值将成为该操作的进位标志位的值。

x86-64提供了一条左移指令shl用于执行该运算。shl指令的语法形式如下所示：

shl dest ， count

操作数count（计数）可以是CL寄存器，也可以是0～ n 范围内的常数，其中 n 比目标操作数中的位数少一位（例如，对于8位操作数， n =7；对于16位操作数， n =15；对于32位操作数， n =31；对于64位操作数， n =63）。dest操作数是典型的目标操作数，可以是内存位置，也可以是寄存器。

当操作数count为常数1时，shl指令执行如图2-9所示的运算。

图2-8 左移位运算

图2-9 左移位一位

在图2-9中，C表示进位标志位，也就是说，从操作数中移除的最高位被移入进位标志位中。因此，可以在执行“shl dest，1”指令后，通过立即测试进位标志位（例如，使用jc和jnc指令）来判断“shl dest，1”指令是否会导致溢出。

shl指令会根据移位结果设置零标志位（如果结果为0，则z=1；否则z=0）。如果移位结果的最高位为1，那么shl指令将设置符号标志位为1。如果移位计数为1，则在最高位改变时设置溢出标志位（即当最高位以前为1时将0移入最高位，或者当最高位以前为0时将1移入最高位）；如果移位计数不为1，则溢出标志位未定义。

将一个值向左移动一位，与将这个值乘以该值的基数是一样的效果。例如，将十进制数值向左移动一位（在数值的右侧添加一个0）可以有效地将其乘以10（十进制数的基数）：

1234 shl 1=12340

“shl 1”指令表示向左移动1位。

因为二进制数的基数是2，所以将某个二进制数值向左移动一位，结果将使其乘以2。如果将一个二进制数值向左移动 n 次，则得到将该值乘以2 ⁿ 的结果。

右移位运算的工作方式相同，只是将数据向相反的方向移动。对于一个字节数值，第7位移到第6位，第6位移到第5位，第5位移到第4位，依此类推。在右移位过程中，我们将一个0移到第7位，第0位将作为进位位被移出（具体请参见图2-10）。

图2-10 右移位运算

相应地，x86-64提供了一条shr指令，该指令将目标操作数中的各个位向右移。shr指令的语法与shl指令的语法相类似：

shr dest ， count

这条指令将一个0移位到目标操作数的最高位；将其他各个二进制位均向右移动一位（从较高的位编号移动到较低的位编号）。最后，将第0位移入进位标志位。如果指定count为1，那么shr指令将执行如图2-11所示的运算。

图2-11 右移位一位

shr指令将根据移位结果设置零标志位（如果结果为0，则ZF=1；否则ZF=0）。shr指令将清除符号标志位（因为移位结果的最高位始终为0）。如果移位计数为1，那么shl指令将在最高位改变时设置溢出标志位（即当最高位以前为1时将0移入最高位，或当最高位以前为0时将1移入最高位）；如果移位计数不为1，则溢出标志位未定义。

因为左移位相当于乘以2，所以右移位大致相当于除以2（或者简而概之，右移位是除以数值的基数）。如果执行 n 次右移，则得到将该数值除以2 ⁿ 的结果。

但是，右移位只相当于无符号数除以2。例如，将254（0FEh）的无符号数表示形式向右移动一位，结果将得到127（7Fh），这正好符合预期。然而，如果将用补码表示的-2（0FEh）向右移动一位，结果将得到127（7Fh），这是一个错误的结果。之所以出现这个问题的原因在于，我们将一个0移入第7位。如果第7位之前包含一个1，则意味着将这个数从负数改变成了正数。对于除以2的操作而言，这是一个错误的结果。

为了将右移位用作除法运算，必须定义第三种移位运算，即算术右移位（arithmetic shift right）。算术右移位与正常的右移位（逻辑右移位）相类似，不同之处在于，算术右移位不是将一个0移入最高位，而是将最高位复制回其自身；也就是说，在移位过程中，不会修改最高位，如图2-12所示。

算术右移位通常会产生预期的结果。例如，在-2（0FEh）上执行算术右移位运算，结果会得到-1（0FFh）。但是，算术右移位会将数值舍入到小于或等于实际结果的最接近整数。例如，如果对-1（0FFh）进行算术右移位，则结果为-1，而不是0。因为-1小于0，所以算术右移位向-1舍入。这不是算术右移位中的错误，只是使用了一个不同（尽管有效）的整数除法定义。

x86-64提供算术右移位指令sar。sar指令的语法与shl和shr指令几乎相同：

sar dest ， count

对count操作数和dest操作数的通常限制在这里都适用指令sar。如果count为1，则此指令执行的运算如图2-13所示。

图2-12 算术右移位运算

图2-13“sar dest，1”运算

sar指令将根据移位结果设置零标志位（如果结果为0，则z=1；否则z=0）。sar指令将符号标志位设置为移位结果的最高位。sar指令执行后，溢出标志位始终为0，因为此运算不可能产生有符号溢出。

循环左移位和循环右移位运算的行为类似于左移位和右移位运算，只是从一端移出的位移回了另一端。图2-14演示了这两种运算。

图2-14 循环左移位和循环右移位

x86-64提供rol和ror指令，用于对操作数执行这两种基本运算。这两条指令的语法与移位指令相类似：

rol dest ， count

ror dest ， count

如果count为1，则这两条指令会将移出目标操作数的位复制到进位标志位中，如图2-15和图2-16所示。

图2-15“rol dest，1”运算

图2-16“ror dest，1”运算

与移位指令不同，循环移位指令不影响符号标志位或者零标志位的设置。仅当进行1位循环移位时，才定义溢出标志位，该标志位在所有其他情况下都是未定义的（仅RCL和RCR指令除外：0位循环移位不起任何作用，也就是说，不影响溢出标志位）。对于循环左移位，溢出标志位被设置为原始高阶两位的异或结果。对于循环右移位，溢出标志位被设置为循环移位后高阶两位的异或结果。

对于循环移位操作来说，可以将输出位移位到进位标志位，并将以前进位标志位的值移回移位操作的输入位，这种做法会更方便一些。x86-64的rcl（rotate through carry left，通过进位标志位循环左移位）和rcr（rotate through carry right，通过进位标志位循环右移位）指令具有这一作用。这两种指令的语法形式如下所示：

rcl dest ， count

rcr dest ， count

count操作数是常量或者CL寄存器，dest操作数是内存位置或寄存器。count操作数必须小于dest操作数中的位数。如果count为1，则这两条指令实现如图2-17所示的循环移位。

图2-17“rcl dest，1”和“rcr dest，1”运算

与移位指令不同，通过进位标志位进行循环移位的指令不会影响符号标志位或零标志位的设置。仅当进行1位循环移位时，才定义溢出标志位。对于循环左移位，如果原始高阶两位改变，则设置溢出标志位。对于循环右移位，溢出标志位被设置为循环移位后结果的高阶两位的异或结果。

2.12 位字段和打包数据

虽然x86-64对于字节、字、双字和四字数据类型运行效率最高，但有时还需要处理不为8位、16位、32位或64位的数据类型。我们也可以对非标准数据进行零扩展，使其大小成为比自己大的第一个2的幂（例如将22位值扩展成32位值）。事实证明，这样的扩展操作可以提高运行速度，但是如果有一个由此类值构成的大数组，则将浪费略多于31%的内存空间（因为每一个32位值中，都有10位被浪费）。假设将这被浪费的10位重新用于其他用途，那么该如何处理呢？答案是将单独的22位值和10位值打包为单个32位值，就可以不浪费任何空间了。

例如，考虑格式为“04/02/01”的日期。表示这种格式的日期需要三个数值，即月、日以及年。当然，月的取值范围为1～12，因此至少需要4位（4位可以表示最多16个不同的值）来表示。日的取值范围为1～31，因此需要5位（5位可以表示最多32个不同的值）来表示。对于年，假设我们使用0～99范围内的值，那么年需要7位（7位可以表示多达128个不同的值）来表示。因此，表示这种格式的日期所需要的位数为4+5+7=16，也就是两个字节。

换句话说，我们可以将日期数据打包成两个字节，而如果我们使用单独的字节来表示每个月、日和年，那么需要三个字节。这样存储每个日期都会节省一个字节的内存空间，在存储大量日期的情况下，可以节省大量的内存空间。使用打包数据表示日期，则各个位的排列如图2-18所示。

图2-18 短日期打包格式（两个字节）

MMMM表示由4位组成的月，DDDDD表示由5位组成的日，YYYYYYY表示由7位组成的年。每个位集都称为一个位字段（bit field）。例如，2001年4月2日将表示为4101h：

0100 00010 0000001=0100_0001_0000_0001b或4101h

4 2 01

尽管打包值提高了空间利用率（也就是说，打包的方式有效地利用了内存），但打包值的计算效率却非常低（比较慢！）。那么是什么原因导致的呢？其实是将数据解包到不同的位字段中需要额外的指令，这些额外的指令需要额外的执行时间（还需要额外的字节来存储指令），因此必须仔细考虑打包数据字段是否可以节省整体的开销。程序清单2-4中的示例代码演示了打包和解包这种16位的日期格式所需执行的操作。

程序清单 2-4 打包和解包日期数据

构建和运行该程序的结果如下所示：

C：\> build listing2-4

C：\> echo off

Assembling：listing2-4.asm

c.cpp

C：\> listing2-4

Calling Listing 2-4：

Enter current month：2

Enter current day：4

Enter current year（last 2 digits only）：68

Packed date is 2244

The date is 02/04/68

Listing 2-4 terminated

当然，经历过“千年虫”（2000年）的问题之后，我们知道将日期格式限制在100年（或者甚至127年）是一种非常愚蠢的处理方式。为了进一步验证打包日期格式，我们可以将其扩展为四个字节，即打包成一个双字变量，如图2-19所示。（所创建的数据对象的长度应该为2的偶数次幂，即一个字节、两个字节、四个字节、八个字节等，否则程序性能将受到影响。）

图2-19 长日期打包格式（四个字节）

在这种打包数据格式中，月字段和日字段分别由8位组成，因此可以从双字中提取它们作为字节对象。剩下的16位用于表示年，可以表示65536个年。通过重新排列这些位，使得年字段位于高阶位中，月字段位于中间位中，而日字段位于低阶位中。这种长日期格式允许我们轻松地比较两个日期，以查看一个日期是小于、等于还是大于另一个日期。请考虑以下的代码：

mov eax，Date1；假设Date1和Date2是双字变量

cmp eax，Date2；使用长日期打包格式

jna d1LEd2

当Date1>Date2时执行此处的代码

d1LEd2：

如果将不同的日期字段保存在不同的变量中，或者以不同的方式组织字段，那么我们将无法像比较短日期打包数据格式那样轻松地比较Date1和Date2。因此，此示例演示了打包数据的另一个优点，就是即使没有节约任何空间，也可以使某些计算更方便甚至更高效（这正好与使用打包数据时相反）。

在实际应用中，打包数据类型的例子比比皆是。可以将八个布尔值打包成一个字节，也可以将两个BCD数字打包成一个字节，等等。

打包数据的一个典型示例是RFLAGS寄存器，该寄存器将9个重要的布尔对象（以及7个重要的系统标志）打包到一个16位寄存器中。我们经常需要访问其中的某些标志位。可以使用条件跳转指令测试许多条件码标志位，还可以使用表2-12中直接影响某些标志位的指令，来操作标志寄存器中的单个位。

表 2-12 影响某些标志位的指令

lahf和sahf指令提供了一种便捷的方式，可以将标志寄存器的低阶8位作为一个由8位组成的字节（而不是8个单独的1位值）来访问。有关标志寄存器的布局，请参见图2-20。

图2-20 作为打包布尔数据的FLAGS寄存器

lahf指令和sahf指令的语法形式如下所示：

lahf

sahf

2.13 IEEE 浮点数格式

当英特尔计划为其新推出的8086微处理器引入浮点单元（8087 FPU）时，尽全力聘请了最好的数值分析师来设计浮点格式，该专家随后聘请了该领域的另外两名专家。这三位专家（William Kahan、Jerome Coonen和Harold Stone）设计了英特尔芯片的浮点数格式。他们在设计KCS浮点标准方面做得非常出色，以至于IEEE采用了这种格式作为其浮点数格式。

为了满足广泛的性能和精度要求，英特尔实际上引入了三种浮点数格式，即单精度、双精度和扩展精度。单精度格式和双精度格式对应于C语言的浮点数和双精度类型，或者FORTRAN语言的实数和双精度类型。扩展精度格式包含16个额外的位，在存储结果的过程中，向下舍入到双精度值之前，长链计算会将这些额外的位用作警戒位。

2.13.1 单精度格式

单精度浮点数格式由三部分组成，分别是由反码表示的24位尾数8位的excess-127格式的指数以及一个符号位。尾数通常表示1.0（包括）～2.0（不包括）之间的值。尾数的高阶位始终假定为1，用于表示二进制小数点左侧的数值。余下的23个尾数位用于表示二进制小数点右侧的值。因此，尾数表示以下的数值：

1.mmmmmmm mmmmmmmm

mmmm字符表示尾数的23位。请注意，由于尾数的高阶位始终为1，因此单精度格式实际上不会将该位存储在浮点数的32位内。尾数的高阶位被称为隐含位（implied bit）。

因为我们研究的是二进制数，所以二进制小数点右侧的每个位置都表示一个值（0或1）乘以2的一个负数（各位置对应的负数是连续的）次幂。隐含的那1位总是1乘以2 ⁰ ，即1。这就是尾数总是大于或等于1的原因。即使其他的尾数位都是0，隐含的1位也会使结果总是数值1 。当然，即使二进制小数点的后面存在几乎无限个1，它们的总和也仍然不会达到2。这就是尾数可以表示介于1（包含）和2（不包含）之间的数值的原因。

虽然在1和2之间存在无限多个数值，但我们只能表示其中的800万个，因为我们使用的是23位的尾数（隐含的第24位始终为1）。这就是浮点算术运算结果不精确的原因所在——在涉及单精度浮点值的计算中，存在固定位数的限制。

尾数使用反码格式而不是补码来表示有符号值。尾数的24位值只是一个无符号二进制数，符号位决定该值是正数还是负数。反码具有一个不寻常的特性，即0有两种表示（符号位分别为1或0）。一般情况下，这种特性仅对设计浮点数软件系统或硬件系统的人员来说很重要。我们将假定0的符号位为0。

为了表示1.0（包含）～2.0（不包含）范围之外的数值，可以利用浮点数格式的指数部分。浮点数格式计算2的指定指数次幂，然后将尾数乘以该数值。指数为8位，以excess-127的格式存储。在excess-127格式中，指数0表示为127（7Fh），负指数是0～126范围内的数值，正指数是128～255范围内的数值。为了将指数转换为excess-127格式，需要将指数值加上127。使用excess-127格式可以更容易地比较浮点数。单精度浮点数格式如图2-21所示。

图2-21 单精度（32位）浮点数格式

使用24位尾数，我们将获得大约六位半（十进制）精度（半位精度意味着前六位数字可以全部在0～9范围内，但第七位数字只能在0～ x 范围内，其中 x <9且通常接近5）的数据。采用8位excess-127格式的指数，单精度浮点数的动态范围（dynamic range）大约为2 ^±127 或10 ^±38 。

虽然单精度浮点数完全适用于许多实际应用，但其精度和动态范围有限，不适用于金融、科学和其他应用领域。此外，在进行长链计算期间，单精度格式的精度限制可能会引入严重误差。

2.13.2 双精度格式

双精度格式有助于解决单精度浮点数的问题。与单精度格式相比，双精度格式占用了两倍的空间。双精度格式由三部分组成，分别是11位的excess-1023格式的指数、53位的尾数（隐含的高阶位为1）以及一个符号位。这种格式提供了大约10 ^±308 的动态范围和14.5位的数据精度，足以满足大多数应用。双精度浮点数的格式如图2-22所示。

图2-22 64位双精度浮点数格式

2.13.3 扩展精度格式

在涉及双精度浮点数的长链计算过程中，为了确保精度，英特尔设计了扩展精度格式。扩展精度格式占用80位。在额外的16位中，12位附加到尾数末尾，4位附加到指数末尾。与单精度值和双精度值不同的是，扩展精度格式的尾数没有隐含的高阶位。因此，扩展精度格式提供了64位尾数、15位的excess-16383格式的指数和1个符号位。图2-23显示了扩展精度浮点数的格式。

图2-23 80位扩展精度浮点数格式

在x86-64 FPU上，所有计算都使用扩展精度格式完成。无论何时，当加载一个单精度值或双精度值时，FPU都会自动将其转换为扩展精度的数值。同样，在将一个单精度值或双精度值存储到内存中时，在存储之前，FPU会自动将该数值向下舍入到适当的大小。通过使用扩展精度格式，英特尔保证提供大量的警戒位，以确保计算的准确性。

2.13.4 规范化浮点值

为了在计算过程中维持最大的精度，大多数计算都使用规范化值。规范化浮点值是尾数的高阶位为1的值。几乎任何非规范化的值都可以被规范化：将尾数的各个位向左移位，并减小指数，直到尾数的高阶位为1。

请记住，指数是一个二进制数。每次增加指数时，浮点数都会乘以2。同样，每当减小指数时，浮点值都会除以2。因此，将尾数向左移位一位意味着将浮点值乘以2；同样，将尾数向右移位一位意味着将浮点值除以2。所以，将尾数向左移位一个位置同时将指数减1并不会改变浮点数的值。

使用规范化浮点数具有优势的原因是这种方式可以保证计算的最大精度位数。如果尾数的高阶 n 位都是0，则尾数的计算精度位要少很多。因此，如果仅涉及规范化值，则浮点数的计算将更加准确。

在两种重要情况下，浮点数将无法规范化。第一种特殊情况是数值0。显然，0无法被规范化，因为在0的浮点数表示中，尾数的每一位值都不可能为1。但是，这并不是问题，因为我们可以使用一个位精确地表示数值0。

第二种情况是尾数中有一些高阶位为0，但偏移指数（biased exponent）也为0（我们不能通过减小指数来对尾数进行规范化）。对于尾数的高阶位以及偏移指数都为0（所允许的最大负指数）的那些很小的数，IEEE标准并没有排除它们，而是允许使用特殊的规范化值来表示这些较小的值。尽管使用非规范化值可以使IEEE浮点数计算产生比向下溢出时更好的结果，但需要注意的是，非规范化值提供的精度位较少。

2.13.5 非数值数据

IEEE浮点标准可以识别三个特殊的非数值数据，即-infinity（负无穷大）、+infinity（正无穷大）和一个特殊的NaN（not-a-number，非数值）。对于这些特殊的数值，其指数字段为全1。

对于某个数值，如果其指数为全1，尾数为全0，则该值为infinity。符号位为0时表示+infinity，符号位为1时表示-infinity。

对于某个数值，如果其指数为全1，尾数不为全0，则该值为无效数值。在IEEE 754术语中，称其为NaN。NaN表示非法操作，例如试图计算负数的平方根。

当任一操作数（或者两个操作数）为NaN时，会发生无序比较。由于NaN的值不确定，因此无法对其进行比较（即它们是不可比较的）。对执行无序比较的任何尝试通常会导致异常或某种错误。另外，有序比较所涉及的两个操作数都不可以是NaN。

2.13.6 MASM 对浮点值的支持

MASM提供了几种数据类型，以支持在汇编语言程序中使用浮点数据。MASM的浮点值常量允许以下的语法形式。

●一个可选的“+”或“-”符号，表示尾数的符号（如果没有指定，则MASM假设尾数为正）。

●后面跟一个或多个十进制数字。

●后面跟一个十进制小数点以及零个或多个十进制数字。

●（可选）后面跟e或E，（可选）后面跟符号（“+”或“-”）以及一个或多个十进制数字。

浮点值必须包含小数点或者e/E，以便将该数值与整数或无符号字面常量区分开来。以下是一些合法的字面浮点值常量的示例：

1.234 3.75e2-1.0 1.1e-11.e+4 0.1 -123.456e+789 +25.0e01.e3

浮点值的字面常量必须以十进制数字开头，如在程序中必须使用0.1来表示.1。

为了声明浮点值变量，可以使用数据类型real4、real8或real10。位于这些数据类型声明末尾的数字指定用于每个类型二进制表示的字节数。因此，我们可以使用real4来声明单精度实数值，使用real8来声明双精度浮点值，使用real10来声明扩展精度浮点值。除了使用这些数据类型来声明浮点值而不是整数这一点，这些数据类型的使用方法与byte、word、dword等的几乎相同。以下示例演示了这些声明及语法：

.data

fltVar1 real4？

fltVar1a real42.7

pi real43.14159

DblVar real8？

DblVar2 real81.23456789e+10

XPVar real10？

XPVar2 real10-1.0e-104

和往常一样，本书使用C/C++的printf函数将浮点值打印到控制台。当然，也可以编写汇编语言例程来完成同样的任务，但是C标准库提供了一种便捷的方法，可以避免编写（复杂的）代码，至少目前是这样。

注意： 浮点算术运算不同于整数算术运算，不能使用x86-64的add和sub指令对浮点数进行操作，可参阅第6章。

2.14 BCD 表示法

尽管整数和浮点数格式能够满足一般程序对数值的大多数需求，但在某些特殊情况下，使用其他数值表示形式会更加方便。在本节中，我们将讨论BCD格式，因为x86-64 CPU为这种数据表示提供了少量的硬件支持。

图2-24 内存中的BCD数据表示

BCD值是一个由半字节形成的序列，每个半字节表示0～9范围内的数值。一个字节可以表示包含两个十进制数字的数值，或者0～99之间的数值（具体请参见图2-24）。

可以看出，BCD表示对内存的利用并不是特别高效。例如，一个8位BCD变量可以表示0～99范围内的数值，而在保存二进制数值时，相同的8位可以表示0～255范围内的数值。同样，16位二进制数值可以表示0～65535范围内的数值，而16位BCD数值只能表示0～9999，大约为0～65535的六分之一。

不过，BCD数值可以很容易地在内部数字表示和字符串表示之间转换，而且可以在使用BCD的硬件（例如，旋转控制器或刻度盘）中对多位的十进制数值进行编码。基于上述两个原因，我们发现人们经常在嵌入式系统（例如烤箱、闹钟和核反应堆）中使用BCD，但在通用计算机软件中很少使用。

英特尔x86-64浮点单元支持一对用于加载和存储BCD值的指令。但在内部，FPU将这些BCD数值转换为二进制表示，并采用二进制形式执行所有的计算。英特尔x86-64浮点单元仅将BCD码用作外部数据格式（位于FPU外部）。这种方式通常会产生更加准确的结果，与专门设计一个能够支持十进制算术运算的单独协处理器相比，这种方式节省了所需的硅。

2.15 字符

也许个人计算机上最重要的数据类型是字符。术语“字符”是指人或者机器可读的符号，一般是非数字实体。具体而言，字符通常是指可以通过键盘键入的任何符号（包括可能需要多个按键才能生成的某些符号），或者在视频显示器上能够显示的符号。字母、标点符号、数字、空格、制表符、回车符（ENTER）、其他控制字符以及其他的特殊符号都是字符。

注意： 数字字符与数值不同：字符“1”与数值1不同。在计算机中，通常对数字字符（“0”、“1”、…、“9”）与数值（0～9）采用两种不同的内部表示形式。

大多数计算机系统使用一个字节或两个字节的序列将各种字符编码为二进制形式。Windows、MacOS、FreeBSD和Linux使用ASCII或者Unicode编码表示字符。本节将讨论ASCII字符集和Unicode字符集，以及MASM提供的字符声明工具。

2.15.1 ASCII 字符编码

ASCII字符集将128个文本字符映射为0～127（0～7Fh）之间的无符号整数值。虽然字符到数值的精确映射可以是任意的并且不重要，但是使用标准化的编码进行映射非常重要，因为当需要与其他程序和外围设备通信时，通信双方需要使用相同的“语言”。ASCII是一种几乎所有人都达成一致的标准化编码：如果使用ASCII编码65表示字符“A”，那么，无论何时向一个外部设备（例如，打印机）传输数据，外部设备都会正确地将该值解释为字符“A”。

尽管存在一些严重不足，但是ASCII数据已经成为跨计算机系统和程序的数据交换标准。大多数程序可以接受ASCII数据，同样，大多数程序可以生成ASCII数据。因为我们将在汇编语言中处理ASCII字符，所以研究ASCII字符集的布局并记住一些关键的ASCII编码（例如，0、A、a等）是非常必要的。

ASCII字符集可以分为4组，每组32个字符。第一组32个字符[ASCII编码0～1Fh（31）]构成一个特殊的非打印字符集，即控制字符。我们之所以把这些字符称为控制字符，是因为它们执行各种打印/显示的控制操作，而不是显示符号。示例包括回车符，用于将光标定位到当前字符行的左侧；换行符，将光标在输出设备中向下移动一行；退格符，将光标向左移回一个位置。

遗憾的是，不同的控制字符在不同的输出设备上执行不同的操作，输出设备之间几乎没有统一的标准。为了准确了解控制字符如何影响特定设备，用户需要查阅设备相关的使用手册。

第二组32个ASCII字符编码包含各种标点符号、特殊字符和数字字符。这一组中最著名的字符包括空格字符（ASCII码值为20h）和数字字符（ASCII码值为30h～39h）。

第三组32个ASCII字符包含大写字母字符。大写字母A到Z的ASCII码值为41h～5Ah（65到90）。因为只有26个字母字符，所以剩下的6个编码代表各种特殊符号。

第四组也是最后一组32个ASCII字符编码表示小写字母、5个附加特殊符号和1个控制字符（具于删除功能）。小写字母使用ASCII码值61h～7Ah。将大写字母和小写字母的ASCII编码转换为二进制，就会发现同一字母的大写字符与小写字符仅在一个位上有区别。例如，考虑图2-25中的大写字母E和小写字母e的字符编码。

图2-25 大写字母E和小写字母e的ASCII码值

这两个ASCII码值唯一不同的是第5位。所有大写字母第5位的值始终为0，所有小写字母第5位的值始终为1。我们可以使用这个事实实现大写字母和小写字母的快速转换。如果有一个大写字母，则可以将其第5位的值设置为1，从而强制把它转换为小写字母。如果有一个小写字母，则可以将其第5位的值设置为0，从而强制把它转换为大写字母。只需反转第5位，就可以实现字母字符在大写和小写之间的转换。

实际上，如表2-13所示，第5位和第6位决定了字符处于ASCII字符集中的哪一组。

例如，我们可以将第5位和第6位的值设置为0，从而将任何大写、小写（或对应的特殊）字符转换为控制字符。

接下来请考虑表2-14中给出的数字字符的ASCII编码。

对于任意一个数字字符，其ASCII码的低阶半字节恰恰等于该字符等价的二进制值。通过去掉数字字符编码的高阶半字节（即将高阶半字节设置为0），可以将该编码转换为相应的二进制表示形式。相反，只需将高阶半字节设置为3，就可以将0～9范围内的二进制数值转换为相应的ASCII字符。可以使用逻辑与操作将高阶位强制设置为0，也可以使用逻辑或操作将高阶位强制设置为0011b（3）。

表 2-13 ASCII 编码的分组情况

表 2-14 数字字符的 ASCII 编码

遗憾的是，对于包含数字字符的字符串，我们无法通过简单地从该字符串的每个数字中去掉高阶半字节，来将其转换为等效的二进制值。以这种方式转换123（31h 32h 33h）将产生3个字节——010203h，但123的正确值为7Bh。上一段中描述的转换仅适用于单个数字字符。

2.15.2 MASM 对 ASCII 字符的支持

MASM为汇编语言程序中的字符变量和字面量提供了支持。MASM中的字符字面常量有以下两种形式：一种是包含在单引号内的单个字符，另一种是包含在双引号内的单个字符，如下所示：

'A'"A"

两种形式代表相同的字符“A”。

如果希望在字符串中包含单引号或双引号，则需要使用另一个字符作为字符串分隔符。例如：

'A"quotation"appears within this string'

"Can't have quotes in this string"

与C/C++语言不同，MASM对单字符对象和字符串对象使用相同的分隔符，并且不使用分单个字符区分字符常量和字符串常量。一个字符字面常量在两个双引号（或单引号）之间只有一个字符，而字符串字面常量在两个双引号（或单引号）之间有多个字符。

在MASM程序中，为了声明字符变量，需要使用byte数据类型。例如，以下示例演示了如何声明一个名为UserInput的变量：

.data

UserInput byte？

上述声明保留一个字节的存储空间，可用于存储任何字符值（包括8位扩展ASCII/ANSI字符）。还可以按如下方式初始化字符变量：

.data

TheCharA byte 'A'

ExtendedChar byte 128；大于7Fh的字符码

因为字符变量是8位对象，所以可以使用8位寄存器对其进行操作。可以将字符变量移动到8位寄存器中，也可以将8位寄存器的值存储到字符变量中。

2.16 Unicode 字符集

ASCII码存在的问题是它只支持128个字符的编码。即使将定义扩展到8位（就像IBM在原始PC上所做的那样），我们也只能使用最多256个字符。这对于现代的多国/多语言应用程序而言实在是太少了。早在20世纪90年代，就有几家公司开发了一种ASCII扩展，称为Unicode，它使用两个字节的字符大小进行编码。因此，（原始）Unicode最多支持65536个不同字符的编码。

遗憾的是，尽管最初的Unicode标准是经过深思熟虑的，但系统工程师发现，即使65536个符号也不够用。如今，Unicode定义了1112064个可能的字符，使用可变长度字符格式进行编码。

2.16.1 Unicode 码位

Unicode码位（code point，又被称为码点）是一个整数值，Unicode将其与特定字符符号相关联。Unicode码位的约定是指定十六进制形式的值，值前面有一个“U+”前缀。例如，U+0041是字符A的Unicode码位（41h是字符A的ASCII码值。U+0000～U+007F范围内的Unicode码位对应于ASCII字符集）。

2.16.2 Unicode 码平面

Unicode标准所定义的码位范围为U+000000到U+10FFFF。10FFFFh为1114111，这是Unicode字符集中1112064个字符的大部分来源，其余2047个码位被保留，用作代理项（surrogate），代理项是Unicode的扩展。 Unicode标准将此范围划分为17个多语言平面（multilingual plane），每个语言平面最多支持65536个码位。6位十六进制码位中的高阶2位用于指定多语言平面，其余4位用于指定平面内的字符。

平面0（U+000000到U+00FFFF）大致对应于原始的16位Unicode定义，Unicode标准将其称为基本多语言平面（Basic Multilingual Plane，BMP）。平面1（U+010000至U+01FFFF）、平面2（U+020000至U+02FFFF）和平面14（U+0E0000至U+0EFFF）为补充（扩展）平面。Unicode为将来的扩展保留了平面3～平面13，将平面15和平面16用于用户自定义的字符集。

很显然，在BMP之外表示Unicode码位需要额外的2个字节。为了减少内存的使用，Unicode在BMP中（特别是UTF-16编码）使用2个字节表示Unicode码位，在BMP外使用4个字节表示码位。在BMP中，Unicode保留代理项码位（U+D800-U+DFFF）以指定BMP后面的16个平面，图2-26显示了其编码。

图2-26 Unicode平面1到16的代理项码位编码

请注意，这两个字（单元1和单元2）总是同时出现。单元1的值（高阶位为110110b）指定Unicode标量的高阶10位（b ₁₀ 至b ₁₉ ），单元2的值（高阶位为110111b）指定Unicode标量的低阶10位（b ₀ 至b ₉ ）。因此，位b ₁₆ 到b ₁₉ （加1）指定Unicode平面1到16，位b ₀ 到b ₁₅ 指定平面内的Unicode标量值。

2.16.3 Unicode 编码

Unicode标准从v2.0版本开始，支持21位字符空间，能够处理超过一百万个字符（尽管大多数码点仍保留供将来使用）。Unicode公司没有采用3字节（或者更糟糕的4字节）编码方式来允许更大的字符集，而是采用不同的编码方案，每种编码都有自己的优点和缺点。

UTF-32使用32位整数来保存Unicode标量。UTF-32编码方案的优点是32位整数可以表示每个Unicode标量值（只需要21位）。使用UTF-32时，程序可以随机访问字符串中的每个字符（无须搜索代理项对），并且能够以常数时间（大部分情况下）完成操作。UTF ~-~ 32明显的缺点是每个Unicode标量值需要4字节的存储空间（这是原始Unicode定义的2倍，也是ASCII字符的4倍）。

Unicode支持的第二种编码格式是UTF-16。顾名思义，UTF-16使用16位（无符号）整数来表示Unicode值。为了处理大于0FFFFh的标量值，UTF-16使用代理项对的编码方案来表示010000h～10FFFFh范围内的值。因为绝大多数有用的字符可以使用16位，所以大多数UTF-16字符只需要2个字节。对于需要代理项的罕见情况，UTF-16需要两个字（32位）来表示字符。

最后一种编码是UTF-8，毫无疑问，这是最流行的编码方案。UTF-8编码与ASCII字符集向上兼容。特别是，所有ASCII字符都有单字节表示（字符原始的ASCII编码，其中包含字符的字节高阶位为0）。如果UTF-8的高阶位为1，则UTF-8需要额外的字节（1～3个额外的字节）来表示Unicode码位。表2-15给出了UTF-8的编码模式。

表 2-15 UTF-8 编码

表中出现的 xxx …位是Unicode码位所占用的位。对于多字节序列，第一个字节包含高阶位，第2个字节包含下一个高阶位，依此类推。例如，一个由2个字节组成的序列“11011111b，10000001b”对应于Unicode标量0000_0111_1100_0001b（U+07C1）。

2.17 MASM 对 Unicode 的支持

遗憾的是，MASM几乎不支持汇编语言源文件采用Unicode文本。幸运的是，MASM的宏工具提供了一种方法，允许我们在MASM中自己创建处理Unicode字符串的方法。有关MASM宏的更多详细信息，请参见第13章。在 The Art of 64-Bit Assembly 的Volume 2中还会重新讨论这个主题，该书花费了大量的篇幅描述如何强制MASM接受和处理源文件与资源文件中的Unicode字符串。

2.18 拓展阅读资料

有关数据表示和布尔函数的一般信息，请考虑阅读作者编写的另一本书 Write Great Code 的Volume 1，或者任何一本数据结构和算法方面的教科书（所有的书店都有售）。

ASCII、EBCDIC和Unicode都是国际标准。有关扩展EBCDIC字符集系列的更多信息，请参考IBM的网站（http://www.ibm.com/）。ASCII和Unicode都是国际标准化组织（International Organization for Standardization，ISO）的标准，ISO为这两种字符集提供了相应的报告。通常情况下，获取这些报告需要付费，但读者也可以通过在互联网上按名称搜索ASCII和Unicode字符集，来查找有关这些字符集的大量信息。读者还可以通过Unicode官网（http://www.unicode.org/），阅读有关Unicode的信息。 Write Great Code 还包含有关Unicode字符集的历史、使用和编码这些额外信息。

vip

第3章内存的访问和组织

在第1章和第2章中，我们讨论了如何在汇编语言程序中声明和访问简单变量。本章将全面讨论x86-64内存访问过程。在本章中，我们将学习如何有效地组织对变量的声明，以加速对其数据的访问。我们还将讨论x86-64栈，以及如何处理栈中的数据。

本章将讨论几个重要概念，具体包括以下内容：

●内存组织

●程序的内存分配

●x86-64内存寻址模式

●间接索引寻址模式和缩放索引寻址模式

●数据类型的强制转换

●x86-64栈

本章将指导读者如何有效地利用计算机的内存资源。

3.1 运行时的内存组织

一个正在运行的程序会以多种方式使用内存，具体取决于数据的类型。以下是汇编语言程序中常见的一些数据分类。

● 代码： 对机器指令进行编码的内存值。

● 未初始化的静态数据： 计算机为整个程序运行期间存在的未初始化变量在内存中预留的一个区域。当Windows将程序加载到内存中时，会将该存储区域的值全部初始化为0。

● 初始化的静态数据： 在程序运行的整个过程中一直存在的一段内存。Windows会从程序的可执行文件中，加载该段中出现的所有变量的值，以便在程序首次开始执行时变量都具有初始值。

● 只读数据： 与初始化的静态数据类似，Windows从可执行文件中，加载此内存段的初始数据。但是，该内存段被标记为只读（read-only），以防止无意中修改数据。程序通常在该内存段中存储常量和其他不变的数据（请注意，代码段也被操作系统标记为只读）。

● 堆：内存中的特殊段，用来保存动态分配的存储空间。C语言的malloc和free等函数负责在堆区域中分配和释放存储空间。4.6.4节将更详细地阐述动态内存分配。

● 栈：内存中的特殊段，程序在其中维护过程和函数的局部变量、程序状态信息以及其他瞬态数据（瞬态数据）。有关栈段的更多信息，请参阅3.9节中的相关内容。

以上所述都是常见程序（汇编语言程序或其他语言程序）中的典型内存段。较小的程序不会用到以上所有内存段（程序一般至少包含代码段、栈段和数据段）。复杂的程序可能会为自己要实现的目标在内存中创建额外的内存段。有些程序可能会将若干内存段组合在一起。例如，许多程序将代码段和只读数据段合并到内存的同一个段中（因为两个段中的数据都标记为只读）。有些程序会将未初始化的数据段和初始化的数据段合并在一起（将未初始化的所有变量都初始化为0）。通常由链接器程序完成合并段的操作。有关合并段的详细信息，请参阅Microsoft链接器的相关文档。

Windows倾向于将不同类型的数据放入内存的不同段中。尽管在运行链接器时，可以通过指定各种参数，以根据选择重新配置内存，但在默认情况下，Windows使用类似于图3-1的组织架构将MASM程序加载到内存中。

图3-1 MASM典型的运行时内存组织架构

Windows本身将保留最低位的内存地址。通常情况下，应用程序无法访问这些低位地址的数据（或者执行这些低位地址的指令）。操作系统保留此内存空间的一个原因是它可以帮助捕获空指针引用，也就是说，如果程序尝试访问内存位置0（NULL），那么操作系统将生成一般保护故障（general protection fault），也称为段故障（segmentation fault），这意味着程序访问了不包含有效数据的内存位置。

内存映射中的其余6个段包含与程序相关的不同类型的数据。内存的这些段包括栈段、堆段、“.code”（代码）段、“.data”（静态数据）段、“.const”（常量）段、“.data？”（存储）段。每个段都对应一种可以在MASM程序中创建的数据类型。接下来将展开阐述“.code”段、“.data”段、“.const”段和“.data？”段。

3.1.1“.code ”段

“.code”段中包含MASM程序中的机器指令。MASM将用户编写的每条机器指令转换为一个或多个字节值组成的序列。在程序执行期间，CPU将这些字节值解释为机器指令。

在默认情况下，当MASM链接用户的程序时，会告诉系统用户的程序可以执行指令并从代码段读取数据，但不能将数据写入代码段。如果用户试图将任何数据存储到代码段中，那么操作系统将生成一般保护错误。

3.1.2“.data ”段

“.data”段通常是程序放置变量的地方。除了声明静态变量外，还可以将数据列表嵌入“.data”段。一些伪指令既可以将数据嵌入“.code”段，也可以将数据嵌入“.data”段，如byte、word、dword、qword等伪指令。请考虑下面的例子：

.data

b byte 0

byte 1，2，3

u dword 1

dword 5，2，10；

c byte？

byte 'a'，'b'，'c'，'d'，'e'，'f'；

bn byte？

byte true；假定true被定义为1

MASM使用这些伪指令将值放置到“.data”内存段时，会将这些值写入伪指令前的变量所在段的后面。例如，字节值1、2和3被写入“.data”内存段中b变量的第0个字节之后。由于没有与这些值相关联的标签，因此用户无法在程序中直接访问这些值，但可以使用索引寻址模式访问这些额外的值。

在前面的示例中，请注意变量c和bn没有（显式）初始值。如果没有提供初始值，那么MASM会将“.data”段中的变量初始化为0，因此MASM将NULL字符（ASCII代码0）指定给c，作为其初始值；将false指定为bn的初始值（假设false定义为0）。“.data”段中的变量声明总是会占用内存，即使用户没有为这些变量分配初始值。

3.1.3“.const ”段

“.const”数据段用于保存常量、表和程序在执行期间无法更改的其他数据。可以在“.const”段中声明并创建只读对象。“.const”段类似于“.data”段，但存在以下3个区别。

●常量段以保留关键字“.const”开始，而数据段以保留关键字“.data”开始。

●“.const”段中声明的所有变量都必须有一个初始值。

●在程序运行过程中，系统不允许用户将数据写入“.const”段中的变量中。

下面是一个例子：

.const

pi real43.14159

e real42.71

MaxU16 word 65535

MaxI16 sword 32767

所有的常量对象声明必须具有初始值，因为无法在程序控制下初始化对象的值。出于许多目的，可以将常量对象视为字面常量。由于它们实际上是内存对象，所以它们的行为类似于（只读）数据对象。并不是在所有允许字面常量的地方都可以使用常量对象；例如，不能在寻址模式中将常量对象用作位移（具体请参阅3.7节中的相关内容），并且不能在常量表达式中使用常量对象。在实践中，可以在任何能合法读取数据变量的地方，使用常量对象。

与“.data”段一样，使用byte、word、dword等伪指令，可以在“.const”段中嵌入数据值，但所有的数据声明都必须初始化。例如：

.const

roArray byte 0

byte 1，2，3，4，5

qwVal qword 1

qword 0

请注意，还可以在“.code”段中声明常量值。因为Windows对“.code”段进行写保护，所以在“.code”段中声明的数据值也是只读对象。如果确实在“.code”段中放置了常量声明，那么应该注意将这些常量放置在程序不会尝试以代码形式执行它们的位置（例如在jmp或ret指令之后）。除非用户使用数据声明手动编码x86机器指令（这种情况很少见，而且只能由专家程序员完成），否则用户不希望程序尝试将数据作为机器指令执行，因为结果通常是未定义的。

3.1.4“.data？ ”段

“.const”段要求用户初始化所有声明的对象。“.data”段允许用户选择性地初始化对象（或者不初始化对象，在这种情况下，对象的默认初始值为0）。“.data？”段则允许用户声明在程序开始运行时未初始化的变量。“.data？”段开始于保留关键字“.data？”，包含不带初始值的变量声明。以下是一个例子：

.data？

UninitUns32 dword ？

i sdword ？

character byte ？

b byte ？

Windows将程序加载到内存时，将所有“.data？”对象初始化为0。然而，并不建议依赖这种隐式初始化变量的方式。如果需要使用值0来初始化对象，可以在“.data”中声明该对象，并显式将其设置为0。

在“.data？”段中声明的变量，可能会使程序的可执行文件占用更少的磁盘空间。这是因为MASM将常量对象和数据对象的初始值写入可执行文件中，但MASM可能会采用打包格式表示“.data”段中未初始化的变量。请注意，具体的行为取决于操作系统版本和对象模块的格式。

3.1.5 程序中声明段的组织方式

在一个程序中，“.data”段、“.const”段、“.data”段和“.code”段可以出现零次或多次。段的声明可能以任何顺序出现，如下例所示：

.data

i_static sdword 0

.data？

i_uninit sdword ？

.const

i_readonly dword 5

.data

j dword？

.const

i2 dword 9

.data？

c byte？

.data？

d dword ？

.code

此处是代码

end

这些段的位置顺序没有限制，并且给定的声明段可能在程序中出现多次。如前所述，当在程序的声明段中，出现同一类型的多个声明段（例如，上面示例中的3个“.data？”段）时，MASM会将它们合并到一个组中（按任意顺序）。

3.1.6 内存访问和 4KB 内存管理单元页

x86-64的内存管理单元（Memory Management Unit，MMU）将内存划分为人们称为页（page）的块。操作系统负责管理内存中的页，因此应用程序通常不必关心页的组织方式。但是，在处理内存中的页时，我们应该注意以下几个问题：具体而言，CPU是否允许访问给定的内存位置，以及给定的内存是读取/写入模式，还是只读模式（写保护）。

每个程序段都位于内存中的连续MMU页中。也就是说，“.const”段从MMU页中的偏移量0处开始存储，该段中的所有数据顺序占用内存中的页。存储内存中一个段的开始页紧跟在存储上一个段的最后一页之后，并从开始页中的偏移量0处开始存放一个段（可能是“.data”段）的内容。如果上一个段（例如，“.const”段）并没有占用4KB的整数倍空间，则该段的数据结尾与最后一页的结尾之间将包含填充空间，以确保下一个段从MMU的页边界开始。

每一个新的段都从自己的MMU页开始，因为MMU使用页粒度来控制对内存的访问。例如，MMU控制内存中的页是采取可读取/写入模式还是只读模式。对于“.const”段，我们希望内存为只读的。对于“.data”段，我们希望同时允许读取和写入。因为MMU只能逐页强制执行这些属性，所以“.data”段的信息与“.const”段的信息不能存储在同一个MMU页中。

通常情况下，所有这些操作对用户代码都是完全透明的。在“.data”段（或者.data？段）中声明的数据是可读写的，“.const”段（以及“.code”段）中的数据是只读的（“.code”段的数据也是可执行的）。除了将数据放在特定的段之外，用户不必太关心内存页的属性。

但是存在这样一种情况，用户确实需要考虑内存中MMU页的组织方式。有时，访问（读取）内存中数据结构末尾以外的数据非常方便（想要了解这其中合理缘由的读者，请参阅第11章的SIMD指令和第14章的字符串指令），但是如果该数据结构与MMU页的结尾对齐，则访问内存中的下一页时可能会存在问题。内存中的某些页是无法访问的（inaccessible），MMU不允许对这些页上进行读取、写入或者在这些页上执行操作。

尝试这样做将导致生成x86-64一般保护（段）错误，并中止程序的正常执行。如果有一个跨越页边界的数据访问，并且内存中的下一页不可访问，则用户的程序将崩溃。例如，恰好在MMU页末尾的一个字节处，尝试访问一个字对象，如图3-2所示。

一般而言，我们不应该读取数据结构末尾以外的数据。如果出于某种原因需要这样做，那么应该确保访问内存中的下一个页是合法的（遗憾的是，现代x86-64 CPU系列没有提供允许该操作的指令。保证访问合法的唯一方法是，确保在我们正访问的数据结构之后确实存在有效的数据）。

图3-2 在MMU页的末尾访问一个字对象

3.2 MASM 如何为变量分配内存

MASM将4个声明段（“.code”段、“.data”段、“.const”段和“.data？”段）分别与一个当前位置计数器相关联。这些位置计数器最初的值为0，每当用户在其中一个段中声明变量（或者在“.code”段中写入代码）时，MASM就将该段的位置计数器的当前值与该变量相关联。此外，MASM也会根据用户声明的对象的大小来增加该位置计数器的值。请阅读以下的一个示例，假设程序中只有一个“.data”声明段：

.data

b byte？；位置计数器的值=0，大小=1

w word？；位置计数器的值=1，大小=2

d dword？；位置计数器的值=3，大小=4

q qword？；位置计数器的值=7，大小=8

o oword？；位置计数器的值=15，大小=16

；此时，位置计数器的值=31

正如所见，在（单个）“.data”段中声明的变量，具有在该段中连续的偏移量（位置计数器的值）。根据上面的声明示例，在内存中，w将紧跟b存放，d将紧跟w存放，q将紧跟d存放，依此类推。这些偏移量并不是变量的实际运行时地址。在运行时，系统将每个段分别加载到内存中的一个（基）地址处。链接器和Windows将内存段的基址加到每个位置计数器值[我们称之为位移量（displacement）或偏移量]中，以生成变量的实际内存地址。

请记住，可以将其他模块（例如，C标准库中的函数）与用户编写的程序链接在一起。而且，同一个源文件中可能会包含其他的“.data”段，链接器必须合并各“.data”段。每个段都有自己的位置计数器，在为段中的变量分配存储空间时，该计数器也从0开始。因此，单个变量的偏移量可能对其最终内存地址影响不大。

请记住，MASM将我们在“.const”段、“.data”段和“.data？”段中声明的内存对象分配到完全不同的内存区域。因此，我们不能假设以下3个内存对象出现在相邻的内存位置（实际上，这些内存对象可能并不会位于相邻的内存位置）：

.data

b byte？

.const

w word 1234h

.data？

d dword ？

事实上，MASM甚至不能确保用户在单独的“.data”（或任意）段中声明的变量在内存中是相邻存放的，即使代码中的声明之间没有任何其他内容。例如，在以下声明中，我们不能假设b、w和d位于相邻的内存位置，也不能假设这些变量在内存中不相邻：

.data

b byte ？

.data

w word 1234h

.data

d dword ？

如果代码要求这些变量占用相邻的内存位置，则必须在同一个“.data”段中声明这些变量。

3.3 标签声明

标签（label）声明允许我们在段（“.code”段、“.data”段、“.const”段和“.data？”段）中声明变量，且不用为变量分配内存。label伪指令指示MASM在声明段中将当前地址分配给变量，但不为对象分配任何存储空间。该变量与变量声明段中出现的下一个对象共享相同的内存地址。以下是标签声明的语法：

variable_name label type

以下代码序列给出了一个在“.const”段中使用标签声明的示例：

.const

abcd label dword

byte 'a'，'b'，'c'，'d'

在上面的示例中，abcd是一个双字，其低阶字节包含97（字母a的ASCII码值），第一个字节包含98（字母b的ASCII码值），第二个字节包含99（字母c的ASCII码值），高阶字节包含100（字母d的ASCII码值）。MASM不会为变量abcd保留存储空间，因此MASM将内存中的以上四个字节（由byte伪指令分配）与变量abcd关联在一起。

3.4 小端模式和大端模式的数据组织方式

回顾1.8节中的相关内容，其中指出x86-64在内存中存储多字节的数据类型时，将低阶字节存于内存中的最小地址处，高阶字节存于内存中的最大地址处（具体请参见图1-5）。内存中的这种数据组织方式称为小端（little endian）模式。小端模式的数据组织方式（低阶字节在前，高阶字节在后）是许多现代CPU共享的一种常见内存组织。然而，小端模式并不是唯一的数据组织方式。

大端（big endian）模式数据组织方式与小端模式数据组织方式在内存字节的顺序上刚好相反。大端模式数据结构的高阶字节首先出现（在最小内存地址中），低阶字节出现在最大内存地址中。表3-1、表3-2和表3-3分别描述了字、双字和四字的内存组织方式。

表 3-1 字对象的小端模式和大端模式数据组织方式

表 3-2 双字对象的小端模式和大端模式数据组织方式

表 3-3 四字对象的小端模式和大端模式数据组织方式

通常情况下，我们不会太关心x86-64 CPU上的大端模式内存组织方式。但是，有时可能需要处理由不同CPU（或由使用大端模式数据组织方式作为其标准整数格式的协议，如TCP/IP）生成的数据。如果要将内存中的大端模式数据值加载到CPU寄存器中，则计算结果将不正确。

如果内存中有一个16位的大端模式数据值，并且用户将其加载到一个16位寄存器中，那么该数据值将进行字节交换。对于16位值，可以使用xchg指令纠正此问题。xchg指令的语法形式如下所示：

xchg reg ， reg

xchg reg ， mem

其中reg是任何8位、16位、32位或64位通用寄存器，mem则是任何合适的内存位置。第一条指令中的两个reg操作数的大小，以及第二条指令中的reg和mem操作数的大小都必须相同。

使用xchg指令可以实现任意两个（大小一致的）寄存器或者寄存器与内存位置之间值的交换，也可以实现（16位）小端模式和大端模式数据格式之间的转换。例如，如果AX寄存器包含大端模式数据格式的值，并且在进行某些计算之前需要将其转换为小端模式数据格式的值，则可以使用以下指令交换AX寄存器中的字节实现该目的：

xchg al，ah

使用xchg指令，以及低位和高位寄存器标识符（AL和AH、BL和BH、CL和CH、DL和DH），可以实现16位寄存器AX、BX、CX和DX中的小端模式和大端模式数据值之间的转换。

遗憾的是，xchg指令不适用于AX、BX、CX和DX以外的寄存器。为了处理较大的值，英特尔引入了bswap（byte swap，字节交换）指令。顾名思义，这个指令交换32位或者64位寄存器中的字节内容，包括交换HO字节和LO字节的内容，以及交换（HO-1）字节和（LO+1）字节（还有交换64位寄存器中的其他所有相反字节对）的内容。bswap指令适用于所有通用32位和64位寄存器。

3.5 内存访问

x86-64 CPU通过数据总线从内存中获取数据。在理想化的CPU中，数据总线与CPU上标准整数寄存器的大小相同，因此我们期望x86-64 CPU具有64位数据总线。在实践中，现代CPU通常采用更大的物理数据总线连接到主存，以提高系统性能。在某次操作中，总线从内存中读取大量数据，并将这些数据放入CPU的高速缓存（cache）中，该高速缓存充当CPU和物理内存之间的缓冲区。

从CPU的角度来看，高速缓存就是内存。因此，本节的其余部分在讨论内存时，通常是讨论高速缓存中的数据。系统将内存访问透明地映射到高速缓存中，从而我们可以假设高速缓存不存在从而讨论内存，并根据需要讨论高速缓存的优点。

在早期的x86处理器上，内存被排列为字节数组（对于8位计算机，例如8088）、字数组（对于16位计算机，例如8086和80286）、双字数组（对于32位计算机，例如80386）。在16位计算机上，地址的低阶位实际上不出现在地址总线中。因此，地址126和127在地址总线上放置了相同的位模式（126，第0位的值隐含为0），如图3-3所示。

当读取字节时，CPU使用地址的最低位去选择数据总线上的低阶字节或者高阶字节。图3-4显示了从偶数地址（图3-4中的126）读取字节的过程。图3-5显示了从奇数地址（图3-5中的127）读取字节的过程。注意，在图3-4和图3-5中，地址总线上出现的地址都是126。

图3-3 16位处理器的地址总线和数据总线

图3-4 在16位CPU上从偶数地址读取字节

图3-5 在16位CPU上从奇数地址读取字节

那么，当16位CPU想要访问奇数地址上的16位数据时，会发生什么呢？例如，假设在图3-4和图3-5中，CPU要读取地址125处的字。当CPU将地址125放到地址总线上时，低阶位不会实际出现。因此，总线上的实际地址是124。此时，如果CPU从数据总线上读取低阶8位，则它读取的将是地址124而不是地址125处的数据。

幸运的是，CPU足够聪明，能够弄清楚这里发生了什么，并读取地址总线上高阶8位的数据，将其用作数据操作数的低阶8位。但是，在数据总线上找不到CPU需要的数据的高阶8位。CPU必须启动第二次读取操作，将地址126放在地址总线上，以获取高阶8位（将位于数据总线的低阶8位，但CPU可以解决这个问题）。完成此读取操作的代价是需要两个内存周期。因此，执行从奇数地址的内存单元读取数据的指令，其时间将比执行从偶数地址（2的整数倍）读取数据的指令的时间更长。

在32位处理器上存在同样的问题，只是32位数据总线允许CPU一次读取4字节。如果地址不是4的整数倍，那么从该地址读取32位值会导致相同的性能损失。请注意，在奇数地址访问16位操作数则不一定会消耗额外的内存周期，只有当地址除以4的余数等于3时，才会产生性能损失。特别地，如果在低阶2位为01b的地址访问16位值（在32位总线上），那么CPU可以在单个内存周期内读取该字，如图3-6所示。

带有高速缓存系统的现代x86-64 CPU在很大程度上解决了这个问题。只要数据（大小为1、2、4、8或10字节）完全位于高速缓存线内，访问未对齐就不会造成内存周期的损失。如果访问确实跨越了缓存线边界，那么CPU会执行两个内存操作以获取（或存储）数据，因此运行速度会减慢。

图3-6 在32位数据总线上访问字

3.6 MASM 对数据对齐的支持

为了编写高效的程序，需要确保合理对齐内存中的数据对象。合理对齐意味着一个对象的起始地址是某个大小的倍数，如果对象的大小是2的幂并且不大于32字节，则该大小通常是对象的大小。对于大小大于32字节的对象，在8、16或32字节的地址边界上对齐对象就足够了。对于大小小于16字节的对象，可以将比对象大小大的第一个2的幂作为对象对齐地址。如果数据未在适当的地址上对齐，则访问这些数据可能需要额外的时间（如前一节所述），因此如果需要确保提高程序的运行速度，应该尝试根据数据对象的大小进行对齐。

当需要为相邻内存位置中不同大小的对象分配存储空间时，数据就会发生错位。例如，如果声明了一个字节变量，则该字节变量将占用一个字节的存储空间，当在该声明段中声明下一个变量时，该变量的地址是字节对象所在的地址加上1。如果字节变量的地址恰好是偶数地址，则该字节后面的变量将从奇数地址开始。如果后面的变量是一个字对象或双字对象，则其起始地址将不是最优的。在本节中，我们将探讨如何根据对象的大小确保变量在适当的起始地址对齐。

请考虑下面的MASM变量声明：

.data

dw dword ？

b byte ？

w word ？

dw2 dword ？

w2 word ？

b2 byte ？

dw3 dword ？

在Windows下运行时，程序第一行的“.data”声明将其变量放置在4096字节的偶数倍的地址处。无论“.data”段中的第一个变量是什么，都保证将该变量对齐到合适的地址。其后的每个变量都将分配到一个地址，该地址是所有前面变量的大小加上“.data”段的起始地址。因此，假设MASM将前一示例中的变量分配到4096的起始地址，则MASM将在以下地址分配这些变量：

；起始地址长度

dw dword ？；4096 4

b byte ？；4100 1

w word ？；4101 2

dw2 dword ？；4103 4

w2 word ？；4107 2

b2 byte ？；4109 1

dw3 dword ？；4110 4

除了第一个变量（在4KB边界上对齐）和字节变量（是否对齐不重要）之外，其余变量都未适当对齐。w、w2和dw2变量从奇数地址开始；虽然dw3变量在偶数地址上对齐，但该地址不是4的倍数。

确保变量适当对齐的一个简单方法是在声明中首先放置所有的双字变量，接着放置字变量，最后放置字节变量，如下所示：

.data

dw dword ？

dw2 dword ？

dw3 dword ？

w word ？

w2 word ？

b byte ？

b2 byte ？

这种变量的组织方式会在内存中生成以下的地址分配：

；起始地址长度

dw dword ？；4096 4

dw2 dword ？；4100 4

dw3 dword ？；4104 4

w word ？；4108 2

w2 word ？；4110 2

b byte ？；4112 1

b2 byte ？；4113 1

正如所见，这些变量都在合理的地址上对齐。遗憾的是，以这种方式排列变量的可能性并不大。无法按这种方式排列变量有很多原因，一个有说服力的实践原因是MASM不允许我们按逻辑功能的方式组织变量的声明（也就是说，我们可能希望相关变量彼此相邻，而不管这些变量的实际大小）。

为了解决这个问题，MASM提供了align伪指令，这个伪指令的语法形式如下所示：

align integer_constant

integer_constant（整型常量）必须是以下的小无符号整数值之一，即1、2、4、8、16中的一个。如果MASM在“.data”段中遇到align伪指令，它将对齐下一个变量到integer_constant的偶数倍地址。可以使用align伪指令重写前面的示例，如下所示：

.data

align 4

dw dword ？

b byte ？

align 2

w word ？

align 4

dw2 dword ？

w2 word ？

b2 byte ？

align 4

dw3 dword ？

如果MASM确定align伪指令的当前地址（位置计数器值）不是指定常量值的整数倍，则MASM将在上一个变量声明之后，自动生成额外的填充字节，直到“.data”段中的当前地址是指定值的倍数。这样处理的结果是，程序代码会稍微长一些（但也只是长若干字节而已），但对数据的访问变快了。考虑到使用此功能时，程序长度只会增加若干字节，因此这可能是一个很好的折中方案。

一般而言，如果希望以尽可能快的速度访问数据，那么应选择与需要对齐的对象大小相等的对齐值。也就是说，应该使用“align 2”语句将字对齐到偶数边界，使用“align 4”将双字对齐到4字节边界，使用“align 8”将四字对齐到8字节边界，等等。如果对象的大小不是2的幂，则将对象与比其大小大的第一个2的幂对齐（最多16字节）。但是，请注意，只需要在8字节边界上对齐real80（以及tbyte）对象。

请注意，数据对齐并非总是必须的。现代x86-64 CPU系列的高速缓存体系结构实际上可以处理绝大多数未适当对齐的数据。因此，应该仅对某些变量（快速访问这些变量至关重要）使用对齐指令。这是一个合理的空间与速度之间的权衡方案。

3.7 x86-64 的寻址模式

到目前为止，我们只讨论了一种访问变量的方法：PC相对寻址（PC-relative addressing）模式。在本节中，我们将讨论用于程序访问内存的其他x86-64内存寻址模式。寻址模式（addressing mode）是CPU用来确定指令将访问的内存位置地址的机制。

x86-64的内存寻址模式提供了对内存的灵活访问，允许我们轻松地访问变量、数组、记录、指针以及其他复杂的数据类型。掌握x86-64的寻址模式是掌握x86-64汇编语言的第一步。

x86-64提供了以下几种寻址模式。

●寄存器寻址模式。

●PC相对寻址模式。

●寄存器间接寻址模式：[reg ₆₄ ]。

●间接加偏移寻址模式：[reg ₆₄ +expression]。

●缩放索引寻址模式：[reg ₆₄ +reg ₆₄ ^* scale]和[reg ₆₄ +expression+reg ₆₄ ^* scale]。

以下各节将介绍各种寻址模式。

3.7.1 x86-64 的寄存器寻址模式

寄存器寻址模式提供对x86-64通用寄存器集的访问。将寄存器的名称指定为指令的操作数，就可以访问该寄存器的内容。本节将使用x86-64的mov（move）指令来演示寄存器寻址模式。mov指令的通用语法形式如下所示：

mov destination ， source

mov指令将数据从source（源）操作数复制到destination（目标）操作数。8位、16位、32位和64位寄存器都是此指令的有效操作数。唯一的限制是两个操作数的大小必须相同。以下mov指令演示了各种寄存器的使用：

mov ax，bx ；将BX中的值复制到AX

mov dl，al ；将AL中的值复制到DL

mov esi，edx ；将EDX中的值复制到ESI

mov rsp，rbp ；将RBP中的值复制到RSP

mov ch，cl ；将CL中的值复制到CH

mov ax，ax ；是的，这是合法的！（虽然没有什么意义）

寄存器是保存变量的最佳位置。使用寄存器的指令比访问内存的指令更短更快。因为大多数计算至少需要一个寄存器操作数，所以寄存器寻址模式在x86-64汇编代码中十分常见。

3.7.2 x86-64 的 64 位内存寻址模式

x86-64系列提供的寻址模式包括PC相对寻址模式、寄存器间接寻址模式、间接加偏移寻址模式、缩放索引寻址模式。这四种形式的变体构成了x86-64上的所有寻址模式。

3.7.2.1 PC 相对寻址模式

PC相对或RIP相对寻址模式是最常见的寻址模式，也是最容易理解的寻址模式。这个模式由一个32位常量组成，CPU将该常量与RIP（instruction pointer，指令指针）寄存器的当前值相加，得到目标位置的地址。

PC相对寻址模式的语法使用了我们在MASM段（“.data”“.data？”“.const”“.code”等）中声明的symbol：

mov al，symbol；PC相对寻址模式会自动提供[RIP]

假设变量j是一个int8变量，位于相对于RIP的偏移量8088h处，则指令“mov al，j”将内存位置RIP+8088h处的字节副本加载到AL寄存器中。同样，如果int8变量K位于内存中的地址RIP+1234h处，则指令“mov K，dl”将DL寄存器中的值存储到内存位置RIP+1234h中（参见图3-7）。

图3-7 PC相对寻址模式

MASM并不会将j或K的地址直接编码到指令的操作码（operation code或opcode，指令的数字机器编码）中，而是对从当前指令地址末尾到内存中变量地址的有符号位移量进行编码。例如，如果下一条指令的操作码位于内存地址8000h（当前指令的末尾）处，则MASM将指令操作码中的j编码为32位有符号常量88h。

在x86-64处理器上，还可以通过指定字或双字的第一个字节的地址，来访问字或双字（参见图3-8）。

图3-8 使用PC相对寻址模式访问字或双字

3.7.2.2 寄存器间接寻址模式

x86-64 CPU系列允许我们使用寄存器间接寻址模式（register-indirect addressing mode），通过寄存器间接访问内存。术语“间接”（indirect）表示操作数不是实际地址，但操作数的值指定了需要使用的内存地址。在寄存器间接寻址模式的情况下，寄存器中保存的值是需要访问的内存位置所在的地址。例如，指令“mov[rbx]，eax”指示CPU将EAX中的值存储到当前RBX中保存的位置处（RBX左右的方括号指示MASM使用寄存器间接寻址模式）。

x86-64包含16种类似上述形式的寻址模式。以下指令给出了其中一个示例：

mov[ reg ₆₄ ]，al

其中，reg ₆₄ 是以下64位通用寄存器之一：RAX、RBX、RCX、RDX、RSI、RDI、RBP、RSP、R8、R9、R10、R11、R12、R13、R14或R15。寄存器间接寻址模式引用的内存位置位于方括号内寄存器指定的偏移量处。

寄存器间接寻址模式要求使用64位寄存器，不能在方括号中指定32位、16位或8位寄存器。从技术上而言，可以加载具有任意数值的64位寄存器，并使用寄存器间接寻址模式间接访问该数值代表的位置：

mov rbx，12345678

mov[rbx]，al；尝试访问位置12345678

遗憾的是（或者幸运的是，这取决于我们的视角），这可能会导致操作系统产生保护错误，因为访问任意内存位置并不总是合法的。事实证明，要将对象的地址加载到寄存器中，可以使用更好的方法。接下来我们简要讨论这些方法。

可以使用寄存器间接寻址模式访问指针所引用的数据，也可以使用这种寻址模式逐步遍历数组数据。通常情况下，在程序运行时，无论何时需要修改变量地址，都可以使用寄存器间接寻址模式。

寄存器间接寻址模式提供了匿名变量（anonymous variable）的示例。使用寄存器间接寻址模式时，可以通过变量的数字内存地址（加载到寄存器中的值）而不是变量的名称来引用变量的值。

MASM提供了一条简单的指令，用于获取变量的地址，并将该地址放入64位寄存器中，即lea指令：

lea rbx，j

执行此lea指令后，可以使用寄存器间接（[rbx]）寻址模式，间接访问j的值。

3.7.2.3 间接加偏移寻址模式

间接加偏移寻址模式（indirect-plus-offset addressing mode）通过将32位有符号常量加上64位寄存器的值来计算有效地址（effective address）。然后，指令使用内存中该有效地址处的数据。

间接加偏移寻址模式的语法形式如下所示：

mov[ reg ₆₄ + constant ]， source

mov[ reg ₆₄ - constant ]， source

其中reg ₆₄ 为64位通用寄存器，constant为4字节常量，source（源操作数）为寄存器或常量值。

如果constant为1100h，且RBX包含12345678h，则以下指令将AL中的值存储到内存中的12346778h位置处（参见图3-9）：

mov[rbx+1100h]，al

图3-9 间接加偏移寻址模式

间接加偏移寻址模式适合于访问类和记录/结构的字段。对此，我们将在第4章中做更详细的讨论。

3.7.2.4 缩放索引寻址模式

缩放索引寻址模式（scaled-indexed addressing mode）与索引寻址模式（indexed addressing mode）类似，不同之处在于缩放索引寻址模式允许组合两个寄存器和一个位移量，并将索引寄存器乘以（缩放）因子1、2、4或8来计算有效地址。（图3-10显示了一个示例，包含作为基址寄存器的RBX和作为索引寄存器的RSI。）

缩放索引寻址模式的语法形式如下所示：

[ base_reg ₆₄ + index_reg ₆₄ ^* scale ]

[ base_reg ₆₄ + index_reg ₆₄ ^* scale + displacement ]

[ base_reg ₆₄ + index_reg ₆₄ ^* scale - displacement ]

base_reg ₆₄ 表示任何通用64位寄存器，index_reg ₆₄ 表示除RSP之外的任何通用64位寄存器，并且scale（缩放因子）必须是常量1、2、4或8。

图3-10 缩放索引寻址模式

在图3-10中，假设RBX包含1000FF00h，RSI包含20h，const为2000h，那么以下指令可将地址10011F80h（1000FF00h+（20h×4）+2000h）处的字节移动到AL寄存器中：

mov al，[rbx+rsi ^* 4+2000h]

缩放索引寻址模式非常适用于访问大小为2字节、4字节或8字节的数组元素。当有指向数组开头的指针时，这些寻址模式对于访问数组元素也很有用。

3.7.3 不支持大地址的应用程序

64位地址的一个优越性是可以访问非常多的内存单元（在Windows下大约为8TB个）。默认情况下，微软链接器（当链接器将C++和汇编语言代码链接在一起时）会将一个名为LARGEADDRESSAWARE的编译标志选项设置为true（yes），这使得应用程序能够访问大量内存。但是，在LARGEADDRESSAWARE模式下的操作需要付出代价：[reg ₆₄ +const]寻址模式中的const部分被限制为32位，因此不能跨越整个地址空间。

由于指令编码的限制，const值只能取±2GB范围内的有符号值。当寄存器包含64位基址，并且我们希望访问该基址周围的固定偏移量（小于±2GB）处的内存位置时，这些值可能远远足够了。使用这种寻址模式的典型代码如下所示：

lea rcx，someStructure

mov al，[rcx+fieldOffset]

在引入64位地址之前，（32位）间接加偏移寻址模式中出现的const偏移量可以跨越整个（32位）地址空间。因此，如果有一个数组声明，例如：

.data

buf byte 256 dup（？）

就可以使用以下寻址模式访问该数组的元素：

mov al，buf[ebx]；EBX用于32位处理器上

试着在64位程序中汇编指令“mov al，buf[rbx]”（或者涉及buf但非PC相对寻址模式的其他寻址模式），会发现尽管MASM能够正确汇编代码，但链接器将报告错误：

error LNK2017：'ADDR32' relocation to 'buf' invalid without/LARGEADDRESSAWARE：NO

链接器报告的错误旨在说明：在超过32位的地址空间中，不可能将偏移量编码到buf缓冲区，因为机器指令操作码仅提供32位偏移量来保存buf的地址。

不过，如果我们人为地将应用程序使用的内存数量限制在2GB，MASM便可以将相对于buf的32位偏移量编码到机器指令中。只要我们遵守限制，绝不使用超过2GB的内存，间接加偏移寻址模式和缩放索引寻址模式就有可能发展出一些新变体。

为了关闭LARGEADDRESSAWARE功能，需要在ml64命令中添加一个额外的命令行选项。利用build.bat批处理文件，可以很容易地实现添加。接下来创建一个新的build.bat文件，并称之为sbuild.bat（表示small build，小规模构建）。sbuild.bat文件将包含以下几行命令：

echo off

ml64/nologo/c/Zi/Cp%1.asm

cl/nologo/O2/Zi/utf-8/EHa/Fe%1.exe c.cpp%1.obj/link/largeaddressaware：no

这组命令指示MASM，向链接器传递一个命令，以关闭LARGEADDRESSAWARE功能。MASM、MSVC和微软链接器将构造一个只需要32位地址的可执行文件（忽略在寻址模式下出现的64位寄存器中的32个高阶位）。

一旦禁用LARGEADDRESSAWARE，用户编写的程序就可以使用以下几种间接加偏移寻址模式和缩放索引寻址模式的新变体：

variable [ reg ₆₄ ]

variable [ reg ₆₄ + const ]

variable [ reg ₆₄ - const ]

variable [ reg ₆₄ ^* scale ]

variable [ reg ₆₄ ^* scale + const ]

variable [ reg ₆₄ ^* scale - const ]

variable [ reg ₆₄ + reg_not_RSP ₆₄ ^* scale ]

variable [ reg ₆₄ + reg_not_RSP ₆₄ ^* scale + const ]

variable [ reg ₆₄ + reg_not_RSP ₆₄ ^* scale - const ]

其中，variable（变量名）是我们使用诸如byte、word、dword等的伪指令在源文件中声明的对象名称，const是一个（最大32位）常量表达式，scale是1、2、4或8。这些寻址模式使用变量的地址作为基址，并将其与64位寄存器的当前值相加（示例请参见图3-11至图3-16）。

图3-11 间接加偏移寻址模式的基址形式

图3-12 间接加偏移寻址模式的小地址加常量形式

图3-13 基址加缩放索引寻址模式的小地址形式

图3-14 基址加缩放索引加常量寻址模式的小地址形式

图3-15 缩放索引寻址模式的小地址形式

图3-16 缩放索引加常量寻址模式的小地址形式

虽然小地址形式（LARGEADDRESSAWARE：NO）既方便又高效，但是如果用户的程序使用了超过2GB的内存，程序就会出现错误，使用这些地址（使用全局数据对象作为基址，而不是将基址加载到寄存器中）的所有指令都需要重写。这可能是一件非常痛苦的事情，并且容易出错。在使用LARGEADDRESSAWARE：NO之前，请三思。

3.8 地址表达式

通常情况下，在访问内存中的变量和其他对象时，我们需要访问变量之前或之后的内存位置，而不是访问变量指定地址处的内存位置。例如，当访问数组的元素或者结构/记录的字段时，确切的元素或字段可能并不位于变量本身的地址处。地址表达式（address expression）提供了一种机制，将算术表达式附加到地址上，以访问变量地址周围的内存位置。

在本书中，地址表达式是任何一种合法的x86-64寻址模式，该模式包括位移量（也即变量名）或者偏移量。例如，以下是合法的地址表达式：

[ reg ₆₄ + offset ]

[ reg ₆₄ + reg_not_RSP ₆₄ ^* scale + offset ]

考虑下面有关内存地址的一个合法MASM语法，它实际上不是一个新的寻址模式，而只是PC相对寻址模式的一种简单扩展：

variable_name [ offset ]

这个扩展形式通过将变量的地址加上方括号内的常量偏移量来计算变量的有效地址。例如，指令“mov al，Address[3]”将Address对象后的3个字节，加载到AL寄存器中（参见图3-17）。

图3-17 使用地址表达式访问变量以外的数据

请注意，这些示例中的offset值必须是常量。如果index是int32变量，那么variable[index]不是合法的地址表达式。如果希望指定在运行时可以变化的索引，则必须使用间接寻址模式或者缩放索引寻址模式。

还需要注意的是，Address[offset]中的offset是字节地址。尽管这种语法让人联想到C/C++或者Java等高级程序设计语言中的数组索引，但除非Address是字节数组，否则不能正确地索引到对象数组中。

在此之前，所有寻址模式示例中的偏移量都是单个数字常量。其实，MASM还允许在任何偏移量合法的地方使用常量表达式（constant expression）。常量表达式由一个或者多个常量项组成，这些常量项进行加法、减法、乘法、除法、求余（模）等各种运算。然而，大多数地址表达式只涉及加法、减法、乘法，有时候还涉及除法运算。请考虑下面的例子：

mov al，X[2 ^* 4+1]

上述指令将X的地址+9处的字节移动到AL寄存器中。

地址表达式的值始终在编译的时候进行计算，而不是在程序运行的时候。当MASM遇到上面的指令时，将会立即计算2×4+1，并将计算结果累加到内存中X的基址上。MASM将此计算累加和（X的基址值加上9）的操作编码为指令的一部分，不会发出额外的指令来在运行时计算这个表达式的累加和（这种处理方式很合理，虽然效率会比较低）。因为MASM在编译时计算地址表达式的值，所以表达式的所有构成部分都必须是常量，因为MASM在编译程序时无法知道变量运行时的值。

地址表达式对于访问内存中变量以外的数据非常有用，特别是当用户在“.data”段或“.const”段中使用了byte、word、dword等语句，用以在数据声明后附加额外的字节时。例如，考虑程序清单3-1中的代码，该程序使用地址表达式访问4个连续字节，而这4个连续字节与变量i相关联。

程序清单 3-1 地址表达式的演示示例

构建和运行该程序的命令及输出结果如下所示：

C：\> build listing3-1

C：\> echo off

Assembling：listing3-1.asm

c.cpp

C：\> listing3-1

Calling Listing 3-1：

i[0]=0 i[1]=1 i[2]=2 i[3]=3

Listing 3-1 terminated

程序清单3-1中的代码显示了4个值，即0、1、2和3，并且将这4个值作为数组中的各个元素来处理。这是因为地址i处的值为0。地址表达式i[1]指示MASM获取位于i的地址加1处的字节内容。该位置的值为1，这是因为这个程序的byte语句在“.data”段中的值0之后定义了值1。同理，对于i[2]和i[3]，该程序显示值2和值3。

请注意，MASM还提供了一个特殊的运算符this，用于返回位于段中的当前位置计数器的值。可以使用this运算符在地址表达式中表示当前指令的地址。有关更多详细信息，请参阅4.3.1节中的相关内容。

3.9 栈段以及 push 和 pop 指令

x86-64在内存的栈段中维护栈。栈（stack）是一种动态的数据结构，大小可以根据程序的特定需求变大和变小。栈还可以存储有关程序的重要信息，包括局部变量、子例程信息和临时数据。

x86-64通过RSP（stack pointer，栈指针）寄存器控制其栈。当程序开始执行时，操作系统使用栈内存段中最后一个内存位置的地址初始化RSP。通过将数据“压入”（push）栈，将数据写入栈段；通过从栈中“弹出”（pop）数据，将数据从栈段中删除。

3.9.1 基本的 push 指令

x86-64的push指令语法形式如下所示：

push reg ₁₆

push reg ₆₄

push memory ₁₆

push memory ₆₄

pushw constant ₁₆

push constant ₃₂ ；将 constant ₃₂ 符号扩展到64位

这六种形式允许我们压入以下数据：16位的寄存器数据、64位的寄存器数据、16位的内存数据、64位的内存数据、16位的常量以及64位的常量。然而，不能压入32位的寄存器数据、32位的内存数据以及32位的常量。

push指令执行以下操作：

RSP：=RSP- size_of_register_or_memory_operand （2 or 8）

[RSP]：= operand's_value

例如，假设RSP寄存器中的值为00FF_FFFCh，指令“push rax”将RSP寄存器中的值设置为00FF_FFF4h，并将RAX寄存器中的当前值存储到内存单元00FF_FFF4中，如图3-18和图3-19所示。

尽管x86-64支持16位入栈操作，但是16位入栈操作主要用于16位的环境，例如微软磁盘操作系统（Microsoft Disk Operating System，MS-DOS）。为了获得最佳的性能，栈指针的值应该始终为8的倍数。实际上，如果RSP寄存器中包含的值不是8的倍数，则在64位的操作系统下，用户的程序可能会出现故障。一次只能往栈中压入少于8个字节数据的唯一实际原因是通过4次连续的字压入操作来构建一个四字数据。

图3-18 执行“push rax”操作之前的栈段

图3-19 执行“push rax”操作之后的栈段

3.9.2 基本的 pop 指令

为了提取已经压入栈中的数据，可以使用pop指令。基本的pop指令语法形式如下所示：

pop reg ₁₆

pop reg ₆₄

pop memory ₁₆

pop memory ₆₄

与push指令一样，pop指令仅支持16位和64位的操作数，不能从栈中弹出8位或32位的值。另外，与push指令一样，应该避免弹出16位的值（除非连续弹出四个16位的值），因为弹出16位的值可能会使RSP寄存器中包含的值不是8的倍数。push和pop之间的一个主要区别是不能将一个常量值弹出栈（这是显而易见的，因为push的操作数是源操作数，而pop的操作数是目标操作数）。

从形式上而言，pop指令执行以下的操作：

operand ：=[RSP]

RSP：=RSP+ size_of_operand （2 or 8）

正如所见，pop操作与push操作正好相反。请注意，在调整RSP寄存器中的值之前，pop指令先从内存单元[RSP]处复制数据。有关这个操作的详细信息，请参见图3-20和图3-21。

图3-20 执行“pop rax”操作之前的内存

图3-21 执行“pop rax”操作之后的内存

注意，从栈中弹出的值仍然存在于内存中，并不会被擦除。弹出操作只是调整栈指针，使栈指针指向弹出值上方的一个值。但是，永远不要尝试访问已经从栈中弹出的值。下一次将某些内容压入栈时，弹出栈的值才会被抹去。除了用户自己的代码外，其他程序也会使用栈（例如，操作系统会使用栈，子例程也会使用栈），所以一旦从栈中弹出数据，就无法确保出栈后的数据仍然保存在栈内存中。

3.9.3 使用 push 和 pop 指令保存寄存器的状态

push和pop指令最常见的用途可能是在中间计算过程中保存寄存器的值。由于寄存器是保存临时值的最佳场所，并且很多寻址模式也需要用到寄存器，因此在编写执行复杂计算的代码时，很容易耗尽所有的寄存器。当发生这种情况时，可以借助于push和pop指令来保存寄存器的状态。

请考虑下面的程序框架：

需要使用RAX寄存器的指令序列

需要使用RAX寄存器的指令序列，但是与第一个指令序列的用途不同

需要使用RAX中原始值的指令序列

push和pop指令非常适合于以上程序框架中所述的情况。在中间指令序列之前插入一个push指令，在中间指令序列之后再插入一个pop指令，就可以在这些计算中保留RAX寄存器值，相应的程序框架如下：

需要使用RAX寄存器的指令序列

push rax

需要使用RAX寄存器的指令序列，但是与第一个指令序列的用途不同

pop rax

需要使用RAX中原始值的指令序列

以上程序框架中的push指令将在第一个指令序列中计算的数据复制到栈中。现在，中间的那个指令序列可以将RAX寄存器用于其他任何目的。当中间的指令序列完成后，pop指令恢复RAX寄存器中的值，以便最后一个指令序列可以继续使用RAX中的原始值。

3.10 栈

我们可以将多个值压入栈中，而无须先从栈中弹出以前的值。栈是一个后进先出（last-in，first-out，LIFO）的数据结构，因此在压入和弹出多个值的时候，特别需要注意数据的顺序。例如，假设希望在指令块中保留RAX和RBX寄存器的值，以下代码演示了处理此问题的一种显而易见的方法：

push rax

push rbx

此处是使用RAX和RBX的代码

pop rax

pop rbx

遗憾的是，上述代码无法正常工作！图3-22至图3-25显示了问题所在。这段代码先将RAX的值压入栈中，再将RBX的值压入栈中，结果是栈指针指向栈中RBX的值。当执行“pop rax”指令时，将从栈中弹出最初位于RBX中的值，并将该值放入RAX中！同样，“pop rbx”指令将原来位于RAX中的值弹出并放到RBX寄存器中。结果，这段代码交换了寄存器RAX和RBX的值，因为是按相同的顺序对两个寄存器进行弹出与压入的。

为了纠正这个问题，必须注意，栈是一个后进先出的数据结构，最先弹出栈的内容必须是最后压入栈中的内容。因此，我们必须始终遵守以下准则：始终按照与往栈中压入值时相反的顺序弹出栈中的值。

图3-22 压入RAX后的栈

图3-23 压入RBX后的栈

图3-24 弹出RAX后的栈

图3-25 弹出RBX后的栈

先前代码的更正如下所示：

push rax

push rbx

此处是使用RAX和RBX的代码

pop rbx

pop rax

另一条需要牢记的重要准则是：在栈中，弹出的字节数必须总是与所压入的字节数完全相同。这通常意味着入栈的操作次数必须和出栈的操作次数完全一致。如果pop操作次数太少，则会在栈中留下数据，这可能使正在运行的程序出现混乱。如果pop操作次数太多，又会意外地删除以前入栈的数据，通常会带来灾难性的后果。

上述重要准则的一个推论是，在循环语句中将数据入栈和出栈时要特别小心谨慎。经常会出现将push指令置于循环中，而将pop指令留在循环外（反之亦然）的现象，从而创建不一致的栈。请记住，重要的是push和pop指令如何执行，而不是程序中出现的push和pop指令的数量。在运行时，程序执行的push指令的数量（以及顺序）必须与pop指令的数量（以及相反顺序）相匹配。

最后需要注意的事情是：微软ABI要求栈在16字节边界上对齐。当往栈中压入和从栈中弹出数据项时，请确保在调用符合微软ABI的函数或过程之前，栈在16字节边界上对齐（并要求之后栈也要在16字节边界上对齐）。

3.11 其他 push 和 pop 指令

除了基本指令外，x86-64还提供了如下四条额外的push和pop指令：

pushf popf

pushfq popfq

pushf、pushfq、popf和popfq指令用于压入和弹出RFLAGS寄存器的值。这些指令允许用户在执行一系列指令的过程中保留条件码和其他标志位的设置。遗憾的是，保存单个标志位必定耗费巨大的精力。当使用pushf（q）和popf（q）指令时，要么对所有的标志位进行操作，要么不对任何标志位进行操作：当压入栈时，保留所有的标志位；当弹出栈时，恢复所有的标志位。

我们应该使用pushfq和popfq指令压入和弹出RFLAGS寄存器完整的64位，而不仅是其中16位的标志位。尽管在编写应用程序时，压入和弹出的额外48位基本上会被忽略，但仍应通过压入和弹出四字来保持栈对齐。

3.12 不通过弹出栈从栈中移除数据

经常会有的情况是不再需要使用已经压入栈的数据。尽管我们可以将这类数据从栈中弹出并放到某个未使用的寄存器或者内存单元中，但还有一种更简单的方法可以从栈中移除我们不再需要的数据，即只调整RSP寄存器中的值，从而跳过栈中的这些数据。

请考虑下面的代码困境（伪代码，不是实际的汇编语言）：

push rax

push rbx

代码序列，将计算结果值保存到RAX和RBX中

if（ 执行了计算 ）then

；我们不希望弹出RAX和RBX！

；该如何处理栈？

else

；没有执行计算，因此需要恢复RAX和RBX。

pop rbx

pop rax

endif；

在if语句的then部分中，希望移除寄存器RAX和RBX中的旧值，但是不会影响其他任何寄存器或者内存单元的内容。我们该如何用代码实现呢？

因为RSP寄存器包含栈顶部的数据项的内存地址，所以将该数据项的大小累加到RSP寄存器中，就可以从栈顶部移除该数据项。在前面的示例中，我们希望从栈的顶部移除2个四字数据项，这可以通过将栈指针加上16来轻松实现（有关详细信息，请参见图3-26和图3-27）：

push rax

push rbx

代码序列，将计算结果值保存到RAX和RBX中

If（ 执行了计算 ）then

；从栈中移除不需要的RAX/RBX值。

add rsp，16

else

；没有执行计算，因此需要恢复RAX和RBX。

pop rbx

pop rax

endif；

图3-26 从栈中移除数据（执行“add rsp，16”指令之前）

图3-27 从栈中移除数据（执行“add rsp，16”指令之后）

实际上，这段代码在没有将数据移动到任何地方的情况下，成功地将数据从栈中弹出。还请注意，这段代码比两条伪pop指令执行速度要快，因为它可以仅使用一条add指令就从栈中移除任意数量的字节。

注意： 请记住，需要在四字边界上保持栈对齐。因此，只要从栈中移除数据时，就应该向RSP中添加一个常量，该常量必须是8的倍数。

3.13 不通过弹出栈访问压入栈的数据

有的时候，我们会将数据压入栈中，然后希望获得该数据值的副本，或者可能希望更改该数据的值，而又不真正将数据从栈中弹出（即我们希望稍后才将数据从栈中弹出）。x86 ~-~ 64的[reg ₆₄ ±offset]寻址模式提供了实现该功能的机制。

请考虑在执行以下两条指令后的栈（参见图3-28）：

push rax

push rbx

图3-28 压入RAX和RBX后的栈

如果希望访问RBX中的原始值而不将其从栈中移除，那么可以从栈中弹出该值，然后立即再次压入该值。进一步，假设希望访问RAX的旧值，或者访问栈中离栈顶更远的另一个值。沿用刚刚的方法，就需要从栈中弹出所有的中间值然后将这些值再压入栈中，这样做即使在最好的情况下也很容易出问题，而在最坏的情况下是不可能实现的操作。如图3-28所示，在内存中，压入栈中的每个值都与RSP寄存器有一定的偏移量，因此我们可以使用[rsp±offset]寻址模式直接访问我们感兴趣的值。在前面的示例中，可以使用以下单个指令重新加载RAX的原始值到RAX中：

mov rax，[rsp+8]

此代码将从内存地址rsp+8开始的8字节数据值复制到RAX寄存器中，这个值恰好是之前压入栈中的RAX值。可以使用相同的方法访问压入栈中的其他数据值。

注意： 需要牢记的是，每次往栈中压入或从栈中弹出数据时，RSP与栈中值之间的偏移量都会发生变化。滥用此功能会创建难以修改的代码。如果在整个代码中使用此功能，则在首次将数据压入到栈中的位置，以及决定使用[rsp+offset]内存寻址模式再次访问该数据的位置之间，想要压入和弹出其他数据项将变得非常困难。

上一节讨论了通过向RSP寄存器添加常量，从栈中移除数据的方法。以下伪代码实现的示例可能更加安全：

push rax

push rbx

代码序列，将计算结果值保存到RAX和RBX中

If（ 执行了计算 ）then

使用新的RAX/RBX值覆盖栈中保存的值

（ 这样后续的pop操作指令就不会更改RAX/RBX中的值 ）。

mov[rsp+8]，rax

mov[rsp]，rbx

endif；

pop rbx

pop rax

上述代码序列的计算结果存储在栈的顶部。稍后，当程序从栈中弹出这些计算值后，会将这些值加载到RAX和RBX中。

3.14 微软 ABI 注释

在本章讨论的功能中，唯一影响微软ABI功能的是数据对齐。作为一条通用的规则，微软ABI要求所有数据在该数据对象的自然边界（natural boundary）上对齐。自然边界是对象大小的倍数（最多16字节）地址。因此，如果用户打算将word/sword、dword/sdword或qword/sqword值传递给C++程序，则应尝试将对象分别对齐到2、4或8字节的边界上。

当调用由遵循微软ABI规范的语言编写的代码时，在发出一条call（调用）指令之前，必须确保栈在16字节边界上对齐。这会严重限制push和pop指令的实用性。如果在发出一条调用指令之前使用push指令保存寄存器的值，则必须确保在调用之前压入两个（64位）值，或者确保RSP地址是16字节的倍数。第5章将更详细地探讨这个问题。

3.15 拓展阅读资料

在作者另一本较旧的16位版本的教程《汇编语言的编程艺术》（可以从https://artofasm.randallhyde.com/获取）中，可以找到有关8086的16位寻址模式和段的信息。该书的出版版本（No Starch出版社，2010年）涵盖了32位寻址模式。当然，英特尔x86文档（http://www.intel.com/）提供了有关x86-64寻址模式和机器指令编码的完整信息。