写汇编的人迟早会撞上同一堵墙：寄存器那么多，到底哪个该放什么；内存寻址方式一堆，[BX+SI+2]和[BP+DI]到底差在哪；代码看着没错，跑起来却打印一串乱码或者直接死循环。汇编语言这门课，真正卡人的从来不是指令条数，而是寄存器与内存这两套存储体系之间的配合关系。你把这两块理顺了，剩下的指令不过是填空；理不顺，背一百条指令也写不出一个正确的循环。
这篇内容就是把这两块拆开讲透：寄存器各自的分工和命名由来、内存地址是怎么被"拼"出来的、寻址表达式的组合规则、数据在内存里的真实排布（字节序、对齐、栈的生长方向），以及几段可以亲手跑起来验证的代码。适合刚接触汇编、被寻址方式绕晕的同学，也适合学过一遍但只会照着抄例程、一改就出错的读者。下面这些内容基于 8086/16 位实模式的经典模型展开，因为它把寄存器与内存的关系暴露得最赤裸，理解之后再去看 32/64 位只是量的扩展。
1. 寄存器不是"变量"，而是CPU手边的一摞草稿纸
很多人第一反应是把寄存器当变量用，AX就是一个叫 AX 的变量，BX就是另一个。这个类比能让你上手，但会在后面害你。寄存器更准确的画像是：CPU 内部一小摞固定位置的草稿纸，一共就那么十几张，写上去立刻能读，不用出门去内存里取。内存是仓库，寄存器是手边的工作台。这个区别决定了后面所有的设计取舍。
1.1 通用寄存器的四兄弟：AX、BX、CX、DX 为什么要分家
8086 的四个通用寄存器AX、BX、CX、DX都是 16 位，看起来功能完全重叠——理论上你只用 AX 一个也能写出所有程序。那为什么要分四个？因为指令编码里塞了默认约定。
- AX（Accumulator）：累加器。乘除法、
IN/OUT、串操作这些指令默认拿它当主角。MUL一个 16 位数，结果的高 16 位自动落在DX、低 16 位落在AX，你没得选。 - BX（Base）：基址寄存器。它是四个里唯一能放进方括号里做间接寻址的通用寄存器，
[BX]合法，[AX]直接报错。这一点是新手最容易忽略的硬约束。 - CX（Count）：计数器。
LOOP指令自动把CX减一并判零，串操作REP前缀也默认数CX。 - DX（Data）：数据寄存器，主要给乘除法做高位搭档，间接寻址时配合
IN/OUT存端口号。
这张默认分工表不是你定的，是硬件电路和指令编码定死的。你逆着它来当然能跑，但会多写好几条MOV来回倒腾，代码又长又慢。我在实际写循环的时候有个习惯：先想清楚这一段要不要用LOOP，要用就老老实实把计数放CX，别为了"逻辑清晰"塞到SI里再每次CMP，那是给自己找麻烦。
1.2 AH、AL 与 AX 叠在一起：高低字节命名的来龙去脉
AX是 16 位，但它可以拆成两个 8 位来用：高 8 位叫AH，低 8 位叫AL。同理BX拆BH/BL，CX拆CH/CL，DX拆DH/DL。注意这里不是"四个 8 位寄存器分别存在"，而是同一块 16 位空间的两个切片。
MOV AX, 1234H ; AX = 1234H MOV AH, 56H ; AX 变成 5634H，高字节被覆盖，低字节没动 MOV AL, 78H ; AX 变成 5678H这段代码跑完AX = 5678H。写AH只动高半边，写AL只动低半边，互不干扰——这个特性在做字节级操作时非常好用，比如把一个 16 位数的高低字节对调（大小端转换）只要三行：
XCHG AH, AL ; 直接交换高低字节但反过来，写AX会同时覆盖AH和AL。这是新手最常见的隐形 bug 来源：前面刚辛苦算好的AL，中间一条MOV AX, 某值就全没了。我踩过这个坑——在一个字符处理循环里，用AL存当前字符，然后为了取一个偏移量写了MOV AX, BX，下一轮循环输出全是错的，查了半小时才发现是这一行把字符冲掉了。
注意事项：
AH/AL这类 8 位切片只存在于 AX、BX、CX、DX 四个寄存器上。SP、BP、SI、DI没有对应的 8 位形式，你不能写MOV SIL, 5（这是 16 位时代的规矩，64 位下才有SIL/DIL）。
顺带说一句为什么命名这么"反直觉"。这套命名是从更早的 8 位处理器一路继承下来的，当年只有 A、B、C、D 四个 8 位寄存器，扩展到 16 位时为了兼容旧代码，就把原来的 8 位寄存器原封不动塞进新寄存器的低半边，起了个"Low"的名字（L），高半边叫"High"（H）。理解了这层历史，AH/AL就不再是需要死记的东西，而是兼容性留下的自然结果。
1.3 SP、BP、SI、DI：四个不参与算术的老实人
剩下四个寄存器默认不干算术的活，专管"指位置"。
| 寄存器 | 全称 | 默认职责 | 能否放进方括号 |
|---|---|---|---|
| SP | Stack Pointer | 栈顶指针，PUSH/POP/CALL/RET自动改它 | 不能 |
| BP | Base Pointer | 栈内基址，常用来访问函数参数和局部变量 | 能，默认段为 SS |
| SI | Source Index | 源变址，串操作MOVS的源 | 能，默认段为 DS |
| DI | Destination Index | 目的变址，串操作MOVS的目的 | 能，默认段为 DS |
SP是这四个里最不能乱碰的。它必须时刻指向栈顶，你手贱写一句MOV SP, 0，下一条PUSH或者CALL就会把数据写到内存最低端，把中断向量表踩烂，程序当场起飞。我见过有人在调试时想"清空栈"就归零SP，结果调试器都跟着挂了。
BP的价值在于它默认寻址段是SS（栈段）而不是DS（数据段），所以函数里访问参数一律用[BP+偏移]，这样即使中途改了DS也不会读错位置。这是编译器生成代码的固定套路，你反汇编任何一段带局部变量的 C 函数都能看到MOV BP, SP开头。
SI和DI除了串操作，最实用的场景是两个数组同时遍历：SI指源数组、DI指目标数组，一条MOVSB就完成一次"取一个字节、存一个字节、两个指针各加一"，配合REP前缀一行搞定整段拷贝。手写循环的话要写五六条指令。
1.4 IP 和 FLAGS：两个你没法直接 MOV 的角色
IP（Instruction Pointer）指向下一条要执行的指令。你不能写MOV IP, 100H，语法上直接拒绝。想改它只有三条路：JMP、CALL/RET、以及中断。这个限制是有道理的——如果允许随意写 IP，CPU 的取指流水就会乱套。
FLAGS更特殊，它是一个按位使用的寄存器，每一位是一个独立的标志：
- CF（进位）：无符号运算溢出时置 1，
JC/JNC看它。 - ZF（零）：结果为 0 时置 1，
JE/JNE看它。 - SF（符号）：结果最高位为 1 时置 1，配合
OF判断有符号大小。 - OF（溢出）：有符号运算溢出。
- DF（方向）：串操作时指针是加还是减，
CLD清零=递增，STD置位=递减。
那两个JC和JL的区别，是汇编考试和实际写代码都绕不开的问题：JC看的是无符号进位，JL看的是"符号位不等于溢出位"。简单记法是——无符号比较用A/B系列（Above/Below），有符号比较用G/L系列（Greater/Less）。用错了就是-1被判成"大于 1"，因为无符号视角下0FFFFH是 65535。
2. 段地址加偏移：内存地址到底是怎么拼出来的
这是整个 16 位汇编里最"别扭"、也最容易被含糊带过的部分。很多人背下了"物理地址 = 段地址 × 16 + 偏移地址"这个公式，但没想明白它为什么长这样，于是换个场景就不会算了。
2.1 那个乘16的公式，本质是"寄存器不够宽"的补救
8086 的地址总线是 20 位，能寻址 1MB 空间，但所有寄存器都是 16 位，最多表示 65536 个地址，只有 64KB。差了 16 倍，怎么办？
设计者的办法是：地址不直接存，存成两段。段基址只存高 16 位（相当于已经右移了 4 位），用的时候整体左移 4 位（也就是乘以 16），再加上 16 位的偏移量。两个 16 位数一拼，刚好凑出 20 位。
; 段地址 1234H，偏移 5678H ; 物理地址 = 1234H * 10H + 5678H ; = 12340H + 5678H ; = 179B8H心算技巧：段地址末尾补一个 0（十六进制），然后和偏移相加。1234补零变12340，加上5678，个位0+8=8，十位4+7=B，百位3+6=9，千位2+5=7，万位1，得到179B8。熟悉之后不用拿笔算。
这个设计带来一个有意思的副作用：同一个物理地址有多种表示。1234:5678、1200:59B8、1000:79B8指向的是同一个字节。所以你在调试器里看到段寄存器的值跟别人不一样，不一定是谁写错了，可能只是段基址选得不同。
2.2 CS、DS、SS、ES 的默认搭配，决定了你少写多少前缀
四个段寄存器各有默认服务对象，指令在取操作数时会自动配对应的段：
| 段寄存器 | 默认搭配的寻址 | 典型用途 |
|---|---|---|
| CS | 取指令（配合 IP） | 代码段，不能随便改 |
| DS | 数据访问（配合 BX、SI、DI 和直接地址） | 全局变量、字符串 |
| SS | 栈操作（配合 SP、BP） | 函数调用、局部变量 |
| ES | 串操作的目的段（配合 DI） | 内存拷贝、SCASB扫描 |
这里有个坑：ES没有默认的"普通数据访问"职责，但它必须在串操作里指定目的段。也就是说你写MOVSB之前必须先把ES设好，否则目的地址会跑到一个你完全没想到的地方，程序静默地写坏内存——不报错、不崩溃，就是数据莫名其妙变了，这种 bug 最难查。
2.3 段超越前缀：临时换一个段来用
想从ES段读数据怎么办？加段超越前缀，在方括号前写明：
MOV AL, ES:[BX] ; 这次从 ES 段取，不是 DS MOV AL, SS:[SI] ; 从栈段取反过来，用BP做基址时默认是SS段，如果你想用BP去访问DS里的数据表，就得写DS:[BP+2]。这种"默认段 + 超越前缀"的组合，是读别人汇编代码时最容易看漏的细节——一行MOV AX, [BP+4]，你以为在取全局数组，其实在取栈上的参数。
2.4 保护模式之后，段寄存器还剩什么
现代 32/64 位系统里，段机制基本被"平坦模型"架空了——所有段的基址都是 0，界限都是 4GB，段寄存器退化成一个索引，指向全局描述符表里的表项。CS还管着特权级，FS/GS被操作系统拿来指向线程本地存储（TLS），其余几个的意义已经很淡。
但这不是说学段地址没用了。反过来，理解段机制能让你看懂很多遗留代码和底层行为，比如为什么实模式程序必须在开头设DS，为什么jmp far要写段:偏移，为什么老式程序的.COM格式限制在 64KB 以内——因为整个文件被当成一个段加载，CS、DS、SS 全指向同一个段基址。
3. 七种寻址方式：把高级语言的结构翻译成方括号
寻址方式是汇编里最需要"手感"的部分。光记住七种名字没用，关键是看到int arr[3][5]这种结构时，能立刻反应出该用哪种组合。
3.1 一张表看完七种寻址及其汇编写法
| 寻址方式 | 写法示例 | 有效地址计算 | 典型场景 |
|---|---|---|---|
| 立即寻址 | MOV AX, 1234H | 无（操作数在指令里） | 常量赋值 |
| 寄存器寻址 | MOV AX, BX | 无（操作数在寄存器） | 寄存器间传值 |
| 直接寻址 | MOV AX, [2000H] | EA = 2000H | 访问固定地址的全局变量 |
| 寄存器间接 | MOV AX, [BX] | EA = BX | 指针解引用 |
| 寄存器相对 | MOV AX, [BX+4] | EA = BX + 4 | 结构体成员、数组元素 |
| 基址变址 | MOV AX, [BX+SI] | EA = BX + SI | 二维数组、矩阵 |
| 相对基址变址 | MOV AX, [BX+SI+4] | EA = BX + SI + 4 | 二维数组中的结构体 |
一个必须记住的硬规则：方括号里能出现的寄存器组合是有限的。合法的只有四种搭配：
[BX+SI] [BX+DI] [BP+SI] [BP+DI]再各加一个 8 位或 16 位常数偏移。你不能写[AX+BX]、[SI+DI]、[CX]，这些在 8086 上全是非法指令。原因在硬件：CPU 内部只有一个加法器专门算有效地址，它的两个输入端口分别接"基址组（BX/BP）"和"变址组（SI/DI）"，跨组才能相加，同组相加没有对应的电路。
提示：如果确实需要
[AX+某偏移]，只能先MOV BX, AX再[BX+偏移]。多一条指令，但没办法。
3.2 为什么偏偏是 BX/BP 配 SI/DI
这个组合不是随便定的，它对应了两类真实的访问需求：
- BX/BP 是"锚点"：指向一个结构的起始位置。
BX指向数据段里的结构，BP指向栈上的栈帧。 - SI/DI 是"游标"：在结构内部滑动。遍历数组成员、扫描字符串里的字符。
所以[BX+SI]天然表达的语义是"从 BX 指的那个表的开头，往后数 SI 个元素"。这套语义和 C 语言的base[i]一一对应，编译器生成代码时几乎是机械翻译。你手写汇编时按这个思路组织，代码会自然清晰。
3.3 一维数组、二维数组、结构体的翻译实例
先看一维字数组求和，数组起始地址2000H，长度 10：
MOV BX, 2000H ; BX 指向数组首地址 MOV CX, 10 ; 循环 10 次 XOR AX, AX ; 累加器清零（XOR 比 MOV AX,0 少一个字节） SUM_LOOP: ADD AX, [BX] ; 取一个字累加 ADD BX, 2 ; 字数组，每次前进 2 字节 LOOP SUM_LOOP ; 结果在 AXADD BX, 2这里的 2 是关键。字节数组是 1，字数组是 2，双字是 4。初学者写成ADD BX, 1然后抱怨结果只有一半，就是这么来的——偏移量的单位是字节，不是元素个数。
二维数组int a[3][5]，每行 5 个元素，每个元素 2 字节，所以行跨度是 10 字节。访问a[i][j]：
; 假设 i 在 AL，j 在 AH（都从 0 开始） MOV BL, AL MOV BH, 0 MOV AX, 10 MUL BX ; AX = i * 10（行首偏移） MOV BX, AX MOV AL, AH ; 这里需注意先保存 j，实际写法要调整 ; 更稳妥的写法是用 IMUL 或查表上面这段示意代码里就藏着一个真实的坑：MUL BX会覆盖AX和DX，如果j存在AX的某半边，算完就没了。正确做法是先把i、j都存到内存或者不参与乘法的寄存器里，算完行偏移再取回来。这个教训很实在——乘除法指令天然会吃掉 AX 和 DX，在它前后安排寄存器时要把这两个当成"易燃品"。
结构体的情况更适合看出组合寻址的价值。假设一个结构体是"学号（2 字节）+ 成绩（2 字节）+ 姓名（10 字节）"，共 14 字节。遍历一个结构体数组：
MOV BX, OFFSET STU_TABLE ; 指向数组首 MOV CX, STU_COUNT NEXT_STU: MOV AX, [BX] ; 学号 MOV DX, [BX+2] ; 成绩 ADD BX, 14 ; 跳到下一个结构体 LOOP NEXT_STU如果结构体内部还有数组（比如成绩是多科），那就是[BX+2+SI]这种"基址+常数+变址"的三段式，正好对应第七种寻址方式的完整形式。
3.4 段超越和默认段，在组合寻址里怎么配
用BP做基址时默认段是SS，这一条在函数里几乎是必然的。看一个标准栈帧：
FUNC: PUSH BP MOV BP, SP ; 建立栈帧 ; 此时 [BP+4] 是第一个参数（[BP] 是旧的 BP，[BP+2] 是返回地址） MOV AX, [BP+4] ... POP BP RET[BP]、[BP+2]、[BP+4]三个位置的语义必须记牢：[BP]存的是上一层函数的 BP，[BP+2]是CALL压进去的返回地址，[BP+4]开始才是真正的参数。这个 4 字节的偏移就是"栈帧头"的固定开销。忘了这一点，参数就会取到返回地址上去，程序RET的时候跳到一片乱码里执行。
4. 内存里的数据长什么样：字节序、对齐和栈的方向
寄存器讲完了，该讲内存这一侧。寄存器的问题在于"用哪个"，内存的问题在于"数据是怎么摆的"。
4.1 小端序：0x1234 存进去，内存里是 34 12
x86 是小端（little-endian）：低字节放低地址，高字节放高地址。MOV AX, 1234H之后写进内存，用字节视角看是：
MOV WORD PTR [2000H], 1234H ; 内存布局： ; 2000H -> 34H （低字节 AL） ; 2001H -> 12H （高字节 AH）初学时这个很别扭，因为人读数字是从高位往低位读，而内存是从低地址往高地址排。但小端有一个实际好处：类型转换不用动内存。一个 4 字节的int要当short用，直接读低两个字节就行，地址不变。如果换成大端，就得往后偏移两个字节再读。
验证一次就记住了：写一段代码把一个字存进内存，然后用字节方式读出来打印，看到34在前12在后，这个印象比看十遍定义都深。
4.2 对齐：为什么结构体的大小比成员加起来大
WORD（2 字节）最好放在偶地址，DWORD（4 字节）最好放在 4 的倍数地址。这不是强制的，是性能问题——对齐的访问一次总线周期就能完成，不对齐可能要拆成两次。
但在 16 位实模式下写汇编时，对齐还带来另一个约束：跨字边界的字访问在某些指令上是允许的，但在某些场合会出问题，比如用MOV访问一个奇地址的字，8086 会做两次总线读再拼起来，而 80386 之后就没这个限制了。手写数据结构时省事一点，让每个字段从偶地址开始，能躲掉不少麻烦。
结构体的填充规则可以自己看一眼：
; 不推荐的紧凑排布（共 7 字节） ; BYTE a ; 偏移 0 ; WORD b ; 偏移 1 <-- 奇地址，访问时可能拆成两次 ; DWORD c ; 偏移 3 <-- 更糟 ; 推荐的排布（共 8 字节） ; BYTE a ; 偏移 0 ; BYTE pad ; 偏移 1 填充 ; WORD b ; 偏移 2 ; DWORD c ; 偏移 4编译器自动做的事，你手写汇编时得自己补。这类"看不见的填充字节"是内存计算错误的高发区——算结构体数组步长时按字段大小加起来算成 7，实际排布是 8，遍历到第二个元素就开始错位，越往后错得越离谱。
4.3 栈是从高地址往低地址长的
这是另一个反直觉的地方。绝大多数人第一次听到"栈往低地址长"都会愣一下。具体动作是这样的：
PUSH AX执行时，先SP = SP - 2，再把AX的值写进[SS:SP]。注意顺序：先减指针，再写数据。POP AX反过来：先读[SS:SP]送到AX，再SP = SP + 2。
; 假设初始 SP = 0100H，AX = 1234H PUSH AX ; SP 变成 00FEH，[SS:00FEH] = 34H，[SS:00FFH] = 12H POP BX ; BX = 1234H，SP 回到 0100HSP永远指向最后压入的那个字的低字节地址，也就是当前栈顶。PUSH让它变小，POP让它变大。这个方向和数组下标增长的方向相反，所以栈上的数据看地址是"倒着来"的。
理解了这个，很多错误就好解释了。为什么PUSH和POP次数不匹配会让程序在RET的时候飞掉？因为CALL压进去的返回地址被多次PUSH挤到了深处，RET从栈顶取到的其实是某个不相干的值，直接当跳转目标用了。
4.4 三个段的边界在哪里，谁在管
实模式下，代码段（CS:IP）、数据段（DS:）、栈段（SS:SP）三者的界限完全靠程序员自己保证。CPU 不会拦住你往代码段里写数据，也不会检查SP有没有越界。你可以在.EXE程序的段定义里让它们重叠，程序照样跑——只要不互相踩。
DATA SEGMENT BUF DB 100 DUP(0) DATA ENDS CODE SEGMENT ASSUME CS:CODE, DS:DATA, SS:STACK START: MOV AX, DATA MOV DS, AX ; ... CODE ENDSASSUME只是个汇编器指令，告诉汇编器"我打算这么配"，它不产生任何机器码，也不会真的去改寄存器。真正让DS指向数据段的，是那两行MOV AX, DATA/MOV DS, AX。忘了写这两行，ASSUME照样在，汇编也能通过，但运行时所有对数据段的访问都会偏移到一个随机的地方——这是新手第一个程序最常见的翻车点。
5. 亲手跑一遍：用调试器把寄存器变化看在眼里
看再多的表格不如单步走一次。这一段给出一套完整可复现的验证流程，环境选最容易搭的。
5.1 两套可选环境，按手头条件挑
| 方案 | 需要的工具 | 优点 | 适合谁 |
|---|---|---|---|
| 方案 A | DOSBox + MASM/LINK + DEBUG | 最接近教材，DEBUG的R/D/T命令直观 | 跟着课程走的同学 |
| 方案 B | NASM + GDB（Linux 下 32 位） | 免费、现代、能看内存和寄存器 | 想往后学 64 位的人 |
方案 A 的好处是DEBUG程序的体验很原始但极清楚：R看寄存器，D看内存，T单步，U反汇编。方案 B 的 GDB 用info registers、x/16xb 0x地址、si，功能更强但要记的命令多一些。
5.2 第一段可验证的代码
下面这段把"寄存器写入 → 内存布局 → 栈变化"三件事一次性验证完：
; 目的：验证 AX 拆分、小端序、PUSH 方向 CODE SEGMENT ASSUME CS:CODE START: MOV AX, 1234H ; AX = 1234H MOV BX, 5678H ; BX = 5678H MOV DS, AX ; 借 AX 的值当数据段（仅为演示） MOV [0000H], AX ; 把 1234H 写到 DS:0000 MOV [0002H], BX ; 把 5678H 写到 DS:0002 PUSH AX ; 压栈 PUSH BX ; 再压栈 XCHG AH, AL ; 交换 AX 高低字节，AX 变成 3412H MOV CX, 0 POP CX ; CX 弹出最后压入的 5678H POP DX ; DX 弹出 1234H MOV AH, 4CH INT 21H CODE ENDS END START5.3 单步走一遍，每一步该看到什么
在DEBUG里加载后，用T逐条执行，逐条对账：
MOV AX, 1234H之后，AX=1234，其余不变。MOV BX, 5678H之后，BX=5678。MOV DS, AX之后，DS=1234。此时D DS:0000会看到原来那块内存的内容。- 执行完两条
MOV [..]后，D DS:0000应该显示34 12 78 56。这一眼就是小端序最好的证据：1234 存成了 34 12。 - 两条
PUSH之后，R命令看到的SP比初始值小了 4。用D SS:SP查看，头两个字节是78 56，接着是34 12——最后压入的BX在最上面（低地址）。 XCHG AH, AL之后，AX从1234变成3412。- 两条
POP之后，CX=5678、DX=1234，SP回到初始值。注意弹出的顺序和压入相反，这就是后进先出。
5.4 用内存窗口验证"字和字节视角的差异"
在DEBUG里对同一块内存用两种方式看：
D DS:0000 ; 按字节显示：34 12 78 56如果你想按字看，得自己在纸上拼：低地址那个字节是低字节，所以第一个字是1234H，第二个字是5678H。这个"拼"的动作做几遍，小端序就固化成条件反射了。
提示：验证栈变化时把初值和终值的
SP都记下来。PUSH两次再POP两次，SP必须回到原点。如果没回来，说明代码里有一对没配对，这种不对等在小程序里通常不炸，在带CALL的代码里必炸。
6. 五个高频翻车现场，以及它们为什么必然出错
前面铺垫了原理，这一段集中说错误。这些坑我几乎每一个都亲自踩过，排查过程也一并写出来，你可以照着这个思路复现。
6.1 数据段没初始化，字符串打印出乱码
现象：程序能跑，不崩，但屏幕上输出的字符串是一串看不懂的符号，或者干脆什么都不输出。
排查链路是这样的：先确认INT 21H的AH=09H功能号设对了，再看DX指向的偏移是不是字符串起始，最后查DS。九成的情况是只写了MOV DX, OFFSET MSG，忘了先设DS。OFFSET给出的是段内偏移，段基址在DS里，DS如果是启动时的随机值，DX指向的实际物理地址就完全不对。
修复就是开头那两行，顺序不能反：
MOV AX, DATA_SEG MOV DS, AX为什么不能直接MOV DS, DATA_SEG？因为 8086 不允许把立即数直接送到段寄存器。必须先过一个通用寄存器中转。这条限制在新手看来毫无道理，但它是硬约束，只能记住。
6.2 内存到内存的 MOV，汇编器直接拒绝
写MOV [2000H], [3000H]会报错。x86 的MOV指令最多允许一个内存操作数，两个都是内存就没有对应的机器码。必须借一个寄存器中转：
MOV AX, [3000H] MOV [2000H], AX知道原因后就不会觉得这是"汇编器的刁难"了：指令编码里 ModR/M 字节只有一个字段用来描述内存操作数，硬件上没有"双内存通路"这种设计。
6.3 字长不匹配，汇编器报 operand must match
MOV [BX], 1 ; 错误：不知道写字节还是写字 MOV BYTE PTR [BX], 1 ; 正确 MOV WORD PTR [BX], 1 ; 正确内存操作数的大小必须显式说明，因为[BX]本身不携带长度信息。寄存器操作数天生带长度（AL是 1 字节，AX是 2 字节），所以MOV [BX], AL是合法的。这个规则在写循环计数器、初始化缓冲区时会反复遇到。
6.4 栈不平衡，RET 跳到不知道哪里去
这是最凶的一种。程序在函数里PUSH了三个寄存器，POP只弹了两个，RET就从栈上取到了第三个寄存器的值当返回地址。
排查方法很直接：在函数入口和出口各打一个断点，看SP的值是否一致。不一致就是配对问题。我在写带多个分支的函数时养成了一个习惯——在每个RET之前都检查一遍这一路上压了几个、弹了几个。如果分支太多容易乱，就在函数开头一次性PUSH所有要用的寄存器，结尾统一POP，中间不管怎么跳都不碰栈指针。
FUNC: PUSH BX PUSH CX PUSH DX ; ... 函数体，随便用 BX/CX/DX ... POP DX POP CX POP BX RET注意弹出顺序必须和压入相反，因为栈是后进先出。压 BX、CX、DX，就得弹 DX、CX、BX。
6.5 用错了寄存器做间接寻址
MOV AX, [CX] ; 非法！CX 不能做间接寻址 MOV AX, [BX] ; 合法能放进方括号的只有BX、BP、SI、DI四个。写循环时如果计数器在CX里又想同时用它当指针，只能挪一下：先MOV BX, CX再[BX]。或者干脆把计数器放内存里，用DEC+JNZ代替LOOP，把CX解放出来——这个取舍要看具体场景，循环次数少的时候用内存变量反而更省寄存器。
7. 从 16 位到 64 位：寄存器体系是怎么长上去的
把 8086 这套搞清楚之后，往上走会轻松很多，因为规律是一致的：位宽翻倍，命名加前缀，低位保持兼容。
7.1 EAX、RAX 的层层套娃
AX是 16 位，扩展到 32 位叫EAX（Extended AX），再扩展到 64 位叫RAX。它们不是四个独立寄存器，而是同一块物理空间的切片：
; 64 位下的分层 ; RAX [63................................0] ; EAX [31.............0] ; AX [15.....0] ; AH [15..8] ; AL [7..0]写EAX会把高 32 位清零（这是 64 位模式下的规定），写AX或AL不会。这个细节在写 64 位代码时很要命：你以为只改了低 16 位，实际上高 32 位也被清了。
32 位时代新增了ESI、EDI、EBP、ESP，并且取消了 8 位切片限制——SI、DI、BP的低 8 位也能用，叫SIL、DIL、BPL，但要配合 REX 前缀。寻址方式也从"只能 BX/BP 配 SI/DI"放宽到"任意通用寄存器都能做基址或变址"，还可以带比例因子：
MOV EAX, [EBX + ESI*4 + 8] ; 基址 + 变址×比例 + 偏移这个*4的缩放因子是给数组准备的：int数组每个元素 4 字节，ESI直接当元素下标用，硬件帮你乘 4。到了这一步，C 语言的arr[i]几乎是一比一翻译成一条指令。
7.2 R8–R15 与参数传递的变化
64 位下多了R8到R15八个通用寄存器，寄存器总数到了 16 个。这带来了调用约定的根本变化：前 6 个整型参数不再走栈，而是直接放RDI、RSI、RDX、RCX、R8、R9（这是常见的一类约定）。所以在 64 位下看反汇编，函数的开头往往看不到PUSH一堆参数，而是直接就开始用寄存器了。
这个变化对写内联汇编的人影响很大：16 位时代"参数在[BP+4]开始"的记忆完全失效，得按新约定来。但底层的逻辑没变——还是"谁负责压栈、谁负责清栈、返回值放哪"这三件事，只是载体从栈换成了寄存器。
7.3 学完 16 位再看现代代码，能看懂什么
一个实际的例子：你在调试器里看到一段MOV EAX, DWORD PTR [RBP-4]。按前面学的东西翻译一下：RBP是栈帧基址，-4说明这是第一个局部变量（局部变量在RBP下方，因为栈往低地址长），DWORD PTR说明是 4 字节。整句是"取第一个int型局部变量到EAX"。
再比如LEA EAX, [RBX+RCX*2+16]，LEA取的是有效地址而不是内存内容。因为带*2的缩放，这是典型的数组元素地址计算——RBX是数组基址，RCX是下标，每个元素 2 字节，再加 16 字节的结构体头部偏移。
能把这些读出来，说明寄存器和寻址这两块是真的通了，而不是靠背。
8. 一点个人手感：什么时候该省寄存器，什么时候不该
最后说几个只有写过一些代码才会有的体会，都是些书本上不会写的东西。
寄存器的稀缺感要提前建立。16 位下通用寄存器只有 7 个能用（SP不能碰），写复杂一点的循环很容易全部占满，然后被迫往内存里倒腾。我现在动笔前会先在纸上列一张表，把这一段里每个寄存器打算放什么写下来，中途要临时用就按表来，避免"这个寄存器刚才存的是什么来着"这种混乱。表不用留档，写一遍的过程本身就是在做分配。
别为了少一条指令牺牲可读性。XOR AX, AX比MOV AX, 0少一个字节、快一点，这是常识。但在一个逻辑复杂的函数里为了省这一个字节把代码写得难懂，完全不值。反过来，XOR清零还有个额外好处是它会置ZF，某些场景下顺手就完成了判断，这时候用它是真正的一石二鸟。
调试时优先看寄存器快照，而不是逐行读代码。程序出错的时候，先在关键位置停下，把AX、BX、CX、DX、SI、DI、SP、FLAGS全部记下来，然后倒推"这个值是从哪来的"。大部分错误在这个动作之后就能定位——比如SP每次循环都在减小，那必然是某处PUSH没配对；CX是 0 但循环还在跑，那LOOP肯定没执行到。
手写汇编时把注释写成"意图"，不是"动作"。写ADD BX, 2 ; BX 加 2这种注释毫无价值，代码本身就说了。写成ADD BX, 2 ; 指向下一个字元素才有用，因为三个月后你记得的是"我在遍历一个数组"，不记得当时为什么加的是 2 而不是 1。内存步长这类数字，是最容易在修改时忘掉含义的东西。
