汇编语言 on 文艺技术笔记

10 个经典汇编程序实例：从排序到字符串处理

Sat, 13 Jun 2026 12:00:00 +0800

实例 1：冒泡排序

BUBBLE_SORT PROC
    MOV CX, N-1         ; 外层循环
OUTER:
    MOV BX, 0
    PUSH CX
INNER:
    MOV AL, ARR[BX]
    CMP AL, ARR[BX+1]
    JLE NO_SWAP
    XCHG AL, ARR[BX+1]
    MOV ARR[BX], AL
NO_SWAP:
    INC BX
    LOOP INNER
    POP CX
    LOOP OUTER
    RET
BUBBLE_SORT ENDP

实例 2：字符串长度

STRLEN PROC
    MOV CX, 0
    MOV BX, OFFSET STR
NEXT:
    CMP BYTE PTR [BX], 0
    JE DONE
    INC CX
    INC BX
    JMP NEXT
DONE:
    MOV AX, CX
    RET
STRLEN ENDP

实例 3：十六进制转十进制

HEX2DEC PROC
    MOV CX, 0
    MOV BX, 10
CONVERT:
    MOV DX, 0
    DIV BX            ; AX ÷ 10
    PUSH DX           ; 余数入栈
    INC CX
    CMP AX, 0
    JNE CONVERT
PRINT:
    POP DX
    ADD DL, '0'
    MOV AH, 02h
    INT 21h
    LOOP PRINT
    RET
HEX2DEC ENDP

实例 4：阶乘

FACTORIAL PROC
    MOV AX, 1
    MOV CX, N
FACT_LOOP:
    MUL CX            ; AX * CX → DX:AX
    LOOP FACT_LOOP
    RET
FACTORIAL ENDP

实例 5：斐波那契数列

FIBONACCI PROC
    MOV AX, 0
    MOV BX, 1
    MOV CX, N
FIB_LOOP:
    MOV DX, AX
    ADD DX, BX        ; DX = AX + BX
    MOV AX, BX
    MOV BX, DX
    ; 打印 AX
    LOOP FIB_LOOP
    RET
FIBONACCI ENDP

总结

这些实例覆盖了汇编编程的常见模式。动手敲一遍，你的汇编水平会有质的飞跃。

下一篇：《汇编语言实验指导：5 个动手实验从易到难》

汇编语言调试技巧：Debug 工具与逆向分析基础

Sat, 13 Jun 2026 12:00:00 +0800

DEBUG.exe 基础

DOS 自带的调试工具，支持单步执行、寄存器查看、内存修改。

启动

`1`	`debug program.exe`

常用命令

命令	功能	示例
r	查看/修改寄存器	`r ax`
d	查看内存	`d ds:0100`
e	修改内存	`e ds:0100 90 90`
t	单步执行	`t`
g	运行到断点	`g 0100`
u	反汇编	`u cs:0100`
a	汇编	`a cs:0100`

单步调试示例

-debug hello.exe
-r          ; 查看寄存器
-t          ; 执行一条指令
-r ax       ; 查看 AX 变化
-d ds:0000  ; 查看数据段
-q          ; 退出

Turbo Debugger (TD)

图形化调试器，支持：

源码/反汇编窗口
断点设置
变量监视
调用栈查看

GDB 调试（32 位 Linux）

1
2
3

nasm -f elf32 prog.asm -o prog.o
ld -m elf_i386 prog.o -o prog
gdb ./prog

GDB 命令：

(gdb) break main
(gdb) run
(gdb) info registers
(gdb) stepi
(gdb) x/10xw $esp

逆向分析基础

静态分析

使用 objdump 或 IDA 查看反汇编
识别函数边界（PUSH BP / MOV BP,SP … POP BP / RET）
追踪数据流

动态分析

设置断点
观察寄存器变化
修改内存测试边界条件

常见调试技巧

问题	调试方法
程序崩溃	检查栈平衡（PUSH/POP 是否配对）
结果错误	单步执行，逐条检查寄存器
死循环	检查 CX 是否正确递减
内存越界	检查 DS/ES 段地址

总结

调试是汇编开发的必备技能。掌握 DEBUG/GDB，你就能定位任何底层 Bug。

下一篇：《汇编在现代系统中的位置：从 Bootloader 到逆向工程》

汇编语言实验指导：5 个动手实验从易到难

Sat, 13 Jun 2026 12:00:00 +0800

实验 1：环境搭建与 Hello World

目标：配置 DOSBox + MASM，成功编译运行第一个程序

验收标准：

环境配置文档
成功显示 “Hello World”

步骤：

安装 DOSBox
下载 MASM 工具链
编写 DATA/CODE 段程序
编译、链接、运行

实验 2：计算器程序

目标：实现加减乘除四则运算

要求：

从键盘接收两个数字和运算符
输出计算结果
处理除零错误

提示：使用 INT 21h 的 01h/0Ah 功能读取输入

实验 3：学生成绩管理

目标：用结构体存储学生信息，实现排序和查询

数据结构：

STUDENT STRUC
    ID      DW ?
    NAME    DB 20 DUP(?)
    SCORE   DW ?
STUDENT ENDS

功能：

录入 5 个学生成绩
按成绩排序
显示排行榜

实验 4：文件加密工具

目标：读写文件，实现 XOR 加密/解密

要求：

命令行指定文件名
读取文件内容
逐字节 XOR 加密
写回文件

实验 5：Bootloader 原型

目标：编写 512 字节引导程序

要求：

显示 “Booting…”
从软盘读取内核到内存
跳转到内核

提示：使用 INT 13h 读磁盘，程序必须以 55AAh 结尾

总结

实验是学习汇编的最佳方式。从简单到复杂，每一步都建立在前面的基础上。

下一篇：《汇编语言调试技巧：Debug 工具与逆向分析基础》

汇编在现代系统中的位置：从 Bootloader 到逆向工程

Sat, 13 Jun 2026 12:00:00 +0800

汇编过时了吗？

没有。它只是从"日常开发"变成了"专业工具"。

场景 1：Bootloader 与 UEFI

计算机启动的第一行代码是汇编：

BIOS/UEFI 固件
GRUB 引导加载器
Windows Boot Manager

; 典型的 MBR 引导代码
[BITS 16]
[ORG 0x7C00]

start:
    mov ax, 0
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, 0x7C00
    
    mov si, msg
    call print_string
    
    jmp $

场景 2：操作系统内核

Linux 内核的入口点是汇编：

1
2
3

; arch/x86/boot/header.S
.code16
jmp     trampoline

内核初始化阶段：

设置段寄存器
切换到保护模式
建立页表
跳转到 C 代码

场景 3：漏洞分析与利用

逆向分析 CVE 漏洞时，你看到的是汇编：

1
2
3

0x08048456:  call   strcpy    ; 缓冲区溢出点
0x0804845B:  leave
0x0804845C:  ret              ; EIP 被覆盖 → 控制流劫持

场景 4：性能优化

关键热点函数手写汇编：

视频编解码（x264）
加密算法（AES-NI）
数学库（BLAS/LAPACK）

; SSE2 向量化加法
movdqa xmm0, [a]
paddd  xmm0, [b]
movdqa [c], xmm0

场景 5：游戏与反作弊

游戏引擎底层渲染
反作弊驱动（Ring 0）
模拟器开发（NES/GBA）

学习建议

先学 8086：理解基础概念
再学 x86_64：掌握现代架构
结合 C 语言：理解编译输出
动手实践：写 Bootloader、分析 CrackMe

总结

汇编语言是程序员的"拉丁文"。它不常用，但懂它的人能读懂计算机的真正语言。

汇编语言系列到此结束。 从基础到实战，从历史到现代，希望这个系列能帮你建立完整的底层知识体系。

内存管理实战：直接访问显存与 VGA 文本模式

Sat, 13 Jun 2026 12:00:00 +0800

VGA 文本模式

DOS 默认运行在 80×25 文本模式。显存起始地址：B800:0000。

显存结构

每个字符占 2 字节：

字节 1：ASCII 码
字节 2：属性（前景色 + 背景色）

1
2
3

偏移 0: 'H'(48h)  属性 (07h)  → 白字黑底 'H'
偏移 2: 'e'(65h)  属性 (07h)  → 白字黑底 'e'
...

属性字节

位	含义
0-2	前景色（0-7）
3	前景高亮
4-6	背景色（0-7）
7	闪烁

颜色值：0=黑 1=蓝 2=绿 3=青 4=红 5=紫 6=棕 7=白

实战：彩色输出

MOV AX, 0B800h
MOV ES, AX          ; ES 指向显存段

MOV DI, 0           ; 屏幕左上角
MOV AL, 'A'         ; 字符
MOV AH, 1Ch         ; 属性：红底白字
MOV ES:[DI], AX     ; 写入显存

; 清屏
CLEAR_SCREEN PROC
    MOV AX, 0B800h
    MOV ES, AX
    MOV DI, 0
    MOV CX, 2000    ; 80*25 = 2000 字符
    MOV AX, 0720h   ; 空格 + 白字黑底
    CLD
    REP STOSW       ; 重复写入
    RET
CLEAR_SCREEN ENDP

实战：滚动窗口

SCROLL_UP PROC
    MOV AH, 06h     ; BIOS 滚动功能
    MOV AL, 1       ; 滚动行数
    MOV BH, 07h     ; 空白行属性
    MOV CH, 0       ; 左上角行
    MOV CL, 0       ; 左上角列
    MOV DH, 24      ; 右下角行
    MOV DL, 79      ; 右下角列
    INT 10h
    RET
SCROLL_UP ENDP

总结

直接操作显存让你理解图形系统的底层逻辑。现代 GUI 虽然复杂，但核心思想不变：内存映射到像素。

下一篇：《10 个经典汇编程序实例：从排序到字符串处理》

DOS 中断调用实战：INT 21h 文件/键盘/显示操作

Sat, 13 Jun 2026 11:00:00 +0800

什么是 DOS 中断？

DOS 中断是操作系统提供的系统调用。汇编程序通过 INT 21h 请求 DOS 服务。

功能号机制

1
2
3

MOV AH, 功能号  ; 选择服务
; 设置其他参数
INT 21h         ; 调用

常用功能号速查

功能号	功能	输入	输出
01h	键盘输入（带回显）	-	AL=字符
02h	显示字符	DL=字符	-
09h	显示字符串	DX=字符串地址	-
0Ah	键盘输入（缓冲区）	DX=缓冲区地址	-
3Ch	创建文件	DX=文件名，CX=属性	AX=文件句柄
3Dh	打开文件	DX=文件名，AL=模式	AX=文件句柄
3Eh	关闭文件	BX=文件句柄	-
3Fh	读文件	BX=句柄，DX=缓冲区，CX=字节数	AX=实际读取
40h	写文件	BX=句柄，DX=缓冲区，CX=字节数	AX=实际写入
4Ch	退出程序	AL=返回码	-

实战：文件读写

; 创建并写入文件
DATA SEGMENT
    FNAME DB 'test.txt', 0
    MSG   DB 'Hello from Assembly!'
    BUF   DB 100 DUP(?)
    HANDLE DW ?
DATA ENDS

CODE SEGMENT
    ASSUME CS:CODE, DS:DATA
START:
    MOV AX, DATA
    MOV DS, AX
    
    ; 创建文件
    MOV AH, 3Ch
    MOV CX, 0
    MOV DX, OFFSET FNAME
    INT 21h
    MOV HANDLE, AX
    
    ; 写入数据
    MOV AH, 40h
    MOV BX, HANDLE
    MOV CX, 20
    MOV DX, OFFSET MSG
    INT 21h
    
    ; 关闭文件
    MOV AH, 3Eh
    MOV BX, HANDLE
    INT 21h
    
    ; 退出
    MOV AH, 4Ch
    INT 21h
CODE ENDS
    END START

总结

掌握 INT 21h，你的汇编程序就能与文件系统、键盘、屏幕交互，从玩具变成工具。

下一篇：《输入输出与中断程序设计：硬件交互的底层逻辑》

多模块程序设计与混合编程：C 语言调用汇编

Sat, 13 Jun 2026 11:00:00 +0800

为什么混合编程？

性能热点：关键函数用汇编优化
硬件操作：端口访问、特权指令
学习价值：查看 C 代码的汇编实现

C 调用汇编

汇编文件（add.asm）

.386
.MODEL flat, C
.CODE

; int add(int a, int b);
add PROC
    MOV EAX, [ESP+4]    ; 参数 a
    MOV ECX, [ESP+8]    ; 参数 b
    ADD EAX, ECX
    RET
add ENDP

END

C 文件（main.c）

#include <stdio.h>
extern int add(int a, int b);

int main() {
    int result = add(100, 200);
    printf("100 + 200 = %d
", result);
    return 0;
}

编译链接

1
2

nasm -f win32 add.asm -o add.obj
gcc -m32 main.c add.obj -o mixed.exe

汇编调用 C 库

EXTERN printf:PROC
EXTERN exit:PROC

SECTION .data
    msg DB 'Hello from Assembly!', 0

SECTION .text
    GLOBAL main
main:
    PUSH msg
    CALL printf
    ADD ESP, 4
    PUSH 0
    CALL exit

参数传递约定（32 位）

参数从右到左压栈

CALL 后栈布局：

1
2
3

[ESP]    = 返回地址
[ESP+4]  = 参数 1
[ESP+8]  = 参数 2

返回值放在 EAX
调用者负责清理栈

64 位差异

32 位	64 位
栈传参	RCX/RDX/R8/R9 寄存器传参
调用者清栈	调用者清栈（影子空间 32 字节）
EAX 返回值	RAX 返回值

总结

混合编程让汇编融入现代开发流。掌握链接约定，你就能在需要时引入汇编优化。

下一篇：《10 个经典汇编程序实例：从排序到字符串处理》

宏指令与高级汇编技术：代码复用与元编程

Sat, 13 Jun 2026 11:00:00 +0800

什么是宏指令？

宏指令在汇编阶段展开，不是运行时调用。它相当于代码模板替换。

基本语法

PRINTSTR MACRO msg
    MOV DX, OFFSET msg
    MOV AH, 09h
    INT 21h
ENDM

; 使用
PRINTSTR HELLO_MSG

展开后等价于：

1
2
3

MOV DX, OFFSET HELLO_MSG
MOV AH, 09h
INT 21h

带参数宏

ADD2 MACRO dest, src1, src2
    MOV dest, src1
    ADD dest, src2
ENDM

; 使用
ADD2 AX, BX, CX

局部标号

MYMACRO MACRO
    LOCAL skip
    CMP AX, 0
    JE skip
    ; do something
skip:
ENDM

LOCAL 确保宏多次展开时标号不冲突。

条件汇编

DEBUG EQU 1

IF DEBUG
    PRINTSTR "Debug mode ON
$"
ELSE
    PRINTSTR "Release mode
$"
ENDIF

循环展开

UNROLL_LOOP MACRO count, label
    LOCAL i
    i = 0
    REPEAT count
        CALL label
        i = i + 1
    ENDM
ENDM

宏 vs 子程序

特性	宏	子程序
展开时机	汇编时	运行时
代码体积	每次展开复制代码	只有一份代码
执行速度	快（无调用开销）	稍慢（CALL/RET）
适用场景	短小频繁的代码	复杂逻辑

总结

宏指令让汇编也能实现"代码生成"。合理运用宏和条件汇编，你的代码会简洁数倍。

下一篇：《DOS 中断调用实战：INT 21h 文件/键盘/显示操作》

输入输出与中断程序设计：硬件交互的底层逻辑

Sat, 13 Jun 2026 11:00:00 +0800

I/O 端口

CPU 通过端口与外设通信。x86 有独立的 I/O 地址空间（64KB）。

端口读写指令

1
2

IN  AL, DX    ; 从 DX 指向的端口读入 AL
OUT DX, AL    ; 将 AL 写入 DX 指向的端口

中断向量表（IVT）

内存 0000:0000 处的 1KB 空间，存放 256 个中断处理程序地址：

中断号	功能
00h	除零错误
08h	定时器中断
09h	键盘中断
10h	BIOS 显示服务
13h	BIOS 磁盘服务
21h	DOS 系统调用

中断处理流程

CPU 收到中断请求
保存 FLAGS、CS、IP 到栈
从 IVT 查找处理程序地址
跳转到处理程序
IRET 返回

自定义中断处理程序

; 安装自定义中断
CLI                  ; 关中断
MOV AX, 0
MOV ES, AX
MOV WORD PTR ES:[09h*4], OFFSET MyISR
MOV WORD PTR ES:[09h*4+2], CS
STI                  ; 开中断

; 中断服务程序
MyISR PROC
    PUSH AX
    ; 处理键盘输入
    POP AX
    IRET
MyISR ENDP

BIOS 中断

中断	功能号	用途
INT 10h	AH=00h	设置显示模式
INT 10h	AH=0Eh	显示字符（TTY）
INT 13h	AH=02h	读磁盘扇区
INT 16h	AH=00h	读取键盘按键

总结

中断是硬件与软件的桥梁。理解中断机制，你就掌握了操作系统与硬件对话的语言。

下一篇：《多模块程序设计与混合编程：C 语言调用汇编》

子程序设计：参数传递、局部变量与调用约定

Sat, 13 Jun 2026 11:00:00 +0800

为什么需要子程序？

汇编没有"函数"关键字，但我们可以用 CALL 和 RET 实现同样的效果。

子程序的基本结构

MyFunc PROC
    PUSH BP        ; 保存调用者的栈帧
    MOV BP, SP     ; 建立新栈帧
    SUB SP, 4      ; 分配 4 字节局部变量
    
    ; 函数体
    MOV [BP-2], AX  ; 局部变量 1
    MOV [BP-4], BX  ; 局部变量 2
    
    MOV SP, BP     ; 清理局部变量
    POP BP         ; 恢复调用者栈帧
    RET
MyFunc ENDP

参数传递方式

1. 寄存器传参（最快）

; 调用者
MOV AX, 100
MOV BX, 200
CALL AddFunc

; AddFunc
AddFunc PROC
    ADD AX, BX     ; 结果在 AX 中
    RET
AddFunc ENDP

2. 栈传参（适合多参数）

; 调用者
PUSH 200
PUSH 100
CALL AddFunc
ADD SP, 4          ; 清理参数

; AddFunc
AddFunc PROC
    PUSH BP
    MOV BP, SP
    
    MOV AX, [BP+4] ; 参数 1
    MOV BX, [BP+6] ; 参数 2
    ADD AX, BX
    
    POP BP
    RET
AddFunc ENDP

局部变量的作用

局部变量存储在栈中，每个函数调用有独立的副本：

不会污染全局数据
递归调用时自动隔离
函数返回后自动释放

调用约定

约定	参数传递	栈清理	寄存器保护
C 调用	栈（右到左）	调用者	EAX/ECX/EDX 不保护
Pascal	栈（左到右）	被调用者	所有寄存器保护
fastcall	寄存器 + 栈	调用者	混合

总结

子程序是汇编走向工程化的关键。掌握栈帧管理，你就能写出结构清晰、可维护的汇编代码。

下一篇：《宏指令与高级汇编技术：代码复用与元编程》

标志位详解：CF/ZF/SF/OF 如何影响程序流程

Sat, 13 Jun 2026 10:00:00 +0800

FLAGS 寄存器

CPU 执行指令后，会自动更新 FLAGS 中的状态位。这些标志位决定了程序的分支走向。

核心标志位

标志	全称	何时置 1	示例
ZF	Zero	结果为 0	`SUB AX, AX` → ZF=1
CF	Carry	无符号溢出（进位/借位）	`ADD AL, 0FFh` → CF=1
SF	Sign	结果为负（最高位=1）	`SUB AL, 5` → SF=1
OF	Overflow	有符号溢出	`ADD AL, 7Fh, 1` → OF=1

条件跳转指令

跳转指令根据标志位决定走向：

指令	含义	检查标志
JE/JZ	等于/为零	ZF=1
JNE/JNZ	不等于/非零	ZF=0
JC	有进位	CF=1
JNC	无进位	CF=0
JG	大于（有符号）	ZF=0 且 SF=OF
JA	大于（无符号）	CF=0 且 ZF=0

实战：判断两数大小

MOV AX, 100
MOV BX, 200
CMP AX, BX      ; 实际执行 AX - BX

JG  GREATER     ; 如果 AX > BX（有符号）
JL  LESS        ; 如果 AX < BX
JE  EQUAL       ; 如果相等

CF 与 OF 的区别

这是初学者最容易混淆的点：

CF 关注无符号数：0FFh + 1 = 100h → 进位了，CF=1
OF 关注有符号数：7Fh + 1 = 80h → 从 +127 变成 -128，溢出了，OF=1

总结

标志位是汇编语言的"红绿灯"。掌握它们，你才能写出有逻辑判断的程序。

下一篇：《汇编语言语法与程序格式：段定义、数据声明与伪指令》

堆栈操作深度解析：PUSH/POP 与函数调用的秘密

Sat, 13 Jun 2026 10:00:00 +0800

栈是什么？

栈（Stack）是一种 后进先出（LIFO） 的数据结构。在汇编中，它由 SS:SP 指向。

PUSH 与 POP

1
2

PUSH AX    ; SP = SP - 2, [SS:SP] = AX
POP  BX    ; BX = [SS:SP], SP = SP + 2

PUSH：先将 SP 减 2，再写入数据
POP：先读取数据，再将 SP 加 2

栈帧结构

函数调用时，栈中会形成栈帧：

高地址
  +----------------+
  |    参数 2      |
  +----------------+
  |    参数 1      |
  +----------------+
  |  返回地址      | ← CALL 自动压入
  +----------------+
  |  旧 BP         | ← PUSH BP
  +----------------+ ← BP (当前栈帧基址)
  |  局部变量 1    |
  +----------------+
  |  局部变量 2    |
  +----------------+ ← SP (栈顶)
低地址

函数调用流程

; 调用者
PUSH 参数 2
PUSH 参数 1
CALL FUNC

; 被调用者 FUNC:
PUSH BP        ; 保存旧栈帧
MOV BP, SP     ; 设置新栈帧
SUB SP, 4      ; 分配局部变量空间

; ... 函数体 ...

MOV SP, BP     ; 恢复 SP
POP BP         ; 恢复旧栈帧
RET            ; 弹出返回地址并跳转

为什么需要栈？

保存返回地址：CALL 自动将下一条指令地址压栈
传递参数：通过栈传递，避免寄存器不够用
保存上下文：子程序可以随意使用寄存器，退出前恢复
局部变量：每个函数有独立的栈帧，互不干扰

总结

理解栈，就理解了程序执行的"时间线"。每一次函数调用，都是在栈上翻开新的一页。

下一篇：《标志位详解：CF/ZF/SF/OF 如何影响程序流程》

分支与循环：JMP/LOOP/条件跳转的结构化编程

Sat, 13 Jun 2026 10:00:00 +0800

从高级语言到汇编

高级语言的控制流：

1
2

if (a > b) { c = 1; } else { c = 2; }
for (i=0; i<10; i++) { sum += i; }

汇编的实现：

IF-ELSE 结构

MOV AX, A
CMP AX, B
JLE ELSE_PART     ; 如果 A <= B，跳到 ELSE

MOV C, 1          ; IF 分支
JMP END_IF

ELSE_PART:
MOV C, 2          ; ELSE 分支

END_IF:

FOR 循环

MOV CX, 10        ; 循环次数
MOV AX, 0         ; sum = 0

LOOP_START:
ADD AX, CX        ; sum += i
LOOP LOOP_START   ; CX--, 若 CX≠0 则跳转

MOV SUM, AX

WHILE 循环

; while (a > 0) { a--; }
MOV AX, A

WHILE_CHECK:
CMP AX, 0
JLE WHILE_END     ; 如果 a <= 0，退出循环

DEC AX
JMP WHILE_CHECK

WHILE_END:
MOV A, AX

LOOP 指令详解

LOOP label 等价于：

1
2

DEC CX
JNZ label

CX 自动减 1
若 CX ≠ 0 则跳转

总结

掌握这些模式，你就能用汇编实现任何高级语言的控制逻辑。汇编的跳转虽然原始，但逻辑清晰，性能极致。

下一篇：《子程序设计：参数传递、局部变量与调用约定》

汇编语言语法与程序格式：段定义、数据声明与伪指令

Sat, 13 Jun 2026 10:00:00 +0800

汇编程序的骨架

一个完整的汇编程序包含三个基本段：

STACK SEGMENT STACK
    DW 100h DUP(?)
STACK ENDS

DATA SEGMENT
    VAR1 DB 10
    VAR2 DW 1234h
DATA ENDS

CODE SEGMENT
    ASSUME CS:CODE, DS:DATA, SS:STACK
START:
    MOV AX, DATA
    MOV DS, AX
    ; 程序主体
    MOV AH, 4Ch
    INT 21h
CODE ENDS
    END START

数据声明伪指令

伪指令	含义	占用字节	示例
DB	Define Byte	1	`MSG DB 'Hello$'`
DW	Define Word	2	`NUM DW 1234h`
DD	Define Double Word	4	`ADDR DD 0`
DUP	重复定义	N	`BUF DB 100 DUP(0)`

常用伪指令

伪指令	功能
ASSUME	告诉编译器段寄存器与段的关系
PROC/ENDP	定义子程序
EQU	定义常量（`MAX EQU 100`）
ORG	设置起始地址
END	程序结束标记

命名规范

段名：大写，如 DATA, CODE, STACK
标签：有意义，如 LOOP_START, EXIT
变量：前缀标识类型，如 bVal（Byte）, wVal（Word）

总结

规范的格式和清晰的命名，让汇编代码从"天书"变成"工程"。

下一篇：《分支与循环：JMP/LOOP/条件跳转的结构化编程》

寻址方式终极指南：7 种寻址模式与性能分析

Sat, 13 Jun 2026 10:00:00 +0800

寻址的本质

CPU 执行指令时，需要找到操作数的位置。寻址方式就是告诉 CPU 去哪里找数据。

立即数寻址

数据直接在指令中：

`1`	`MOV AX, 1234h`

最快，无需访问内存
数据随指令一起从代码段取出

寄存器寻址

操作数在寄存器中：

`1`	`MOV AX, BX`

极快，寄存器在 CPU 内部
无内存访问延迟

直接寻址

操作数在内存的固定地址：

`1`	`MOV AX, [2000h]`

访问 DS:2000h 处的数据
地址在编译时确定

寄存器间接寻址

地址在寄存器中：

`1`	`MOV AX, [BX]`

地址 = DS:BX
适合遍历数组

基址寻址

`1`	`MOV AX, [BP+10h]`

地址 = SS:BP + 10h（注意用 SS 段）
常用于访问局部变量

变址寻址

`1`	`MOV AX, [SI+50h]`

地址 = DS:SI + 50h
适合数组元素访问

基址变址寻址

`1`	`MOV AX, [BX+SI+100h]`

地址 = DS:BX + SI + 100h
最灵活，适合二维数组或结构体成员访问

性能对比

寻址方式	内存访问次数	相对速度
立即数	0	⚡ 最快
寄存器	0	⚡ 最快
直接	1	较快
间接	1	中等
基址变址	1	较慢（计算地址）

总结

选择合适的寻址方式，是汇编性能优化的第一步。简单变量用直接寻址，数组用变址，结构体用基址变址。

下一篇：《堆栈操作深度解析：PUSH/POP 与函数调用的秘密》

8086 指令系统全景图：数据传送、算术运算与逻辑操作

Sat, 13 Jun 2026 09:00:00 +0800

8086 指令分类

8086 有一百多条指令，但常用的只有 30 多条。我们将它们分为三大类：

一、数据传送指令

指令	功能	示例
MOV	复制数据	`MOV AX, BX`
XCHG	交换数据	`XCHG AL, BL`
PUSH/POP	压栈/出栈	`PUSH AX`
LEA	加载有效地址	`LEA BX, VAR`

注意事项：

MOV 不能在两个内存单元之间直接传送
段寄存器不能直接接收立即数
PUSH/POP 操作单位是字（16 位）

二、算术运算指令

指令	功能	影响标志位	示例
ADD	加法	CF, ZF, SF, OF	`ADD AX, 5`
SUB	减法	CF, ZF, SF, OF	`SUB BX, CX`
MUL	无符号乘法	CF, OF	`MUL BL`
DIV	无符号除法	异常	`DIV CX`

乘除法细节：

MUL BL：AL × BL → AX
DIV CX：DX:AX ÷ CX → AX(商) DX(余数)

三、逻辑运算指令

指令	功能	示例	应用场景
AND	按位与	`AND AL, 0Fh`	清零高 4 位
OR	按位或	`OR AH, 80h`	设置最高位
XOR	按位异或	`XOR AX, AX`	快速清零
NOT	按位取反	`NOT AL`	求反码
SHL/SHR	逻辑移位	`SHL AL, 1`	×2 或 ÷2

实战：用 XOR 清零

`1`	`XOR AX, AX ; 比 MOV AX, 0 更快，且只占 2 字节`

这是汇编优化中的经典技巧，也是现代编译器常用的优化手段。

总结

掌握这 30 条指令，你就能写出 80% 的汇编程序。剩下的指令多在特定场景下使用。

下一篇：《寻址方式终极指南：7 种寻址模式与性能分析》

第一条汇编程序：Hello World 的底层实现

Sat, 13 Jun 2026 09:00:00 +0800

经典的 Hello World

在高级语言中，print("Hello World") 只需要一行。在汇编中，你需要：

定义数据段
设置显示功能号
调用中断
设置退出功能号
再次调用中断

完整源码

DATA SEGMENT
    MSG DB 'Hello, Assembly World!$'
DATA ENDS

CODE SEGMENT
    ASSUME CS:CODE, DS:DATA
START:
    MOV AX, DATA
    MOV DS, AX          ; 初始化 DS 寄存器

    MOV DX, OFFSET MSG  ; 字符串偏移地址放入 DX
    MOV AH, 09h         ; DOS 中断 09h: 显示字符串
    INT 21h             ; 调用中断

    MOV AH, 4Ch         ; DOS 中断 4Ch: 退出程序
    INT 21h

CODE ENDS
    END START

逐行解析

1. 数据段定义

1
2
3

DATA SEGMENT
    MSG DB 'Hello, Assembly World!$'
DATA ENDS

DB 定义字节数据
$ 是字符串结束符（DOS 09h 中断要求）

2. 初始化 DS

1
2

MOV AX, DATA
MOV DS, AX

CPU 不允许直接将立即数送入段寄存器，必须通过通用寄存器中转。

3. 调用显示中断

1
2
3

MOV AH, 09h
MOV DX, OFFSET MSG
INT 21h

AH=09h 告诉 DOS：“我要显示字符串”
DX 存放字符串的偏移地址

4. 安全退出

1
2

MOV AH, 4Ch
INT 21h

如果不写退出代码，程序会继续执行内存中的随机数据，导致崩溃。

编译与运行

1
2
3

masm hello.asm;   # 生成 hello.obj
link hello.obj;   # 生成 hello.exe
hello.exe         # 运行

总结

第一个汇编程序虽然只有十几行，但它涵盖了汇编的核心要素：段定义、寄存器操作、中断调用。

下一篇：《8086 指令系统全景图：数据传送、算术运算与逻辑操作》

汇编语言到底是什么？为什么它至今仍然重要

Sat, 13 Jun 2026 09:00:00 +0800

为什么还要学汇编？

在 AI 编程、高级语言框架满天飞的今天，很多人问：“汇编还有用吗？”

答案是：有用，且不可替代。

汇编语言不是用来写业务的，它是用来理解计算机如何工作的。当你掌握了汇编，你看到的不再是"代码"，而是 CPU 在内存中搬运数据的过程。

从机器码到助记符

计算机只认识 0 和 1。早期的程序员直接写二进制指令：

`1`	`10110000 01100001 ; 将数字 97 (ASCII 'a') 放入 AL 寄存器`

这太反人类了。于是发明了助记符：

`1`	`MOV AL, 61h ; 将 61h 移入 AL 寄存器`

这就是汇编语言的本质：机器指令的人类可读包装。它与机器码是一一对应的关系。

高级语言的"黑盒"

我们用 Python/Java 写 a = b + c，编译器会做大量优化：

寄存器分配
指令重排
内联展开

你看到的是一行代码，机器执行的是几十条指令。汇编语言打破了这个黑盒，让你看到每一步的代价。

汇编的现代应用场景

领域	为什么需要汇编
逆向工程	分析恶意软件、CrackMe，没有源码只能看汇编
系统编程	操作系统内核、Bootloader、驱动开发
嵌入式	MCU 资源受限，需要极致性能优化
安全研究	漏洞利用、Shellcode 编写、ROP 链构造
性能调优	关键热点函数手写汇编，榨干 CPU 性能

总结

汇编语言不是用来和高级语言"抢饭碗"的，它是程序员的内功。

学好汇编，你看代码的眼光会从"语法层"下沉到"机器层"。这是一种质的飞跃。

下一篇：《微型计算机系统结构速览：寄存器、总线与内存》

汇编语言环境搭建：MASM/TASM/DOSBox 从零配置

Sat, 13 Jun 2026 09:00:00 +0800

为什么需要 DOSBox？

现代操作系统（Windows 10/11, macOS, Linux）都是 32/64 位系统，无法直接运行 16 位的 DOS 程序。DOSBox 是一个 x86 模拟器，完美还原 DOS 环境。

安装步骤

1. 下载 DOSBox

官网：https://www.dosbox.com/
Windows: 下载安装包
macOS: brew install dosbox
Linux: sudo apt install dosbox

2. 准备汇编工具链

下载并解压到 D:\ASM（或对应目录）：

MASM 5.0/6.11（微软汇编器）
TASM 5.0（Borland 汇编器）
LINK.exe（链接器）
DEBUG.exe（调试工具）

3. 挂载目录

启动 DOSBox 后，输入：

1
2

mount c D:\ASM
c:

编写一键编译脚本

每次手动敲 masm、link 太麻烦了。创建一个 build.bat：

@echo off
echo [1/2] 汇编中...
masm %1.asm;
if errorlevel 1 goto error

echo [2/2] 链接中...
link %1.obj;
if errorlevel 1 goto error

echo ✅ 编译成功！执行 %1.exe
%1.exe
goto end

:error
echo ❌ 编译失败，请检查错误信息

:end

使用方法：build hello 即可自动完成汇编 → 链接 → 运行。

总结

环境搭建是第一步，虽然繁琐，但配好之后写汇编会非常顺畅。下一篇我们将用这个环境写出第一个程序。

下一篇：《第一条汇编程序：Hello World 的底层实现》

微型计算机系统结构速览：寄存器、总线与内存

Sat, 13 Jun 2026 09:00:00 +0800

CPU 的内部视角

汇编语言的操作对象不是变量，而是寄存器和内存地址。理解 8086 的内部结构，是写好汇编的前提。

8086 的四大通用寄存器

寄存器	全称	主要用途	拆分为高/低 8 位
AX	Accumulator	算术运算、I/O 操作、中断调用	AH / AL
BX	Base	基址寻址、内存指针	BH / BL
CX	Count	循环计数器、位移量	CH / CL
DX	Data	I/O 端口地址、乘除法高位	DH / DL

为什么要拆分？ 因为 8086 支持 8 位和 16 位操作。你可以单独操作 AL 而不影响 AH，这在处理 ASCII 字符时非常高效。

段寄存器：分段内存模型

8086 只有 20 位地址总线，但内部寄存器只有 16 位（最大 64KB）。如何访问 1MB 内存？

答案是段寄存器 + 偏移地址：

`1`	`物理地址 = 段地址 × 16 + 偏移地址`

段寄存器	用途
CS	代码段（Code Segment）
DS	数据段（Data Segment）
SS	堆栈段（Stack Segment）
ES	附加段（Extra Segment）

标志寄存器 FLAGS

CPU 执行每条指令后，会更新 FLAGS 中的状态位：

ZF (Zero Flag)：结果为 0 则置 1
CF (Carry Flag)：进位/借位标志
SF (Sign Flag)：符号标志（最高位）
OF (Overflow Flag)：溢出标志

这些标志位决定了 JE（等于则跳转）、JNE（不等于则跳转）等条件跳转指令的走向。

总线系统

CPU 通过总线与外部通信：

地址总线（20 位）：决定能访问多少内存（1MB）
数据总线（16 位）：决定一次能读写多少数据（2 字节）
控制总线：读写信号、中断请求、时钟同步

总结

8086 的架构虽然古老，但现代 x86_64 依然保留了这些核心概念（寄存器、段、标志位）。理解了 8086，再看现代 CPU 就会觉得"万变不离其宗"。

下一篇：《汇编语言环境搭建：MASM/TASM/DOSBox 从零配置》

汇编语言 on 文艺技术笔记

10 个经典汇编程序实例：从排序到字符串处理

实例 1：冒泡排序

实例 2：字符串长度

实例 3：十六进制转十进制

实例 4：阶乘

实例 5：斐波那契数列

更多实例

总结

汇编语言调试技巧：Debug 工具与逆向分析基础

DEBUG.exe 基础

启动

常用命令

单步调试示例

Turbo Debugger (TD)

GDB 调试（32 位 Linux）

逆向分析基础

静态分析

动态分析

常见调试技巧

总结

汇编语言实验指导：5 个动手实验从易到难

实验 1：环境搭建与 Hello World

实验 2：计算器程序

实验 3：学生成绩管理

实验 4：文件加密工具

实验 5：Bootloader 原型

总结

汇编在现代系统中的位置：从 Bootloader 到逆向工程

汇编过时了吗？

场景 1：Bootloader 与 UEFI

场景 2：操作系统内核

场景 3：漏洞分析与利用

场景 4：性能优化

场景 5：游戏与反作弊

学习建议

总结

内存管理实战：直接访问显存与 VGA 文本模式

VGA 文本模式

显存结构

属性字节

实战：彩色输出

实战：滚动窗口

总结

DOS 中断调用实战：INT 21h 文件/键盘/显示操作

什么是 DOS 中断？

功能号机制

常用功能号速查

实战：文件读写

总结

多模块程序设计与混合编程：C 语言调用汇编

为什么混合编程？

C 调用汇编

汇编文件（add.asm）

C 文件（main.c）

编译链接

汇编调用 C 库

参数传递约定（32 位）

64 位差异

总结

宏指令与高级汇编技术：代码复用与元编程

什么是宏指令？

基本语法

带参数宏

局部标号

条件汇编

循环展开

宏 vs 子程序

总结

输入输出与中断程序设计：硬件交互的底层逻辑

I/O 端口

端口读写指令

中断向量表（IVT）

中断处理流程

自定义中断处理程序

BIOS 中断

总结

子程序设计：参数传递、局部变量与调用约定

为什么需要子程序？

子程序的基本结构