计算机是怎么长出来的
总目录/ 第 1 部/ 1.3 CPU/ 1.3.1

1.3.1 指令与机器码:0xB8 0x01 到底是什么意思

约 1.2 万字 · 6 张图 · 读完你能说清一条指令由哪几段拼起来、 看懂反汇编器吐出来的那几列字节、并且明白 「机器只认识几十条命令」这句话里的「几十条」到底是多少

把 0xB8 0x01 0x00 0x00 0x00 这五个字节喂给一颗 x86 处理器, 它会把数字 1 放进一个叫 EAX 的寄存器里。 没有第六个字节的解释,没有「这五个字节是一个整体的意思」的额外说明—— 它就是这五个字节。五个字节里只有第 2 个是你真正想要的那个 1, 其余四个是「怎么做」的记账。 这一节把这笔账算清楚:指令是怎么被拆成字节的、字节又是怎么被机器读回来的、 为什么有的机器每条指令都占 4 个字节而 x86 的指令可以从 1 个字节长到 15 个字节。

本节的小部分

  1. 1 一条指令的三副面孔
  2. 2 指令的解剖:从 B8 到十个字段
  3. 3 定长与变长:两条技术路线的分岔
  4. 4 指令只会做五件事
  5. 5 寻址方式:操作数从哪来
  6. 6 寄存器:CPU 手里那十几张便签
  7. 7 汇编器与反汇编器:两趟扫描与猜出来的边界
  8. 8 字节序:小端为什么赢了
  9. 9 标志位与条件跳转:比较不需要单独的比较器
  10. 10 一条指令走完的一生
  11. 11 指令集架构的五代:从累加器到 load-store
  12. 12 把一段 C 拆到字节

1.3.1-1一条指令的三副面孔

先看三种写法,它们说的是同一件事:

C 语言:    a = 1;
汇编:      mov eax, 1
机器码:    B8 01 00 00 00

第一行是人想表达什么。第二行是人写给汇编器看的, 用助记符(mnemonic)mov 代替了一个数字。 第三行是机器真正吃的——一串写在内存里的字节, 通常还带着一个「它从哪个地址开始」的信息。

三者不是三种不同的东西,而是同一段含义的三层包装。 C 编译器把第一行变成第二行(还会顺手优化掉很多), 汇编器把第二行变成第三行。反过来的路也能走: 反汇编器把第三行变回第二行,但它永远变不回第一行—— 变量名、类型、注释、循环结构,全在编译的那一步被抹掉了。 这就是为什么「反编译」出来的代码永远比源码难看。

现在盯住第三行。五个字节,为什么不是一个? 因为 1 要放进 EAX,而 EAX 是一个 32 位的盒子。 你如果想往里放一个任意大的数,就得给足 32 位,也就是 4 个字节。 4 个字节再加上前面那个说明「往哪放、怎么放」的字节,正好五个。

那个 B8 是整条指令的动词。 在 x86 的词汇表里,B8 的意思是「把一个 32 位立即数装进 EAX」。 注意它把两件事捆在了一起:动作是「装立即数」,目标是「EAX」。 换一个目标寄存器,动词就换一个编号:

B8 01 00 00 00     mov eax, 1
B9 01 00 00 00     mov ecx, 1
BA 01 00 00 00     mov edx, 1
BB 01 00 00 00     mov ebx, 1
BC 01 00 00 00     mov esp, 1
BD 01 00 00 00     mov ebp, 1
BE 01 00 00 00     mov esi, 1
BF 01 00 00 00     mov edi, 1

从 B8 到 BF 连续八个编号,正好是八个通用寄存器。 看出规律了吗:这八个数的低三位是 000 到 111, 而 000 到 111 正好能编码八个东西。 寄存器号被塞进了操作码的低三位。 这是 x86 编码里最省事的一种做法,代价是「装立即数」这个动作只能占 8 个编号, 想要第 9 个寄存器(x86-64 里的 r8)就塞不进去了——这个坑后面 §2 会讲怎么绕。

再看那个 01 00 00 00。它为什么不是 00 00 00 01? 因为 x86 把低位字节放在低地址。这四个字节从地址 0x1000 开始排, 内存里看到的是:

地址    0x1000  0x1001  0x1002  0x1003
内容      01      00      00      00
              ↑
        最低有效字节在这里

这叫小端(little-endian)。它是历史选择的结果, 不是数学上的必然,而且它带来的麻烦比很多人想的多——§8 专门讲。 现在只需要记住:你在反汇编输出里看到的那串字节, 顺序就是内存里的顺序,而不是你写数字时的顺序。

「指令」到底是什么。 严格说,一条指令是「CPU 能识别并执行的最小动作单元」。 它不是「一行汇编」,因为一行汇编可能被汇编器展开成几条机器指令 (比如 x86 的 mov eax, 0x123456789 会被拆成 mov eax, 0x23456789 加 mov eax, 0x1 两条); 它也不是「一次内存访问」,因为一条指令可能访问两次内存。 它的边界由 CPU 的解码器定义,不由人的书写习惯定义。

1.3.1-2指令的解剖:从 B8 到十个字段

B8 那条指令太简单,简单到看不出结构。换三条真实的、由 GCC 编出来的指令看看。 下面这段是某个函数被编译后的开头(x86-64,System V 调用约定):

55                    push   rbp
48 89 e5              mov    rbp, rsp
89 7d fc              mov    DWORD PTR [rbp-0x4], edi
8b 45 fc              mov    eax, DWORD PTR [rbp-0x4]
e8 1a 00 00 00        call   401130 <helper>
c3                    ret

左边一列是字节,中间是反汇编器还原出的汇编,右边是注释。 请把注意力放在字节那一列:长度分别是 1、3、3、3、5、1。 同一个程序里,指令长度差五倍。这就是变长指令。

x86 的一条指令最多可以分成下面这些段,按出现顺序排列:

段长度作用例子
指令前缀0~4 字节改这一次操作的行为:重复、锁、段覆盖、操作数宽度F3 重复 F0 加锁 66 改用 16 位
REX 前缀0~1 字节64 位扩展:加宽到 64 位、访问 r8~r1548 表示 64 位操作
操作码1~3 字节动词:干什么B8 89 E8 0F B6
ModRM0~1 字节两个操作数各在哪:寄存器还是内存、怎么算地址45 C3
SIB0~1 字节变址寻址的比例、索引寄存器、基址寄存器44 3F
位移0/1/2/4 字节地址里的那个常数偏移FC(即 −4)
立即数0/1/2/4/8 字节指令里直接带的那个值01 00 00 00
三条 x86 指令的逐字节解剖:操作码、ModRM、位移、立即数各占哪几个字节
图 1.3.1-1 三条真实指令的字节解剖。上面一条是最简单的 B8:一个动词加四个字节的值。中间一条 89 7D FC 只有三个字节,却表达了「把 EDI 写到 RBP 减 4 那个地址」这么复杂的意思——它的信息被压进了 ModRM 那一个字节的八个比特里(2 位模式、3 位寄存器、3 位基址)。下面一条 E8 是调用,后面四个字节不是地址而是相对当前指令末尾的偏移,所以整段代码搬到内存任何位置都不用改。

挑中间那条 89 7D FC 拆一下,因为它最能说明问题。

89 是操作码,意思是「把寄存器写到内存/寄存器」。它自己不知道是哪个寄存器, 也不知道写到哪,这些信息全在下一个字节里。

7D 是 ModRM,八位拆成三段:高两位 01 是「模式」, 中间三位 111 是「寄存器」,低三位 101 是「基址/目标」。 模式 01 的意思是「后面还有一个 1 字节的位移」; 寄存器 111 是 EDI;基址 101 在这个模式下是 RBP。 于是这条指令的含义已经被完全确定了: 把 EDI 写到「RBP 加上那个 1 字节位移」指向的地址。

最后一个字节 FC 就是这个位移。它是有符号的 8 位数, FC 按补码读是 −4。所以完整含义是 mov [rbp-4], edi。 三个字节,装下了一个「源寄存器 + 基址寄存器 + 偏移量 + 数据宽度」的四元组。

这就是变长编码的思路:常用的情况用最短的编码,罕见的情况才加长。 RBP 减 4 这种「访问一个局部变量」的操作在真实程序里出现的频率极高, 所以它被压到了三个字节。而访问一个绝对地址(比如全局变量)就要多几个字节, 因为它得带上完整的 32 位地址。

为什么 x86 的指令最长只能 15 字节。 这条限制是 AMD 在 2000 年设计 x86-64 时正式写进手册的: 一条指令(含所有前缀)不得超过 15 字节,超过就触发非法指令异常。 为什么要定这个上限?因为前缀可以无限重复(66 66 66 66…), 理论上一条指令可以无限长。硬件需要一个有限的缓冲区去装它, 所以必须有一刀切在哪里。15 这个数字不是美学选择,是「预留得足够宽松, 又不至于让解码器的移位寄存器太贵」的折中。

还有一件事值得注意:操作码不止一个字节。 0F 是一个「逃逸字节」(escape),它的意思是 「这一个字节不是操作码,真正的操作码在下一个字节」。 这个设计是 80386 时代加的,因为 8086 留的一字节操作码空间用光了。 后来 SSE 指令又不够用,于是有了 0F 38、0F 3A 两级逃逸, 操作码变成三字节。你在反汇编输出里看到的 0f b6 c0(movzx eax, al), 开头的 0f 就是这个逃逸。

1.3.1-3定长与变长:两条技术路线的分岔

现在把 x86 放在一边,看看 ARM 怎么做同一件事。

ARM64:   mov  w0, #1        编码为   20 00 80 52
          add  w0, w1, w2    编码为   20 00 02 0b
          ret                编码为   c0 03 5f d6

每一条都是四个字节,一条不多一条不少。 这意味着两件在 x86 上做不到的事:解码器可以每四个字节切一刀, 八条指令可以同时切、同时译;程序跳转到任何一条指令都是对齐的,不用先算长度。

代价是代码变长。mov w0, #1 在 x86 上如果目标是 AL, 只需要两个字节(B0 01);ARM64 一律四个字节。 一个大量使用小立即数、短跳转、简单寄存器的程序, ARM64 编译出来的代码体积通常比 x86-64 大 20%~30%。 这不是小事:代码体积大意味着指令缓存更容易装不下, 而指令缓存未命中的代价是几十个周期。

所以 ARM 也做了妥协:Thumb。 一套 16 位的短指令编码,只能访问 8 个寄存器、立即数范围也小, 但体积能省三到四成。后来 Thumb-2 允许 16 位和 32 位混排, 于是 ARM 在 32 位时代也变成了「变长」—— 只不过它的变长规则简单得多,看第一个 16 位字的最高几位就知道该读 2 字节还是 4 字节。

定长与变长指令流的对比:x86 字节边界不规则,ARM64 每四字节一格
图 1.3.1-2 同一段逻辑在两种编码下的字节流。上面是 x86:指令边界参差不齐,解码器必须先扫出长度,才能知道下一条从哪开始,所以它只能顺序地、一条一条地切。下面是 ARM64:四字节一格,切分位置天生已知,可以一次切四格并行译码。左边那一列灰色的小格子是「浪费掉的空间」——ARM 为了定长付出的体积代价;上面那些窄条是 x86 用不规则换来的密度。

RISC-V 走的是第三条路:基础指令集 32 位定长, 但预留了「低两位不为 11 就是 16 位短指令」的规则, 于是它天然支持变长,而且长度判断只看最低两位,不需要像 x86 那样扫前缀。 这是 2010 年代设计的后发优势:能看到前两家各自踩过的坑。

三条路线各有各的账,可以列成一张表:

架构编码长度解码难度代码密度它的理由
x86 / x86-641~15 字节高:要扫前缀、算长度最好1978 年内存按 KB 计价,省字节就是省钱;之后为了兼容只能加不能改
ARM64(A64)固定 4 字节低:按格切较差2000 年代以后内存不再稀缺,解码带宽和功耗变成主要矛盾
ARM Thumb-22 或 4 字节中:看第一个半字较好微控制器上 Flash 容量直接等于成本
RISC-V2 或 4 字节起,可扩低:看最低两位好既要密度又要简单解码,用「长度编码进低两位」同时满足

这里有一个很容易被讲错的地方,得说清楚: 变长不等于落后,定长也不等于先进。 现代 x86 处理器内部根本不按 x86 的方式执行。 它把每一条 x86 指令译成一到几个定长的微操作(micro-op,简称 μop), 后端按 μop 调度。也就是说,在硬件实现层, x86 早就是一台 RISC 机器了,变长的那一层只是一件外壳。 外壳的作用是兼容——让 1978 年的程序还能在 2026 年的芯片上跑。

这件外壳不便宜。它占了 x86 芯片里相当大的一块面积和功耗, 而且解码带宽长期是瓶颈:Intel 的前端每周期能取 16 字节, 但遇到一堆前缀或长指令,实际能译出的指令数会掉下来。 这就是为什么同一代工艺下,x86 的每瓦性能往往不如 ARM—— 它有一部分电,花在了「读懂自己」上。

1.3.1-4指令只会做五件事

「一台只认识几十条命令的机器」这句话,容易被误解成「CPU 很笨」。 反过来才对:CPU 的词汇极少,但它能靠组合做出无限的事。 这就像音乐——十二个音,写尽了三百年的曲子。

把 x86-64 的一千多条指令(加上各种前缀和变体,实际编码数量更多) 按做的事分类,只有五类:

类别典型指令它把什么搬到哪里
数据搬移mov movzx movsx lea push pop xchg寄存器↔寄存器、寄存器↔内存、内存↔内存(仅字符串指令)
算术与逻辑add sub imul idiv and or xor not shl shr sar在寄存器内部做运算,结果留在寄存器里
控制流jmp jcc call ret loop改 PC 的值,也就是「下一步去哪」
内存访问(独立成类)ARM 的 ldr str ldp stp只有这一类指令能碰内存;x86 把它并进了 mov
系统与杂项syscall int hlt cpuid rdtsc mfence cli和 CPU 之外的世界打交道:进内核、停住、读时间戳、保证内存顺序

这张表里没有「打印」,没有「排序」,没有「打开文件」,没有「发一个网络包」。 这些事在机器码层面都不存在。它们要么是一长串 mov / cmp / jcc 的组合, 要么是一条 syscall——把活交给操作系统。

这也是理解「程序」的一个关键转折点: 你在屏幕上看到的一切,最终都是一串「搬数据、算一下、判断、跳走」。 一个 for 循环在机器码里就是「加一、比较、条件跳回」三条指令, 重复执行到你满足条件为止。没有任何一条指令叫「循环」。

五类里最容易被低估的是控制流。 没有它,CPU 只能从头到尾一条条执行,那就是一台计算器而不是计算机。 加了跳转,才有了「如果」「循环」「函数」这三个概念的物理基础。 而跳转的代价是:机器不知道下一步要跳到哪, 于是它没法提前把下一步的指令拿过来——这是后面 1.3.4 讲分支预测的起点。

指令数量到底是多少。 说「几十条」是教学简化。真实的 x86-64 指令数量没有官方权威数字, 按助记符数大约一千多条;但按「有实际使用的编码」统计, 一个典型的 C 程序编出来只会用到八十到一百二十种。 编译器、操作系统内核用得多一些,也就两百种上下。 换句话说:CPU 认识一千个词,日常说话只用一百个。 这也是为什么指令集可以做得那么畸形却还能用——常用的那一百个被优化得很好。

1.3.1-5寻址方式:操作数从哪来

一条指令要说清两件事:做什么(操作码),对谁做(操作数)。 操作数可以是三种东西:指令里带着的值、 寄存器里的值、内存里某个地址的值。 第三种最麻烦,因为「某个地址」本身又可能是算出来的。

用图书馆打个比方。你要一本书,可以这样告诉管理员:

寻址方式图书馆里的说法x86 写法用在哪
立即数「就这本,我手上这本」mov eax, 42常数、掩码
寄存器「我桌上那张便签写的编号」mov eax, ebx临时变量
直接「三楼 302 架」mov eax, [0x404000]全局变量、静态数据
寄存器间接「便签上那个编号对应的架子」mov eax, [rbx]指针解引用
基址 + 偏移「便签编号加三格」mov eax, [rbp-8]局部变量、结构体成员
基址 + 变址×比例 + 偏移「便签编号,隔两格取第 i 本」mov eax, [rbx+rcx*4+8]数组、结构体数组
PC 相对「从我站的这格往前数 16 格」mov eax, [rip+0x2a4c]全局变量(PIE)、跳转
七种寻址方式示意:立即数、寄存器、直接、间接、基址偏移、变址、PC 相对
图 1.3.1-3 同一个「取一个数」的动作,七种找法。每一格里左边是 CPU 手上的东西,右边是内存里的东西,箭头表示「这一次要读哪」。前两格根本不碰内存;第三格地址直接写在指令里;第四到第六格地址是算出来的,只是算法越来越复杂;最后一格的地址是「当前指令的位置」加上一个偏移——这条设计让程序可以整体搬到内存任何地方,是动态链接和地址随机化的基础。

为什么需要这么多种?因为程序里访问的东西正好分这几类。 数组要「基址 + 下标 × 元素大小」,结构体要「基址 + 成员偏移」, 局部变量要「栈帧基址 − 偏移」,全局变量要「一个固定位置」。 如果只有一种寻址方式,那每种访问都得先用几条 add 算出地址再读——慢且费指令。 硬件直接用一条指令做完整地址计算,是把复杂度压进编码的典型手法。

x86 的变址寻址里有一个细节很能说明「编码是按需求设计的」: 比例因子只能取 1、2、4、8。为什么正好是这四个? 因为 C 语言里 char 是 1 字节、short 是 2、 int 是 4、double 是 8。 这四个数字就是「数组元素大小」的全部可能。 这个字段在 SIB 字节里占两位,一位都不多。

还有一个历史包袱必须提:段寄存器。 8086 的地址总线是 20 位,但寄存器只有 16 位,装不下一个完整地址。 Intel 的解法是用两个 16 位数拼:段:偏移, 实际地址等于段值乘 16 再加偏移。于是内存被切成一个个 64KB 的段, 每个段有一个段寄存器(CS 代码段、DS 数据段、SS 栈段、ES 附加段)。 这在 1978 年是聪明的省钱办法,到 32 位时代就变成了纯粹的负担: 平坦内存模型下所有段基址都是 0,段寄存器只剩下 FS、 GS 还有用——它们是线程局部存储(TLS)的实现方式。 你在 Linux 上调试多线程程序,看到 fs:0x28 这样的地址, 那就是段寄存器最后的一点残余用途:栈保护金丝雀。

1.3.1-6寄存器:CPU 手里那十几张便签

为什么不能把变量全放在内存里?因为距离。 从寄存器取一个数,是「零周期」——它就在执行单元旁边, 指令译码的时候值已经到了。从 L1 缓存取,大约 4 个周期; 从内存取,现代机器上是 200 到 300 个周期。 同一个动作,差了两个数量级。

所以 CPU 手里有一小把寄存器,用来放「此刻正在算的东西」。 x86-64 有 16 个通用寄存器,名字是这样的:

64 位32 位16 位8 位高/低名字的来历今天的常规用途
raxeaxaxah/alaccumulator,累加器返回值、乘除法隐含操作数
rbxebxbxbh/blbase,基址被调用者保存的临时变量
rcxecxcxch/clcounter,计数器循环计数、移位量
rdxedxdxdh/dldata,数据乘除法高位、第三个参数
rsiesisi—source index,源变址第二个参数、字符串源
rdiedidi—destination index,目的变址第一个参数、字符串目的
rspespsp—stack pointer,栈指针永远指向栈顶,不能挪作他用
rbpebpbp—base pointer,帧指针指向当前栈帧底部
r8~r15r8d~r15dr8w~r15wr8b~r15b没有名字,就是编号x86-64 新增的八个
x86 与 ARM64 寄存器命名对比:x86 有重叠的历史名字,ARM64 是平铺的 31 个
图 1.3.1-4 两套命名哲学。左边是 x86:rax 这一根柱子里嵌着 eax、ax、ah、al 四层,它们是同一块物理存储的不同切片,写 al 不改其他位,写 eax 会把高 32 位清零——这种重叠写法带来了几十年的「部分寄存器停顿」问题。右边是 ARM64:x0 到 x30 平铺,w0 就是 x0 的低 32 位,写 w0 自动清零高半截,没有中间态,也没有 ah/al 这种半截名字。

这张表里藏着一个完整的计算机史。 ax、bx、cx、dx 的全名分别是累加器、基址、计数、数据—— 这些不是随便起的,是 1970 年代每条指令都专用一个寄存器时的分工。 8086 把这些专用寄存器做成了「半通用」的, 于是名字留下来了,专用性却没了。到今天, 你在编译器输出里看到的 rax 大多数时候就是一个普通临时变量, 和「累加」没有半点关系。

更要命的是 ah/al 这种拆分。 8080 是 8 位机器,只有一个 8 位累加器 A。 8086 要兼容它,就把 16 位的 AX 拆成高 8 位和低 8 位,分别叫 AH 和 AL, 这样 8080 的代码可以一字不改地跑。兼容性带来的代价延续了四十年: 写 al 之后读 eax,硬件必须等两个写口合并, 这个等待在老处理器上叫「部分寄存器停顿」,能白白损失几个周期。 现代处理器用寄存器重命名缓解了这个问题,但编码上的怪相保留至今。

ARM64 是 2011 年重新设计的,没有这个包袱: x0 到 x30 三十一个通用寄存器,加一个栈指针 sp, 加一个恒为零的 xzr。 写 w0 就是写 x0 的低 32 位并清零高 32 位, 语义干净,硬件也好做。 这就是「后发优势」在指令集设计上的具体样子: 不是更聪明,只是不用背历史。

寄存器数量为什么是 16 或 31,而不是 1000?因为编码空间。 x86 用 3 个比特表示寄存器,只能有 8 个;x86-64 加了一个 REX 前缀位,扩到 16 个。 ARM64 用 5 个比特,32 个(其中一个留给零寄存器)。 想要更多寄存器,就得在每条指令里多留几位,指令就变长,代码就变大。 寄存器数量和代码密度是一笔此消彼长的交易。

架构寄存器与物理寄存器不是一回事。 你在汇编里看到的 16 个寄存器叫「架构寄存器」, 是 ISA 规定的、程序能看见的。芯片内部实际有 180 个以上的「物理寄存器」。 执行时,硬件把架构寄存器动态映射到空闲的物理寄存器上(寄存器重命名), 于是 mov eax, 1 之后再 mov eax, 2 不需要等前一条写完—— 它俩被分到了不同的物理寄存器。 架构上只有 16 个,是为了编码省字节;物理上有 180 个,是为了并行。 这两件事被刻意分开了。

除了通用寄存器,还有几类必须知道: rip(指令指针,指向下一条要执行的指令)、 rflags(标志寄存器,下一节讲)、 ARM64 的 nzcv(四位条件标志)、 以及一堆控制寄存器(页表基址 cr3、调试寄存器、性能计数器)。 它们不在通用编码空间里,只能用专门的指令读写。

一个实操上的观察:如果你用调试器看过程序崩溃时的寄存器快照, 会发现 rip 指向的那条指令往往不是「出错的那条」, 而是它后面几条。原因是现代处理器乱序执行, rip 反映的是「最后退休的那条」,不是「正在执行的那条」。 这是 1.3.4 的话题,先记着。

1.3.1-7汇编器与反汇编器:两趟扫描与猜出来的边界

最早的程序是手写机器码的。1949 年 EDSAC 上跑第一段程序时, 操作员把一长串十进制数打在纸带上,每个数字是一位「初始指令」—— 那套「初始指令」本身也是一段程序,作用是读纸带、把后面的数字装进内存。 连「装载器」都得靠手写数字来实现。

汇编器的出现就是为了终结这件事。它做的事情简单到可以用一句话说清: 查表替换,加上地址回填。 查表:把 mov 换成 B8,把 add 换成 03,以此类推。 回填:把 jmp loop 里的 loop 换成真实的地址偏移。

回填为什么需要两趟?因为程序里常有「往前跳」:

start:
    cmp  eax, 0
    je   done        ; done 在下面,此刻还不知道它在哪
    ...
done:
    ret

汇编器读到 je done 的时候,done 还没出现。 它只能先留一个空位(占 4 个字节),记下「这里要填 done 的地址」, 等整段扫完、所有标号的位置都知道了,再回头把空位填上。 这就是两趟扫描(two-pass assembler)。

第一次扫描收集标号,第二次扫描生成字节并回填。 这个模式一直用到今天:现代汇编器仍然分两趟, 只不过「回填」这件事被推迟到了链接阶段—— 如果是跨文件的符号(比如调用另一个 .c 里的函数), 汇编器根本不知道地址,只能在目标文件里留一条重定位记录, 让链接器最后去填。

反过来,把机器码变回汇编,叫做反汇编。这条路要难得多, 因为信息丢了。反汇编器看到的只是一串字节, 它必须猜「哪里是一条指令的开头」。

x86 上这个猜测可以猜错。同一串字节, 从偏移 0 开始解是一条指令,从偏移 1 开始解可能是完全另一条指令。 更麻烦的是数据:一个跳转表、一段字符串常量、一段被 .byte 直接写进去的数据,在反汇编器眼里和代码没有区别—— 它会老老实实把它们「翻译」成指令,输出一堆看上去像代码的垃圾。 所以真实的反汇编输出里常能看到莫名其妙的 (bad)、 或者明显不对的 add byte ptr [rax], al(字节 00 00)。

即便解对了边界,丢的东西也补不回来: 变量名变成 [rbp-0x8],函数名变成 sub_401130, 结构体变成「基址加几个偏移」,循环变成「往回跳的 jmp」, 内联过的函数根本不存在。加上 -O2 之后, 你写的东西和机器执行的东西已经不是一对一的关系。 这就是为什么逆向工程是件苦活:不是难在读懂指令,是难在重建结构。

为什么反汇编输出里跳转目标写成 401130 <helper>。 因为 call 编码里存的是相对偏移,不是绝对地址。 反汇编器先算出「当前指令末尾 + 偏移」得到目标地址, 再查一遍符号表,把地址翻译成名字。 如果那个地址不在符号表里,就只能显示裸地址 401130。 符号表是链接时留下的副产品,strip 掉之后就再也找不回来了。

1.3.1-8字节序:小端为什么赢了

一个 32 位整数在内存里占四个字节。这四个字节按什么顺序排, 是计算机史上最无谓、也最纠缠的一场争论。

取 0x12345678,从地址 0x1000 开始放:

            0x1000  0x1001  0x1002  0x1003
大端(BE)    12      34      56      78      ← 高位在前,读起来像写出来的样子
小端(LE)    78      56      34      12      ← 低位在前,和书写顺序相反
同一个数在大端与小端内存中的排布,以及读取前两个字节得到的不同结果
图 1.3.1-5 同一个 32 位数,两种排法,以及由此产生的实际后果。上面一行是大端:从低地址往高地址读,正好是书写顺序,人看着舒服。下面一行是小端:低位在低地址。最下面的两行是关键——如果你把这四个字节的前两个按 16 位去读,大端得到 0x1234,小端得到 0x5678。同一个内存内容,读法不同,答案完全不同,这就是所有字节序 bug 的根源。

大端的优点是直觉:内存dump 出来,从左往右读就是数字本身, 调试的时候一眼能认。网络协议因此选了大端, 并且把它命名为「网络字节序」——TCP/IP 头里的端口号、序号、长度, 全是高位在前。你在写 socket 程序时调用的 htons、htonl, 就是在做「主机序 → 网络序」的转换。

小端的优点不那么直观,但它是性能上的: 从低位开始算,加法可以从第一个字节就开始进位。 这在只有 8 位 ALU 的年代是实打实的收益—— 做一次 32 位加法,四个字节从低到高依次加,进位顺着地址往上走, 指针也顺着往上走,一次循环搞定。 反过来如果高位在低地址,就得倒着遍历,指针递减,多花指令。 6502 的间接变址寻址把这个优势放大到了极致,而 6502 又影响了 8086, 8086 影响了整个 x86 家族——于是今天全世界大多数电脑是小端。

这场争论本来在 1980 年代就该结束。IEEE 754 浮点标准、 TCP/IP、POSIX 都选了各自的一边,然后大家学会了「在边界处转换」。 但边界总是有漏的,于是坑一直存在:

场景踩的是什么典型症状
读二进制文件文件格式规定了字节序,程序没转读出来的数大得离谱或小得离谱,正好是字节倒过来
解析网络包协议是大端,直接 memcpy 到结构体端口号变成 0x1F90 这种奇怪的数
位图与图片格式BMP 小端、PNG 大端、JPEG 大端宽高读成几十万,程序申请内存失败
UTF-16 文本没有 BOM 就不知道是 LE 还是 BE中文变乱码,英文看起来正常(因为 ASCII 部分高低字节一个是 0)
跨架构通信一端 x86 一端 PowerPC/网络设备只有多字节字段错,单字节字段全对

判断一台机器的字节序,最省事的办法不是查资料,是让机器自己说: Python 里 sys.byteorder 直接返回 'little' 或 'big'; C 里用一个 union { uint32_t i; uint8_t c[4]; } 写进去再逐个字节读; 命令行上 lscpu 的 Byte Order 一行也写着。

还有一个反直觉的点:字节序只影响「多字节数据在内存里的排布」, 不影响寄存器的值。你把 0x12345678 装进 eax,无论大小端机器, eax 里都是 0x12345678。差别只在你把它写进内存、或者从内存读出来的时候。 所以字节序问题永远出现在跨越「内存表示」这个边界的地方: 文件、网络、共享内存、指针强转。

1.3.1-9标志位与条件跳转:比较不需要单独的比较器

到这里,机器能搬数、能算数、能跳转。但它还不会「判断」。 if (a < b) 在硬件上是怎么实现的?

答案有点出人意料:没有比较器。 实现比较用的是减法——1.2.3 里那个加法器,把 b 取反加一,再加 a。 减完的结果不写回任何寄存器,只留下一组标志位。 这条「减了但不存」的指令就是 cmp。

标志位里最关键的是四个:

标志全名什么时候置 1它回答什么问题
ZFZero Flag结果为零两个数相等吗
SFSign Flag结果的最高位是 1(即「看起来是负数」)结果是负的吗
CFCarry Flag无符号运算从最高位进位/借位出去无符号数比大小:a 比 b 小吗
OFOverflow Flag有符号运算溢出(两个同号数相加得到异号结果)这个结果还可信吗
CMP 指令如何设置四个标志位,条件跳转如何读这些标志决定跳不跳
图 1.3.1-6 一次判断的完整链路。左边 cmp 走的是加法器,算 a + (~b) + 1,结果扔掉,只把四个标志位写进标志寄存器。中间那八位就是 rflags 的低半截,ZF、SF、CF、OF 各占一位。右边每一条 jcc 都是「读某一位(或某两位的组合),据此决定要不要改 rip」——所以条件跳转本身不做任何计算,它只是看别人算好的结论。

为什么需要 CF 和 OF 两个「进位」标志?因为同一个位模式有两种解释。 看这个例子:a = 0xFFFFFFFF,b = 1,做 a - b:

把 a 和 b 都看成无符号数:  4294967295 - 1 = 4294967294,正常,CF = 0
把 a 和 b 都看成有符号数:  -1 - 1 = -2,正常,OF = 0

再换一组:a = 0x80000000(有符号是 −2147483648),b = 1:

无符号看:  2147483648 - 1 = 2147483647,正常,CF = 0
有符号看:  -2147483648 - 1 = -2147483649,超出 32 位范围,OF = 1

同样一条 sub,同一组标志位,两种解释下「是否出问题」的答案不同。 所以硬件干脆两个都算、两个都存, 由后面的跳转指令自己决定看哪一个。

于是同一句 if (a < b),编译出来有两种可能:

cmp  eax, ebx
jl   less          ; 有符号比较:SF ≠ OF 就跳(jump if less)
; 或者
cmp  eax, ebx
jb   less          ; 无符号比较:CF = 1 就跳(jump if below)

选哪一个,取决于 C 里 a 和 b 的类型。这就是为什么 在 C 里混用有符号和无符号整数会出 bug: 编译器按语言规则选了 jb,而你以为它在按 jl 比。 经典例子:

// 这段代码在任何平台上都是死循环
for (unsigned i = n; i >= 0; i--) { ... }

因为 i 是无符号的,i >= 0 永远成立, 编译器把它优化成「无条件跳回」。而且它不会警告你—— 在它的语义模型里,这段代码就是「一直循环」,完全正确。

完整的条件跳转表没必要背,但值得知道它分成两组, 每组的名字带着明显的方向感。有符号那一组看 SF、OF、ZF, 无符号那一组看 CF、ZF:

有符号含义无符号含义
je / jz相等je / jz相等(两条一样的)
jne / jnz不等jne / jnz不等
jl小于(less)jb低于(below)
jle小于等于jbe低于等于
jg大于(greater)ja高于(above)
jge大于等于jae高于等于

l/g 是 less/greater,b/a 是 below/above。 用两套词不是啰嗦,是提醒:它们回答的是两个不同的问题。

标志位还有一个副作用值得知道:它们会被后面的指令覆盖。 所以编译器在两条判断之间插指令时非常小心, 尽量把「比较」和「跳转」放在相邻位置。 这种「标志位是一种隐式的、全局的中间结果」的设计, 在 RISC 架构里被认为是个缺陷——ARM 就把「要不要更新标志」 做成了指令里的一个可选位(早期的 S 后缀,ARM64 里是 adds/subs 这种写法), 而不是每条指令都无条件覆盖。

多字节加法靠 CF 串起来。 64 位机器算 128 位加法,用的还是同一个加法器: 低 64 位用 add,高位用 adc(add with carry)。 adc 会把上一次的 CF 加进去。 于是「进位」这个 1.2.3 里讲过的信号,在指令层面变成了一个可以跨指令传递的状态。 硬件的进位链只连一个字的宽度,跨字的进位靠软件用标志位接力。

1.3.1-10一条指令走完的一生

现在把一条指令从生到死走一遍,作为下一节的引子。 无论什么架构,过程都是五步:

1. 取指   rip 指向的地址 → 指令缓存 → 取出若干字节
2. 译码   字节 → 这条指令要干什么、操作数在哪
3. 执行   算术逻辑单元(ALU)做运算,或算出内存地址
4. 访存   如果操作数在内存,这一拍去读或写
5. 写回   结果写进目标寄存器,标志位更新

在老式机器上,这五步是一条一条串着走的: 一条指令走完五个时钟,下一条才开始。 8086 就是这种结构,一条指令要 4 到 20 个时钟周期。 所以 8086 跑 5 MHz,实际每秒只能执行几十万条指令。

现代处理器不这么干。它把五步拆成五级流水线, 每个时钟都有一条指令在取指、另一条在译码、另一条在执行。 理想情况下,每个时钟就有一条指令完成。 4 GHz 的处理器,每秒四十亿条——这个数量级就是这么来的。

这里有个概念必须分清:指令周期和时钟周期不是一回事。 时钟周期是硬件的节拍(1/4 GHz = 0.25 纳秒); 指令周期是「一条指令从进流水线到退休」经过的拍数,现代机器上是十几个到几十个。 衡量性能的指标叫 IPC(instructions per cycle,每周期指令数), 现代高性能核心能做到 4 到 6;而流水线拉长会降低 IPC, 但能提高主频,两者的乘积才是实际性能。

x86 在这五步之外还多了一层:微码。 简单指令(mov、add、jmp)由硬件直接译成 μop, 但复杂指令(cpuid、rep movsb、老的字符串操作、 甚至一些寻址方式组合)会被译成一小段「存在芯片内部的程序」, 由它展开成一串 μop。这段内部程序就是微码。

微码的存在解释了很多现象: 为什么有些指令慢得离谱(要跑几十上百个周期)、 为什么 CPU 厂商能通过「更新微码」修 bug(2018 年熔断漏洞的缓解措施就是微码更新)、 为什么 1997 年 Pentium 的 F00F bug 能让机器死机—— 那条非法指令的微码进入了一个死循环,取指单元被锁住, 连「处理异常」的代码都取不出来。

反过来说,ARM 这类 RISC 架构基本没有微码, 每条指令都由固定的组合逻辑直接译出控制信号(硬布线)。 好处是快、省电、可预测;坏处是改不了—— 硬布线一旦流片,任何设计错误都只能靠软件绕过或者重新流片。 微码是一层「可以打补丁的软件」,代价是面积和功耗。

1.3.1-11指令集架构的五代:从累加器到 load-store

如果要给指令集排一个谱系,可以按「操作数住在哪」分成五代。 这个视角比按年代分更有用,因为它解释了为什么不同机器的指令长得不一样。

第一代:累加器机。 EDSAC、6502、8080、8051 都是这样。 机器里只有一个「主角」寄存器,叫累加器(A)。 所有算术都必须经过它:

; 计算 c = a + b(a、b 在内存里)
lda  a        ; 把 a 装进累加器
add  b        ; 累加器 += b
sta  c        ; 累加器存回 c

指令短(一字节操作码 + 一两字节地址),硬件简单(只有一个输入端要管), 但代码长——每算一个数都要来回搬。 这在 1975 年是合理的,因为晶体管比字节贵得多。

第二代:栈机。 操作数放在一个栈上,指令不带地址,默认弹栈顶两个、算完压回去:

; 计算 c = a + b
push a
push b
add        ; 弹出两个,相加,结果压回
pop  c

这种「零地址指令」的代码非常短(add 只有一个字节), 编译器也特别好写——表达式求值天然对应栈操作。 x87 浮点协处理器、Java 字节码、.NET 的 CIL、Forth、PostScript 全是栈机。 JVM 选栈机不是因为它快,而是因为它可移植: 栈机不依赖具体有多少个寄存器,任何平台都能高效模拟; 而且字节码可以被静态验证(栈深度可算),这对下载执行的安全模型至关重要。

代价是慢:每次操作都要读写栈(哪怕栈在寄存器堆里), 而且栈顶的依赖是串行的,很难并行。 这就是为什么 JIT 编译器一定要把字节码再编成寄存器机器码—— 栈机适合传输和验证,不适合执行。

第三代:通用寄存器机。 PDP-11 开了头,x86、VAX 是代表。指令可以直接指定两三个寄存器:

; 计算 c = a + b
mov  eax, [a]
add  eax, [b]
mov  [c], eax

灵活得多,但指令编码复杂(要描述每个操作数在哪), 而且「操作数可以在内存」这一条让指令长度不可控—— 这正是 x86 变长的根源。

第四代:load-store 架构。 ARM、MIPS、RISC-V、PowerPC。 规矩只有一条,但是铁的:只有 load 和 store 能碰内存,其余指令一律只操作寄存器。

; 计算 c = a + b
ldr  w0, [x1]      ; 只有这条碰内存
ldr  w2, [x3]
add  w0, w0, w2    ; 纯寄存器
str  w0, [x4]

这条规矩带来的好处是一连串的:指令定长(因为不用编码「内存操作数」)、 译码简单、流水线规整、每条指令的执行时间可预测(除了访存)。 这是 1980 年代 RISC 运动的核心理念: 把复杂性从硬件推给编译器。

第五代(没有成为主流的那一代):VLIW。 Intel Itanium(安腾)是最大的一次尝试。 思路是「让编译器一次性排好几条并行指令,打包成一条超长指令, 硬件不做调度,照着执行就行」。 听起来很美,实际失败了,原因值得记住: 编译器看不见运行时的信息——缓存有没有命中、 分支会往哪走、内存访问要等多久,这些在编译时都不知道, 所以它没法可靠地把指令排满。硬件做调度虽然贵,但它有实时信息。

把五代放在一起看,会发现一个收敛的趋势: 累加器机(1 个操作数位置)→ 栈机(0 个地址,靠栈)→ 通用寄存器机(2~3 个操作数,可在内存)→ load-store(3 个操作数,只在寄存器)。 寄存器的数量和自由度在增加,内存访问在收窄。 原因不是审美,是速度:内存比寄存器慢两个数量级, 而每一条「操作数在内存」的指令,都意味着一次额外的等待。

至于 x86 为什么明明知道这个道理还不改?因为它不能改。 1978 年定下的编码,是 2026 年所有 Windows 程序、所有游戏、 所有驱动的二进制契约。改一个字,整个软件生态就崩了。 指令集是一种一旦发布就几乎不可撤回的承诺。

1.3.1-12把一段 C 拆到字节

最后做一次完整的练习,把一句 C 追到字节,看看前面这些东西怎么合起来用。

int f(int x) { return x * 2 + 1; }

GCC 用 -O2 编出来是这样(x86-64):

f:
    lea    eax, [rdi+rdi*1+0x1]     ; 8d 44 3f 01
    ret                             ; c3

四个字节,一条指令,加上一个 ret。逐字节拆:

字节是什么拆开看
8d操作码lea(load effective address):算地址但不读内存
44ModRM01 模式(带 1 字节位移)+ 000 目标 EAX + 100 说明「后面跟 SIB」
3fSIB00 比例 ×1 + 111 索引 RDI + 111 基址 RDI
01位移1

合起来的地址是 RDI + RDI × 1 + 1,也就是 2x + 1。 注意 lea 的作用:它本来是「把地址算出来」的指令, 但因为它算完把结果放进寄存器、不去读内存, 所以可以当「三个数的加法器」用——而且不设置标志位、 不占用 ALU 的加法通路。编译器特别喜欢这一招, 大量「乘 2 加常数」「乘 3、5、9」都被它变成一条 lea。

一个自然的疑问:为什么不用 imul?因为 imul 要 3 个周期, 而且只算乘法,还得再来一条 add。 而 lea 走的是地址生成单元(AGU),本来闲着, 一条指令一个周期搞定,还不动标志位。 这是编译器比你更懂硬件的典型例子。

再看一个带函数调用的,把调用约定也串进来。x86-64 System V 的规矩是: 前六个整数参数依次放 rdi、rsi、rdx、rcx、r8、r9, 返回值放 rax,多出来的参数压栈。

int g(int a, int b) { return f(a) + b; }

; 编译结果
g:
    push   rbx                  ; 53
    mov    ebx, esi             ; 89 f3     先把 b 存起来(esi 会被 f 覆盖)
    call   f                    ; e8 xx xx xx xx
    add    eax, ebx             ; 01 d8
    pop    rbx                  ; 5b
    ret                         ; c3

五条指令,四个字节到五个字节不等。 注意 mov ebx, esi:为什么要多这一步? 因为 edi 里已经是 a 了(第一个参数), 但 esi 里的 b 会在 call f 之后被覆盖—— 调用约定允许被调用者随便改 esi(它是「调用者保存」寄存器)。 所以得先把 b 挪到一个「被调用者保存」的寄存器里,也就是 rbx。 这一行汇编,就是「寄存器谁来保护」这条协议的具体代价。

这就是指令层面看到的世界:没有变量、没有函数、没有类型, 只有寄存器编号、内存地址、字节偏移,和一条条按顺序执行的命令。 所有高级语言的抽象,最后都要落到这些东西上。

下一节开始讲这台机器怎么把这些指令一条条执行完: 取指单元怎么知道下一条在哪、译码器怎么识别 8d 44 3f 01 这种字节、 以及为什么一条指令还没退休的时候,后面的指令可能已经执行完了。

自测:能答上 8 题,这一节就算过了

  1. B8 01 00 00 00 这五个字节里,哪几个字节是「做什么」,哪几个是「对谁做」?
  2. 为什么 x86 的指令最长只能 15 字节?这个上限是谁定的?
  3. ARM64 每条指令都是 4 字节,它为此付出了什么代价?又用什么办法弥补?
  4. 「现代 x86 内部其实是一台 RISC 机器」,这句话指的是什么?
  5. 说出指令能做的五类事,并举一个「不在五类里」的操作,说明它怎么实现。
  6. x86 的变址比例因子为什么只能是 1、2、4、8?
  7. 写 al 之后读 eax,为什么会有一个额外的等待?ARM64 为什么没有这个问题?
  8. 反汇编器为什么可能把数据当成指令?
  9. 同一条 cmp 之后,判断「有符号小于」和「无符号小于」分别看哪个标志位?
  10. 用一句话解释:为什么 for (unsigned i = n; i >= 0; i--) 是死循环。
点开看答案(先自己想,别急着点)
  1. B8 是「做什么」(把 32 位立即数装进 EAX,寄存器号藏在低三位里),后四个字节 01 00 00 00 是「装什么」——按小端读出来是 1。至于「对谁做」,被捆在操作码里了,没有单独的字段。
  2. 因为指令前缀可以无限重复,理论上指令可以无限长。AMD 在定义 x86-64 时规定 15 字节上限,超过就触发非法指令异常,目的是让解码器的缓冲区有个界。
  3. 代价是代码体积比 x86 大 20%~30%,指令缓存压力更大。弥补办法是 Thumb/Thumb-2:16 位短编码与 32 位混排,靠第一个半字的高位判断长度。
  4. 指 x86 解码后会把每条指令译成一到几个定长的微操作(μop),后端按 μop 调度执行,和 RISC 的做法一致。变长编码只是兼容外壳。
  5. 搬移、算术逻辑、控制流、访存、系统。「打印到屏幕」不在其中:它是一条 syscall 把活交给内核,内核再用 mov 往显存或帧缓冲写字节。
  6. 因为这四个数正好是 C 基本类型的大小:char 1、short 2、int 4、double 8。这个字段只有两位,编码 1/2/4/8 刚好用完。
  7. 因为它们共享同一块物理存储,写入 al 只改了低 8 位,硬件读 eax 时要把新低 8 位和旧高 24 位合并,产生依赖等待。ARM64 的 w0 是 x0 的低半截,写 w0 自动清零高半截,不存在「部分更新」。
  8. 因为字节流里没有「这里是代码」的标记。跳转表、字符串常量、内联数据与指令混在一起,反汇编器只能从已知入口顺着解,一旦入口猜错或者数据被当成代码,后面全乱。
  9. 有符号小于看 SF ≠ OF(对应 jl),无符号小于看 CF = 1(对应 jb)。
  10. i 是无符号数,永远大于等于 0,判断条件恒真,编译器直接把它优化成无条件跳回——而且在它的语义里这个优化完全正确。
← 1.3 CPU:目录