企业官网建设流程全解析

简介：面向 Delphi 开发者的 BASM（Borland 汇编语言）入门精要，围绕如何在 Delphi 中编写内嵌汇编提升关键代码性能展开，适合希望系统梳理汇编语法、寻址规则与数据访问方式的初级和中级开发者。资源共 1 个 PDF 文件，包体约 30KB，内容精炼便于随时查阅。文档从 ASM/END 代码块和表达式构成讲起，强调每条语句的操作数必须能在编译期算出准确值；随后以 mov eax,I、imul edx,[ebx].RandSeed,08088405H 等示例说明寄存器、立即数、内存引用三类表达式，并讲解变量、常量、数组、记录访问及类型强制转换。同时指出 Delphi 的 BASM 无法独立生成 .Obj，但可配合 Delphi 编译器完成纯汇编程序，还涵盖 TYPE 返回类型大小、DB/DW/DD/DQ 在代码段定义数据等实用技巧。针对表达式类型大小、常量与变量的使用差异，文中也有集中说明，已有 131 人浏览学习，适合作为 Delphi 汇编知识梳理与代码片段速查参考。

1. 一份归类文档，为什么值得单独写一篇实战笔记

BASM（Borland 汇编语言）这个词，对现在的从业者来说有点尴尬：教科书讲汇编默认是 MASM 或 NASM，网上教程铺天盖地都是 Intel 手册配 Linux 的例子；可一旦你打开 Delphi 写一段 asm，或者接手一份老项目源码，碰到的却是另一套方言——同样的助记符，但寄存器约定不同、语法解析规则不同、能用的指令集范围也完全由编译器版本说了算。所谓「BASM 精要」这类文档，本质上就是把这套方言的边界、寄存器规则和指令归类整理成一份可查的手册，省去你在 MASM 语法和 Borland 系编译器行为之间反复试错的时间。这篇笔记就是把这份文档读薄再读厚：先讲清 BASM 到底是什么、和主流汇编差在哪，再给你能在 Delphi 里直接跑起来的代码模板、指令速查选型样板，最后把所有翻车点集中成排查清单。适合两类人：一类是在 Delphi 项目里写底 layer 优化和嵌入式汇编的老手，另一类是逆向分析时对着 Borland 系编译产物无从下手的初学者。

2. 先看边界：BASM 不是 MASM，也不是 Turbo Assembler

2.1 三个名字的关系：BASM、TASM 与内嵌汇编

很多刚接触的人会把 BASM 和 Turbo Assembler 画等号，这是第一个认知偏差。Turbo Assembler（TASM）是 Borland 当年推出的独立汇编器，面向的是完整的汇编源文件，语法上努力兼容 MASM，有自己的伪指令、宏和段定义体系；而 BASM 是 Borland 系编译器内建的那个汇编器，Delphi 里写 asm...end 内嵌汇编时，真正干活的就是它。我一般这样帮你记：TASM 是一个能单独运行的汇编器，BASM 是藏在 Pascal 编译器肚子里的一套汇编语法解析器。后者没有独立的源文件格式，也不支持 TASM 那套完整的伪指令，它只负责把你在函数体里写的一小段汇编翻译成机器码，然后交给编译器做后续优化和栈帧生成。

这个区分直接决定你查文档的方式。如果手上是一本 TASM 手册，里面讲的 PROC、ENDP、SEGMENT、ASSUME 这些段管理语法，在 Delphi 的 asm 块里基本用不上；反过来，BASM 支持的 @Result、参数名直接引用这类写法，TASM 手册也不会提。标题里的「精要」二字，在我看来就是指把这两套东西的边界画清楚，只保留内嵌汇编场景下真正高频的语法和指令，剔掉独立汇编器那一大套你用不上的内容。

还有一层历史背景值得知道：BASM 的指令集支持范围是跟着编译器走的，不是跟着 CPU 走的。CPU 支持 AVX，不代表你的 Delphi 版本里的 asm 块就能写 vmovdqu；编译器版本老，助记符不认识，你写得再对也过不了编译。这也是为什么归类文档里通常会把指令按年代分组，而不是只按功能分组——查一条指令能不能用，先看它在文档里属于哪一代，再看你的编译器认不认。

2.2 寄存器可见性：哪些能用，哪些不能动

BASM 里最容易被 MASM 习惯带偏的就是寄存器使用规则。在纯汇编程序里，所有通用寄存器都是你的，随便用；但在 Delphi 的汇编函数里，寄存器分两类：一类是调用者保存的，一类是被调用者保存的。所谓调用者保存，意思是调用方在调用你的函数之前，不保证这些寄存器在函数返回后还是原来的值，所以你随便改没人管你；被调用者保存则相反，函数返回时这些寄存器必须和进入时保持一致，否则调用方会默默翻车。

落在 BASM 上，规则是这样的：EAX、ECX、EDX 属于调用者保存，你的 asm 函数里可以随意用，不需要恢复；EBX、ESI、EDI 属于被调用者保存，你的 asm 函数里如果改了它们，必须在返回前恢复原值。这是新手最容易踩的坑——在 Delphi 里写内嵌汇编，随手拿 ESI 当临时变量，函数返回后调用方再用 ESI 时数据已经变了，程序表现往往是在完全不相干的地方崩溃，排查起来非常费劲。

参数传递也一样有约定。Delphi 的默认调用约定叫 register 约定，整型、指针、枚举这类参数，前三个依次放在 EAX、EDX、ECX 里，第四个及之后的参数才走栈。返回值则固定放 EAX，64 位整数或浮点另说。所以你在 asm 函数里看到入口处 EAX 等于第一个参数、@Result 最终也要放进 EAX，靠的就是同一套约定。熟悉这套规则之后，很多所谓「玄学崩溃」都能在动手前就避开。

2.3 语法差异对照：符号引用、标号与寻址

抛开寄存器不谈，BASM 和 MASM 语法上最直观的差异是符号解析。MASM 里访问一个变量，要么用变量名配合 OFFSET，要么用 LEA 取地址，符号和段的关系要自己理清；BASM 里则直接按名字访问，编译器自动把名字翻译成对应的寄存器或常量。比如函数里有参数 Value，asm 块里写 MOV ECX, Value，编译器知道 Value 现在在 EAX 里，会生成 MOV ECX, EAX；写 ADD EAX, Value，生成 ADD EAX, EAX——这种「按名引用」的体验，比手工记参数对应哪个寄存器舒服得多。

标号的规则也要注意。BASM 里标号以 @ 开头是惯例，比如 @Loop、@Exit，但这不是强制语法，只是大家约定俗成的写法。真正要注意的是标号的作用域：同一个函数里标号不能重名，不同函数之间标号互相不可见。而在 MASM 里标号是全局的，容易撞名，BASM 把这个问题天然规避了。另一个差异是伪指令的数量。BASM 基本不接受 DB、DW、SEGMENT 这类定义数据的伪指令，因为在 Delphi 里数据定义是 Pascal 的职责，asm 块只负责计算。如果你想定义一块缓冲区，应该在 Pascal 部分用 var 或 const 声明，然后在 asm 里引用它的地址，而不是试图在汇编里开空间。

寻址方式的差异也值得一提。BASM 支持 [EBP+8]、[ECX*4+Data] 这种基于寄存器的寻址，也支持直接引用 Pascal 变量名，但不支持 MASM 里的 OFFSET 运算符。取地址要用 LEA，比如 LEA EAX, MyVar，编译器会解析成 LEA EAX, [EBP-4] 这种实际形式。这些细节在归类文档里通常列成对照表，我自己看这类文档的习惯是先扫对照表，确认语法边界，再深入看指令集，这样不会把精力浪费在「为什么 OFFSET 编译不过」这类低层次问题上。

3. 在 Delphi 里写内嵌汇编：两个可以直接抄的模板

3.1 最小可用模板：纯 asm 函数与 register 约定

先给一个最常用的模板，功能是求整数数组的和，完全用 asm 实现，不掺一行 Pascal 代码。这个函数演示了 BASM 函数的基本结构：参数怎么进、循环怎么写、返回值怎么给。

function SumArray(const Data: PInteger; Count: Integer): Integer; asm MOV ECX, EAX // ECX = Data，先把第一个参数的指针保存到临时寄存器 XOR EAX, EAX // EAX 清零，它就是累加器，也是最后的返回值 TEST EDX, EDX // 检查 Count 是否为零 JLE @Done // Count <= 0 直接返回 0 @Loop: ADD EAX, [ECX] // 累加当前元素，注意这里是内存寻址，取的是 ECX 指向的值 ADD ECX, 4 // 指针后移一个 Integer，32 位下是 4 字节 DEC EDX // Count 递减 JNZ @Loop // 未到零继续循环 @Done: end;

注意函数的声明里没写 begin...end，而是直接跟 asm...end，这是 Delphi 对纯汇编函数的特殊支持。进入函数时，编译器按 register 约定把 Data 放 EAX、Count 放 EDX，函数体里第一个动作是 MOV ECX, EAX，把 Data 挪到 ECX，因为后面 EAX 要腾出来当累加器和返回值用。XOR EAX, EAX 是清零的标准写法，比 MOV EAX, 0 短一个字节，性能也略好。循环体里 ADD EAX, [ECX] 是内存寻址，取的是 ECX 地址处的 4 字节数据；ADD ECX, 4 是指针步进；DEC EDX 配合 JNZ 构成循环控制。

这段代码我故意只用了 EAX、ECX、EDX 三个寄存器，它们都属于调用者保存类，不需要在函数里做任何压栈恢复操作。如果你在这里改用 EBX 或 ESI 当临时变量，就必须在开头 PUSH、结尾 POP，否则函数返回时调用方会拿到被改坏的寄存器值，崩溃点还不一定在函数内。这是 BASM 代码审查时第一条会查的规则：看有没有在 asm 函数里裸用被调用者保存寄存器。

3.2 begin...end 里的 asm 块：按名引用 Pascal 变量

第二种更常见的使用姿势，是在普通 Pascal 函数内部嵌入一段 asm，处理某个热点计算。这时候 BASM 最大的优势——按名引用 Pascal 变量——就体现出来了。下面这个例子是带符号除法，顺便展示了局部变量如何和汇编交互。

function SafeDiv(A, B: Integer): Integer; var Q: Integer; begin if B = 0 then Exit(0); asm MOV EAX, A // A 是参数，编译器自动展开成入口寄存器 EAX CDQ // 把 EAX 的符号位扩展到 EDX，形成 64 位有符号数 IDIV B // 有符号除法，商进 EAX，余数进 EDX MOV Q, EAX // Q 是局部变量，编译器自动映射到 [EBP-4] end; Result := Q; end;

这段代码里，MOV EAX, A 和 MOV Q, EAX 是最值得品味的两个写法。A 是参数，按 register 约定它本来就在 EAX 里，所以这条指令实际编译出来是 MOV EAX, EAX，编译器会直接优化掉；但你写 A 比写 EAX 可读性好得多，而且万一哪天改了函数签名、参数顺序变了，编译器自动帮你重新映射，不用手改。Q 是局部变量，编译器把它映射到 EBP 相对寻址 [EBP-4]，你写 MOV Q, EAX，它就生成 MOV [EBP-4], EAX——这就是 BASM 和 MASM 体验上的最大分野，汇编代码可以和 Pascal 符号共享命名空间。

CDQ 是这里的关键指令，也是新手最容易漏的。IDIV 是有符号除法指令，它要求被除数在 EDX:EAX 组成的 64 位双字里，其中 EDX 是高位、EAX 是低位。如果只把 A 放进 EAX 就直接 IDIV，EDX 里残留着上一次运算的垃圾值，商和余数都会算错。CDQ 的作用是把 EAX 的最高位（符号位）复制到 EDX 的每一位上，这样 EAX 是正数时 EDX 全零、是负数时 EDX 全一，完成了有符号数的 64 位扩展。这段除法逻辑如果换成 unsigned 场景，就要用 XOR EDX, EDX 配合 DIV，两条指令完全不同。

3.3 什么时候值得写 asm，什么时候不该碰

给完模板，得说句泼冷水的话：不是所有热点函数都值得用 BASM 重写。我见过不少项目把简单的赋值逻辑换成汇编，性能没提升多少，维护成本倒是直线上升。判断标准我一般看三条：第一，这段代码是否真的在性能关键路径上，比如被每秒调用上万次的循环里；第二，函数逻辑是否足够简单，简单到用三五条指令能说清；第三，是否只涉及整数和指针运算，不碰浮点 SIMD 和字符串这类复杂类型。三条都满足，才值得动手。

复杂类型是 BASM 的禁区。string、interface、动态数组这类托管类型，编译器在赋值、传参时都要插入引用计数管理代码，计数增减、内存释放都是编译器注入的逻辑。你在 asm 里直接搬运这些类型的数据，等于绕过了编译器的生命周期管理，轻则内存泄漏，重则悬空指针崩溃，而且崩溃时机完全随机，属于典型翻车现场。前面那个 SafeDiv 例子敢用局部变量 Q，是因为它是 Integer，没有生命周期，编译器不需要插任何管理代码，asm 块内外完全可控。

4. 按功能归类的指令速查：文档该怎么用，选型怎么定

4.1 从归类文档里挑指令的三个步骤

拿到一份精要归类文档，上来从第一页往后啃是效率最低的读法。我会先做三件事：先翻目录，看它是按指令功能分还是按 CPU 年代分；再查寄存器约定和语法对照那一节，确认这版编译器支持哪些助记符；最后挑几个我要写的函数场景，在文档里定位对应的指令组。这样读文档，十分钟就能开始写代码，而不是读一小时还在看寻址模式定义。

归类文档最值钱的部分是指令选型。同样是求一个 32 位整数里最低位 1 的位置，你可以用循环一位位测，也可以用 BSF 一条指令搞定；同样是做大小端转换，可以手写移位，也可以用 BSWAP。文档的价值就是把「有没有更短的一条指令」这件事摆在你面前。下面这张表是我认为内嵌汇编里最高频的一组指令，也是归类文档里必然出现的选型样板，我自己写代码时经常回来查这张表。

4.2 CMPXCHG 写自旋锁：一个完整的选型案例

拿表里的 CMPXCHG 举个例子，很多 Delphi 老项目里的无锁代码就是靠它撑起来的，因为早年 Delphi 还没有内置的 InterlockedCompareExchange 封装，或者封装的版本行为不合预期，开发者就直接在 asm 里写。一个常见的自旋锁核心代码长这样：

function TryLock(var LockVar: Integer): Boolean; asm MOV ECX, 1 // ECX = 1，表示锁被占用 XOR EAX, EAX // EAX = 0，期望锁当前是空闲 LOCK CMPXCHG [EAX?], ECX // 错误示范，见下方说明 end;

上面这段是故意写错的，正好借它讲清楚 CMPXCHG 的语义。CMPXCHG 指令的操作数是「内存目标和两个寄存器」，它先比较目标内存值和第一个寄存器（EAX 里的期望值），相等就把第二个寄存器（ECX）写入内存，不等则把内存值加载到 EAX。由于第一个参数在 EAX 里、第二个参数在 ECX 里是硬编码的，真正的写法应该是：

function TryLock(var LockVar: Integer): Boolean; asm MOV ECX, 1 // ECX = 新值，表示锁被占用 XOR EAX, EAX // EAX = 期望的旧值，0 表示锁空闲 LOCK CMPXCHG LockVar, ECX // 若 LockVar = EAX，则写入 ECX JE @Acquired // ZF = 1 说明交换成功 XOR EAX, EAX // 失败，返回 False RET @Acquired: MOV EAX, 1 // 成功，返回 True end;

这里 LOCK 前缀的作用是把 CMPXCHG 变成原子操作，保证多核环境下比较和交换之间不会被其他核心打断。JE 判断的是 ZF 标志位：CMPXCHG 执行后，如果发生了交换，ZF 置 1，说明你拿锁成功；如果没交换，ZF 清 0，同时 EAX 被更新为内存里的当前值，说明锁被别人占着。用汇编写这类逻辑，每一步的语义都摆在明面上，比读高级语言封装出来的实现容易验证。

4.3 助记符认不认，是编译器版本说了算

用归类文档还有一个高频场景：查一条指令这版编译器认不认。这个问题的答案文档里通常不会直接写，因为它随编译器版本浮动。判断方法有两条：一是直接编译试，编译器报「Unknown identifier」或非法指令错误，基本就是助记符不被支持；二是在老代码里找线索，看到 DB 0Fh, 0A8h 这种手工编码片段，就说明写代码的人用的编译器不认 CMPXCHG，只能自己往字节流里塞机器码。

我们自己写新代码时不需要 DB 绕过，但读老项目时必须认识这种写法。DB 是定义字节的伪指令，后跟的十六进制数就是指令的机器码，0F 开头的通常是扩展指令集，拿到现代编译器和调试器里跑，反汇编出来就会现出真身。我读老 Delphi 代码有个习惯：先全局搜 DB 0F，凡是命中的地方基本都是当年的指令集鸿沟现场，也是理解这段代码在干什么的最大线索。

另外，SSE 系列助记符在早期 BASM 里支持得非常有限，很多涉及 SIMD 的代码在 asm 块里写不了，只能靠外部汇编文件或 intrinsics 补位。后来编译器版本逐步补全，才把大部分 SSE 指令的助记符放进内嵌汇编器。所以归类文档里如果按年代把指令分了组，老项目移植时先看分组再动手，能省掉大量「编译不过还在怀疑自己拼写」的时间。

5. 避坑清单：BASM 文档里不写明的那些翻车现场

5.1 改了 EBX/ESI/EDI，程序在不相干的地方崩溃

现象：asm 函数里用了 EBX 当临时变量，单测函数本身返回值正确，但整个程序跑一段时间后会在完全无关的代码处崩溃，崩溃点还经常变，像极了内存损坏。

原因：EBX、ESI、EDI 属于被调用者保存寄存器，调用方在调用你的函数之前会把这些寄存器里的值当作长期数据存在那里。你用它们做临时变量但没有恢复，函数返回后调用方继续用旧数据，逻辑直接错乱。Delphi 编译器生成的函数框架不会自动帮你保存这三者，与某些 C 编译器内嵌汇编会自动插入 push/pop 的行为不同。

解决：asm 函数里尽量只用 EAX、ECX、EDX。如果实在不够用，在函数开头 PUSH EBX，返回前 POP EBX，且保证 PUSH 和 POP 严格配对，中间的所有分支路径都不能漏掉 POP。我自己审查别人代码时，第一眼就扫函数体的开头和结尾有没有配对的 PUSH/POP。

5.2 asm 块里压栈没弹栈，函数返回直接飞掉

现象：在 begin...end 的 asm 块里写了 PUSH 保存寄存器，但忘记 POP，编译不报错，运行到函数返回时程序跳转到随机地址，崩溃或死循环。

原因：BASM 函数的 RET 指令由编译器统一生成，它从栈顶取返回地址。你在 asm 块里 PUSH 了数据而没 POP，栈顶就不再是返回地址，而变成了你压入的值，RET 执行后 CPU 把这个值当成地址跳了过去。

解决：PUSH 和 POP 必须在同一个 asm 块内配对，且不能跨分支缺失。更稳妥的做法是根本不用 PUSH/POP，直接换用调用者保存寄存器。有一句经验我可以直接给你：在 BASM 函数里出现 PUSH 的次数越多，说明代码越有重构空间——绝大多数情况换寄存器就能解决，不需要碰栈。

5.3 64 位 Delphi 里写 asm，编译直接报错

现象：把 32 位老项目里的 asm 函数原样搬到 64 位目标平台，编译时报错说内嵌汇编不支持，整个函数被标红。

原因：64 位编译器移除了 BASM 内嵌汇编支持，asm...end 这个语法在 64 位下不再成立。寄存器数量、调用约定在 x64 下都变了，编译器选择从根上关掉这门方言，倒逼开发者用高级语言或外部汇编文件。

解决：三条路——换成纯 Pascal 实现，利用编译器优化；热点代码用外部 .asm 文件配合独立汇编器编成对象文件再链接；或者用 Intrinsics 风格的系统内置函数达到类似效果。从某种意义上说，BASM 的适用范围天然锚定在 32 位 Delphi 项目上，做迁移评估时要在项目一开始就意识到这条线。

5.4 在 asm 里搬 string，内存泄漏加随机崩溃

现象：asm 块里把一个 string 变量的地址取出来直接赋值给另一个 string，结果程序内存持续增长，偶尔崩溃，而且 Debug 和 Release 行为不一致。

原因：string 是编译器管理的托管类型，每一次赋值、传参、释放都伴随引用计数增减，由编译器在幕后插入若干辅助函数调用。你直接在 asm 里搬运数据，绕过了这些辅助函数，引用计数永远不对，内存自然泄漏；多线程下两个引用计数同时错乱，崩溃也在情理之中。

解决：asm 块只处理整数、指针、枚举、浮点这类无生命周期管理的简单类型。凡是涉及 string、interface、动态数组的场景，把汇编边界放在最外层——先用 Pascal 把复杂类型解包成指针和长度，再进 asm；算完再交回 Pascal 封装。这条规则我当铁律用，宁可多写两行 Pascal，也不在 asm 里碰托管类型。

5.5 有符号除法结果不对，或者除零直接异常

现象：同一段除法汇编代码，正数算得对，负数商和余数全部错乱；或者除数为零时程序直接抛异常退出，没有走 Pascal 的错误处理分支。

原因：IDIV 是有符号除法，要求 EDX:EAX 组成 64 位被除数，而 EDX 不是你每次都能保证干净的。少写 CDQ，EDX 里的残留值就会污染除法结果。除数为零则是硬件层面的异常，直接触发中断，高级语言的异常处理机制拦不住它。

解决：每次做 IDIV 之前先 CDQ 扩展符号位；做 DIV 之前先 XOR EDX, EDX 清零高位。除数为零的防护必须在进入 asm 之前用 Pascal 代码完成，比如 if B = 0 then Exit(0)，不要让汇编指令有机会拿到零除数。这条和前面 SafeDiv 的例子正好呼应，也是我写除法类汇编代码时最常回查的一个点。避免踩坑的顺序反过来就是排查顺序：先查寄存器是否裸用，再查 push/pop 配对，最后查除法扩展指令有没有写齐——按这个顺序过一遍，大部分 asm 崩溃都能定位。

6. 进阶：用 CPU 窗口反查机器码，把精要读成自己的速查表

归类文档终究是别人的归纳，要在自己机器上验证一遍才算数。我有个固定步骤：每从文档里学一条新指令，就在 Delphi 里写一个最小函数包住它，编译后进 CPU 窗口，单步执行对照反汇编结果。比如你刚学了 CMPXCHG，就写个函数调用它，然后打开 CPU 窗口看编译器生成的机器码是不是和你预期的一致，尤其关注有没有自动插入的额外的保存恢复代码。这一步能同时验证两件事：你的编码正确性，以及编译器版本的 BASM 支持边界。

第二个进阶习惯是建自己的微基准测试台。用 RDTSC 或系统计时函数，对同一逻辑的 Pascal 版本和 asm 版本分别打点，样本数跑几十万轮取中位数。我做过一次实验：一个简单的 8 位字节反转函数，纯 Pascal 写和 BASM 写，在某个项目环境下性能差不到 15%，但改成查表法之后反而快了四倍。这个实验说服我从此不再盲目迷信汇编——性能瓶颈往往在算法层面，指令层面的优化只对已经确定最优算法后的局部热点有意义。测试台架子搭一次，后面每优化一个函数都往上面丢，数据比感觉可靠得多。

再进一步，就是把你验证过的片段回填到那份精要文档里，形成自己的批注版。我在文档空白处手写过不少补充：某个指令在哪版编译器上不支持、某个寻址方式在哪种写法下编译器会生成多余指令、某条坑在哪个函数里踩过。这些批注是文档本身给不了的——它们是编译器和项目代码交互摩擦出来的经验值。我现在翻这类文档，基本不看正文的指令表了，主要看自己的批注和当年的踩坑记录，因为它们能直接告诉我哪里会翻车，而不是哪里能通过。

最后说一个教训：我早年间纯靠读文档以为了解了 BASM，第一段内嵌汇编就踩了 EBX 的坑，程序在客户现场随机崩溃，排查了一整天才定位到是寄存器保存问题。从那以后我定了一条规矩——不验证不信任。每一段 asm 代码都要过 CPU 窗口和性能测试台，宁可多花十分钟，也不要留下一个只在生产环境爆发的隐患。这份精要能不能成为你的工具箱一部分，也取决于你愿不愿意做这一步验证。希望帮到你。

本文还有配套的精品资源，点击获取