汇编语言 第四版 王爽著（上） #45
Labels
StudyNotes
读书笔记
Comments
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
{{ message }}
汇编语言 读书笔记
[TOC]
进制计算转化验证时可以使用计算机系统自带计算器开启编程模式，eg：MacOS
1 基础知识
Byte 字节，bit 比特
1KB = 1024Byte(B) = 8 * 1024bit
2 寄存器
2.1 通用寄存器
AX = AH + AL，高字节位，低字节位
2.2 字在寄存器中的存储
十六进制，汇编
H结尾，C语言0x开头Byte 字节， word 字，一个字由两个字节组成
2.3 几条汇编指令
AH AL 在使用中都是作为独立的 8 位寄存器
检测点2.1
62627 = 0xf4a3
(1) 写出每条汇编指令执行后相关寄存器中的值：
(2) 只能使用目前学过的汇编指令，最多使用4条指令，编程计算2的4次方：
2.4 物理地址
CPU 通过地址总线送入存储器的必须是一个内存单元的物理地址
2.5 十六位结构的CPU
2.6 8086CPU 给出物理地址的方法
段地址、偏移地址地址加法器：物理地址=段地址x16+偏移地址
“段地址x16” 的常用说法是左移4位(通常指二进制位)
由观察数据
2H二进制形式10B，对其进行左移运算可以得到：一个X进制的数据左移1位，相当于乘以X2.7 “段地址x16+偏移地址=物理地址”的本质含义
本质含义：CPU 在访问内存时，用一个基础地址（段地址x16）和一个相对于基础地址的偏移地址相加，给出内存单元的物理地址也就是“基础地址+偏移地址=物理地址”
三种方式表示图书馆的地址：
基础地址到体育馆，再从体育馆走826偏移地址（以基础地址为起点）到图书馆段地址,第二张写上826偏移地址，再运算200x10+826=28268086CPU 就相当于提供两张3位数据纸条的 CPU
2.8 段的概念
小结：
检测点2.2
公式：段地址(SA)x16 + 偏移地址(EA) = 物理地址
这里的 16 是十进制，计算时需要先进行转换
2.9 段寄存器
8086CPU 有四个段寄存器：CS、DS、SS、ES。需要访问内存时提供内存单元的段地址。本章只看 CS
2.10 CS 和 IP
CS 为代码段寄存器，IP 为指令指针寄存器
在内存中，指令和数据没有任何区别，都是二进制信息，CPU 在工作的时候把有的信息看作指令，有的看作数据。**CPU 将 CS、IP 中的内容当作指令的段地址和偏移地址，用它们合成指令的物理地址，到内存中读取指令码，执行。**如果说，内存中的一段信息曾被 CPU 执行过的话，那么，它所在的内存单元必然被 CS:IP 指向过
2.11 修改 CS、IP 的指令
jmp指令可以修改 CS、IP。jmp 段地址:偏移地址（段内转移）：用指令中给出的段地址修改 CS，偏移地址修改 IPjmp 某一合法寄存器（段间转移）：用寄存器中的值修改 IP问题2.3
指令执行顺序为：
2.12 代码段
对于 8086PC 机，可以根据需求，将一组内存单元定义为一个段。
我们可以将长度为 N(N<=64KB) 的一组代码，存在一组地址连续、起始地址为 16 的倍数的内存单元中，我们可以认为，这段内存是用来存放代码的，从而定义了一个代码段。
2.9~2.12 小结
检测点2.3
下面指令执行后，CPU 几次修改 IP？都是在什么时候？最后 IP 中的值是多少？
遵循
指令被送入指令缓冲器 -> IP值自动增加 -> 指令被执行的顺序：四次修改mov ax,bx被送到指令缓冲器内，IP 自动增加【第一次修改】mov ax,bx被执行sub ax,ax被送到指令缓冲器内，IP 自动增加【第二次修改】sub ax,ax被执行，ax=ax-ax,ax中的内容为0000Hjmp ax被送到指令缓冲器中，IP 自动增加【第三次修改】jmp ax被执行，将 IP 的内容修改成0000H【第四次修改】Debug 的一些功能
实验1 查看 CPU 和内存，用机器指令和汇编指令编程
由于使用 MAC 所有下面都用实验楼中的环境编码
汇编语言（第 2 版，郑晓薇著）配套实验 免费
3 寄存器(内存访问)
3.1 内存中字的存储
任何两个地址连续的内存单元，N 号单元和 N+1 号单元，可以将它们看成两个内存单元，也可以看成一个地址为 N 的字单元中的低位字节单元和高位字节单元
例如：
AX = 4E20H，AH = 4EH(高位)，AL = 20H(低位)，AX 存放在2地址字单元（2单元+3单元）中，2单元存放低位20H，3单元存放高位4EH3.2 DS 和[address]
[···]表示一个内存单元，[0]中的 0 表示内存单元的偏移地址问题3.2
写几条指令，将 al 中的数据送入内存单元 10000H 中
分析：10000H = 1000H x 16 + 0H 可以表示为 1000:0，地址段 1000H，偏移地址 0
3.3 字的传送
3.4 mov、add、sub 指令
mov 寄存器，数据 例如：mov ax,8
mov 寄存器，寄存器 例如：mov ax,bx
mov 寄存器，内存单元 例如：mov ax,[0]
mov 内存单元，寄存器 例如：mov [0],ax
mov 段寄存器，寄存器 例如：mov ds,ax
add,sub 不能对段寄存器进行操作，其它与 mov 一致
3.5 数据段
将一组长度为 N(N<=64KB)、地址连续、起始地址为 16 倍数的内存单元当作专门储存数据的内存单元，从而定义一个数据段
比如，将 123B0H~123B9H 的内存单元定义为数据段。现在要累加这个数据段中的前 3 个单元中的数据，代码如下：
问题 3.5
写几条指令，累加数据段中的前 3 个字型数据，注意，一个字型数据占两个单元，所以偏移地址为 0、2、4
3.1~3.5 小结
检测点 3.1
（2）：内存中的情况如图所示。
各寄存器的初始值：CS=2000H，IP=0，DS=1000H, AX=0，BX=0；
数据和程序没有区别，本质都是二进制 01 码，当内存单元被 CS:IP 指定时其存储就被当作程序执行。当内存单元被 DS:[address] 指定时其存储的就是数据。
3.6 栈
LIFO（Last In First Out，后进先出)
3.7 CPU 提供的栈机制
PUSH入栈，POP出栈，8086CPU 的入栈和出栈都是以字为单位进行的。字型数据用两个单元存放，高地址单元存放高 8 位，低地址单元存放低 8 位。
任意时刻，SS:SP 指向栈顶元素。 SS 段寄存器存放段地址，SP 寄存器存放偏移地址
3.8 栈顶超界的问题
8086CPU不保证我们对栈的操作不会超界。它只知道栈顶在何处（由 SS:SP 指示），而不知道栈空间有多大。这点就好像它只知道当前要执行的指令在何处（由 CS:IP 指示），而不知道要执行的指令有多少。
从这两点可以看出 8086CPU 的工作机理，只考虑当前的情况：当前栈顶在何处、要执行的指令是哪一条
3.9 push、pop 指令
可以在寄存器和内存（栈空间也是内存空间的一部分，它只是一段可以以特殊方式今昔访问的内存空间）之间传递数据
指令执行时，CPU 要知道内存单元的地址，可以在 push、pop 指令中只给出内存单元的偏移地址，段地址在指令执行时，CPU 从 ds 中取得
问题 3.7
编程，将 10000H~1000FH 这段空间当作栈，初始状态栈为空，将 AX、BX、DS 中的数据入栈
问题 3.8
编程：
栈的综述
3.10 栈段
我们可以将长度为 N(N<=64KB)的一组地址连续、起始地址为 16 的倍数的内存单元，当作栈空间来用，从而定义了一个栈段
段的综述
将一段内存定义为一个段，用一个段地址指示段，用偏移地址访问段内的单元。
若要让 CPU 按照我们的安排来访问这些段，就要
由上可见：CS:IP 指向地址当作代码，SS:SP 指向地址当作栈
比如将 10000H~1001FH 安排为代码段，并在里面存储如下代码：
设置 CS=1000H，IP=0，这段代码将执行。10000H~1001FH，即是代码段，又是栈段和数据段。
一段内存，可以即是代码的存储空间，又是数据的存储空间，还可以是栈空间，也可以什么都不是。关键在于 CPU 中的寄存器设置，即 CS、IP、SS、SP、DS 的指向
检测点 3.2
（1）补全下面的程序，使其可以将 10000H
1000FH 中的 8 个字，逆序复制到 20000H2000FH 中。逆序复制的含义如下图所示：（2）由（1）得到的再逆序回去
代码段中使用 pop，所以 sp 为栈顶地址 0000H
实验2 用机器指令和汇编指令编程
TODO
第4章 第一个程序
4.1 一个源程序从写出到执行的过程
编写汇编源程序
对源程序进行编译连接
执行可执行文件中的程序
4.2 源程序
1.伪指令
汇编语言源程序中包含两种指令
汇编指令- 有对应的机器码指令，可以被编译为机器指令，被 CPU 执行伪指令- 没有对应的机器码指令，不被 CPU 执行，编译器来执行，根据伪指令来进行相关的编译工作上面程序中出现了 3 中伪指令
段名 segment 段名 ends- 成对使用，定义一个段（用来存放代码、数据或栈空间来使用），ends的含义可理解为“end segment”end- 汇编程序的结束标记assume- “假设”，它假设某一段寄存器和程序从的某一个用segment...ends定义的段相关联2.源程序中的“程序”
用汇编语言写的源程序，包括伪指令和汇编指令。
将源程序文件中的所有内容称为 源程序，源程序中最终由计算机执行、处理的指令或数据，称为 “程序”
3.标号
一个标号指代了一个地址。比如：
codesg在segment的前面，作为一个段的名称，这个段的名称最终将被编译、连接程序处理为一个段的段地址4.程序的结构
任务：编程运算 2^3。
（1）定义一个段，名称为 abc
（2）写入汇编指令，实现任务
（3）指出在何处结束
abc segment mov ax,2 add ax,ax add ax,ax abc ends + end（4）abc 被当作代码段来用，所以将 abc 和 cs 联系起来
+ assume cs:abc abc segment mov ax,2 add ax,ax add ax,ax abc ends end5.程序返回
一个程序结束后，将 CPU 的控制权交还给使它运行的程序，这个过程为：程序返回
上述代码中的两条指令所实现的功能就是程序返回
6.语法错误和逻辑错误
一般来说，编译时被编译器发现的错误是语法错误，运行时发生的错误是逻辑错误
4.3 编辑源程序
4.4 编译
使用 masm
1.asm->1.obj如果编译的过程中出现错误，那么将得不到目标文件。一般来说，有两类错误使我们得不到目标文件
在编译过程中，提供一个输入（源程序文件）。最多可以得到 3 个输出：目标文件（.obj）、列表文件（.list)、交叉引用文件（.crf）。目标文件是要得到的最终结果
4.5 连接
使用 link
1.obj->1.exe连接的作用：
4.6 以简化的方式进行编译和连接
masm c:\1;当前路径下生成 1.obj，并忽略中间文件的生成link 1;当前路径下生成可执行文件 1.exe，并忽略中间文件的生成4.7 1.exe 的执行
4.8 谁将可执行文件中的程序装载进入内存并使它运行？
观察 1.exe 的执行过程，思考问题
c:\后面输入可执行文件的名字“1”，按 Enter 键。这时思考问题4.1c:\。思考问题4.2问题4.1
此时，有一个正在运行的程序将 1.exe 中的程序加载入内存，这个正在运行的程序是什么？将程序加载入内存后，如何是使程序运行？
问题4.2
程序运行结束后，返回到哪里？
汇编程序从写出到执行的过程
编程(Edit) -> 1.asm -> 编译(masm) -> 1.obj -> 连接(link) -> 1.exe -> 加载(command) -> 内存中的程序 -> 运行(CPU)
操作系统的外壳（shell）
操作系统是由多个功能模块组成的庞大、复杂的软件系统。任何通用的操作系统，都要提供一个称为 shell（外壳）的程序，用户（操作人员）使用这个程序来操作计算机系统进行工作。
DOS 中有一个程序 command.com，这个程序在 DOS 中称为命令解释器，也就是 DOS 系统的 shell。
DOS 启动时，先完成其他重要的初始化工作，然后运行 command.com，执行完其它的相关任务后，在屏幕上显示出由当前路径组成的提示符，比如：“c:\”或“c:\windows”等，然后等待用户的输入。
用户可以输入要执行的命令，比如：cd、dir、type 等，这些命令由 command 执行，执行完这些命令后，再次显示由当前盘符和当前路径组成的提示符，等待用户的输入。
如果用户要执行一个程序，则输入改程序的可执行文件的名称，command 首先根据文件名找到可执行文件，然后将这个可执行文件加载入内存，设置 CS:IP 执行程序的入口。此后 command 暂停运行，CPU 运行程序。结束后返回到 command 中，command 再次显示由当前盘符和当前路径组成的提示符，等待用户输入。
在 DOS 中，command 处理各种输入：命令或要执行的程序的文件名。我们就是通过 command 来进行工作的。
4.9 程序执行过程的跟踪
debug 1.exe，Debug将程序从可执行文件加载入内存U 命令查看其它指令
T 命令单步执行程序中的每一条指令，观察指令的执行结果
到
int 21时，要使用 P 命令执行（不做深入研究，记住int 21使用 P 命令执行即可）实验3 编程、编译、连接、跟踪
（1）将下面的程序保存为 t1.asm 文件，生成可执行文件 t1.exe
在 DOSBox 中运行下面命令：
（2）用 Debug 跟踪 t1.exe 的执行过程，写出每一步执行后，相关寄存器中的内容和栈顶的内容
使用
debug t1.exe加载程序后：ax=FFFFH;bx=0000H;
cx=0016H(表示程序长度是 22 个字节)
ds=075AH(表示操作系统给 t1.exe 分配的空间区域的段地址)
cs=076AH(cs=ds+10H)
ss=0769;sp=0000H; 使用
d 0769:0 1命令查看栈顶内容为 0000H运行结果显示的汇编指令（
MOV AX,2000）为下一条即将执行的指令mov ax,2000H后ax=2000H；栈顶内容为 0000H
mov ss,ax后，自动连带执行第三条mov sp,0、第四条指令add sp,10这里注意第四条执行，10 的十六进制为 000AH；ss=2000H；栈顶内容为 0000H
pop ax后sp=000AH；栈顶内容为 0000H
pop bx后sp=sp+2=000CH；栈顶内容为 0000H
运行步骤结果显示
debug t1.exe载入程序后t查看寄存器的信息d SS:SP SP+1查看SP(指定地址1)到SP+1(指定地址2)内存单元的内容。使用
p指令执行int 21H（3）PSP 的头部两个字节是 CD 20，用 Debug 加载 t1.exe，查看 PSP 的内容
第五章 [BX]和 loop 指令
（1）[bx]和内存单元的描述
[bx]和[0]有些类似
完整地描述一个内存单元需要两种信息：1、内存单元的地址；2、内存单元的长度（类型）。
用 [0] 表示一个内存单元时，0 表示单元的偏移地址，段地址默认在 ds 中，单元的长度（类型）可以由指令中的其它操作对象（比如寄存器）指出。
（2）loop
这个指令和循环有关
（3）我们定义的描述性符号：“()”
以后我们将使用一个描述性符号“()”来表示一个寄存器或一个内存单元中的内容。比如：
(ax)表示 ax 中的内容、(al)表示 al 中的内容20000H表示内存 20000H 的内容（()中的内存单元地址为物理地址）((ds)*16+(bx))表示为：注意："()"中的元素可以有 3 中类型：1、寄存器名；2、段寄存器名；3、内存单元的物理地址（一个 20 位数据）。比如：
(ax)、(ds)、(al)、(cx)、(20000H)、((ds)*16+(bx))等是正确的用法(2000:0)、((ds):1000H)等是不正确的用法(X)的应用，比如：(X)所表示的数据有两种类型：1、字节；2、字；由寄存器名或具体的运算决定，比如：(al)、(bl)、(cl)等得到的数据为字节型；(ds)、(ax)、(bx)等得到的数据为字型；(al)=(20000H)、则 (20000H) 得到的数据为字节型；(ax)=(20000H)、则 (20000H) 得到的数据为字型；（4）约定符号 idata 表示常量
在 Debug 中写过类似的指令：
mov ax,[0]，表示将 ds:0 处的数据送入 ax 中。指令中，在“[...]”里用一个常量 0 表示内存单元的偏移地址。以后，用 idata 表示常量。比如：5.1 [BX]
5.2 Loop 指令
格式是：loop 标号，CPU 执行 loop 指令的时候，要进行两步操作：
通常我们用 loop 指令来实现循环功能，cx 中存放循环次数
（1）编程计算 2^3
（2）编程计算 2^12
用 cx 和 loop 指令配合实现循环功能的程序框架如下：
问题5.2
编程，用加法计算 123*236，结果存在 ax 中。
问题5.3
改进 5.2，提高 123*236 的计算速度。
程序 5.2 做了 236 次加法，可以将 236 加 123 次。先设 (ax)=0，然后循环 123 次 (ax)=(ax)+236，这样可以用 123 次加法实现相同的功能
5.3 在 Debug 中跟踪用 loop 指令实现的循环程序
计算 ffff:0006 单元中的数乘以 3，结果存储在 dx 中。
（1）运算后的结果是否会超出 dx 所能存储的范围？
ffff:0006 单元中的数是一个字节型的数据，范围在 0~255，则用它和 3 相乘结果不大于 65535，可以在 dx 中存放
（2）用循环累加来实现乘法，用哪个寄存器进行累加？
将 ffff:0006 单元中的数赋值给 ax，用 dx 进行累加。先设 (dx)=0，然后做了 3 次 (dx)=(dx)+(ax)
（3）ffff:5 单元是一个字节单元，ax 是一个 16 位寄存器，数据的长度不一样，如何赋值？
注意，这里“赋值”是说让 ax 中的数据的值（数据的大小）和 ffff:0006 单元中的数据的值（数据的大小）相等。8 位数据 01H 和 16 位数据 0001H 的数据长度不一样，但它们的值是相等的。
如何赋值？设 ffff:0006 单元中的数据是 XXH，若要 ax 中的数据的值和 ffff:0006 单元中的相等，ax 中的数据应为 00XXH。所以，若实现 ffff:0006 单元向 ax 赋值，应该令 (ah)=0, (al)=(ffff6H)
注意程序中的第一条指令 mov ax,0ffffh。大于 9FFFH 的十六进制数据 A000H、A001H...C000H、C001H...FFFEH、FFFFH 等，在书写的时候都是以字母开头的。而在汇编程序中，数据不能以字母开头，所以要在前面加 0。比如：9138h 在汇编程序中可以写为“9138h”，而 A000h 在汇编程序中要写为“0A000h”
使用 u 命令查看被 Debug 加载入内存的程序。图中 ds=075A，所以程序在 076A 处（如果不清楚，可以复习 4.9 的内容）。(cs)=076a, (ip)=0, cs:ip 正指向程序的第一条指令。
从 076a:0000~076a:001b 是我们的程序，076a:0014 处是源程序中的指令 loop s，此处标号 s 已经变为了一个地址 0012h。如果在执行“loop 0012”时，cx 减 1 后不为 0，“loop 0012”就把 IP 设置为 0012h，实现跳转
可以使用 g 命令，
g 0012，表示执行程序到当前代码段（段地址在 CS 中）的0012h处5.4 Debug 和汇编编译器 masm 对指令的不同处理
mov ax,[]指令的不同表示mov ax,0处理目前可以将偏移地址送入 bx 寄存器中，用
[bx]的方式来访问内存单元。比如：比较汇编源程序以下指令的含义：
从上面代码可以看出：在汇编源程序中
mov al,ds:[0]，如果没有显示给出，比如mov al,[0]那么编译器 masm 将把指令中的“[idata]”解释为“idata”5.5 loop 和[bx]的联合应用
计算 ffff:0~ffff:b 单元中的数据的和，结果存储在 dx 中。
分析：
使用 loop 指令改写上面程序，可以看到有 12 个相似的程序段，描述：
可以得到最终程序：
5.6 段前缀
上述访问内存单元的指令中，用于显式指明内存单元的段地址的“ds”、“cs”在汇编语言中成为段前缀
5.7 一段安全的空间
向一段内存中写入内容时：
以后需要直接向一段内存中写入内容时，就使用 0:200~0:2ff 这段空间
5.8 段前缀的使用
考虑一个问题，将内存 ffff:0
ffff:b 单元中的数据复制到 0:2000:20b 单元中。分析：
0:20b 单元等同于 0020:00020:b 单元，它们描述的是同一段内存空间0:20b 用 0020:00020:b 面熟，就是为了使目标单元的偏移地址和源始单元的偏移地址从同一数值 0 开始程序 5.8 如下：
因源始单元 ffff:X 和目标单元 0020:X 相距大于 64KB，在不同的 64KB 段里，程序 5.8 中，每次循环要设置两次 ds，这样做法效率不高。可以使用两个段寄存器分别存放源始单元 ffff:X 和目标单元 0020:X 的段地址，这样就可以省略循环中需要重复做 12 次设置 ds 的程序段。改进的程序 5.9 如下：
程序 5.9 中，使用 es 存放目标空间 0020:0
0020:b 的段地址，用 ds 存放源始空间 ffff:0ffff:b 的段地址。访问内存单元的指令mov es:[bx],al中，显式地用段前缀“es”给出单元的段地址，这样就不必在循环中重复设置 ds实验4 [bx]和 loop 的使用
（1）编程，向内存 0:200
0:23F 依次传送数据 063(3FH)先进行分析：
0:23f 与 0020:00020:3f 内存空间一样。牢记公式内存地址=段地址x16+偏移地址（2）编程，向内存 0:200
0:23f 依次传送数据 063(3FH)，程序中只能使用 9 条指令（包括“mov ax,4c00h”和“int 21h”）先进行分析：上题中的 bx、dx 寄存器中的值在每次循环中都是一致的，去掉 dx 就可以了
（3）下面程序的功能是将“mov ax,4c00h”之前的指令复制到内存 0:200 处，补全程序。上机调试，跟踪运行结果
先进行分析：
mov ax,______这里填入 csmov cx,______这里是要填入一个数字，代表循环的次数mov ax,cs到mov ax,4c00h之前的内存占用为 076a:0~076a:17 也就是 17H=23第 6 章 包含多个段的程序
在操作系统环境中，合法地通过操作系统取得的空间都是安全的，因为操作系统不会让一个程序所用的空间和其它程序以及系统自己的空间相冲突。取得空间的方法有两种：
一个程序在被加载的时候取得所需的空间，则必须要在源程序中做出说明。我们通过在源程序中定义段来进行内存空间的获取。
上面是从内存空间获取的角度上谈定义段的问题。我们再从程序规划的角度来谈一下定义段的问题。大多数有用的程序，都要处理数据，使用栈空间，当然也都必须有指令，为了程序设计上的清晰和方便，也都定义不同的段来存放它们。
6.1 在代码段中使用数据
考虑一个问题，编程计算以下 8 个数据的和，结果存在 ax 寄存器中：0123h、0456h、0789h、0abch、0defh、0fedh、0cbah、0987h
“dw”的含义是定义字型数据，即“define word”。在这里，定义了 8 个字型数据，占用空间大小为 16 个字节
程序中的指令就要对这 8 个数据进行累加**可这 8 个数据在哪里？**由于它们在代码段中，程序在运行的时候 CS 中存放代码段的段地址，所以可以从 CS 中得到它们的段地址。**它们的偏移地址是多少呢？**因为用 dw 定义的数据处于代码段的最开始，所以偏移地址为 0，这 8 个数据就在代码段的偏移 0、2、4、6、8、A、C、E 处。程序运行时，它们的地址就是段前缀+偏移，也就是 CS:0、CS:2 等。
程序中，用 bx 存放 2 递增的偏移地址，用循环来进行累加。
使用 Debug 来查看程序：
图中，通过“DS=075A”，得知程序从 076a:0 开始存放。用 u 命令查看程序，看到一些读不懂的指令。
在源程序中，在汇编指令前，有 16 个字节是用 dw 定义的数据，从 16 个字节后才是汇编指令对应的机器码。
用 d 命令清楚的查看程序中前 16 个字节的内容：
从 076a:0010 查看程序要执行的机器指令：
**怎样执行程序中的指令呢？**用 Debug 加载后，可以将 IP 设置为 10H，从而使 CS:IP 指向程序中的第一条指令。让后再用 t、p 或 g 命令执行。因为程序编译后的入口处不是所希望执行的指令，所以只能使用 Debug 来执行程序，正确的做法是指明程序中的入口所在，具体的做法：
在程序的第一条指令的前面加上了一个标号 start，而这个标号在伪指令 end 的后面出现。**end 除了通知编译器程序结束外，还可以通知编译器程序的入口在什么地方。**程序中用 end 指令指明了程序的入口在标号 start 处，也就是说
mov bx,0是第一条指令。在前面的课程中（参见 4.8 节），已经知道在单任务系统中，可执行文件中程序执行过程如下：
若要 CPU 从何处开始执行程序，要在源程序中用“end 标号”指明
6.2 在代码段中使用栈
利用栈将定义的数据逆序存放
dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h思路如下：
问题是，首先要有一段可以当作栈的内存空间。如前所述，这段空间应该由系统来分配。可以在程序中通过定义数据来取得一段空间，然后将这段空间当作栈空间来用。程序如下：
代码段中定义了 16 个字型数据，它们的数值都是 0。这 16 个字型数据的值是多少，对程序来说没有意义。我们用 dw 定义 16 个数据，即在程序中写入了 16 个字型数据，而程序在加载后，将用 32 个字节的内存空间来存放它们。这段内存空间是我们所需要的，程序将它用作栈空间。可见，定义这些数据的最终目的是，通过它们取得一定容量的内存空间。所以在描述 dw 的作用时，可以说它定义数据，也可以说用它开辟内存空间
检测点 6.1
（1）下面的程序实现一次用内存 0:0~0:15 单元中的内容改写程序中的数据，完成程序：
（2）下面的程序实现依次用内存 0:0~0:15 单元中的内容改写程序中的数据，数据的传送用栈来进行。栈空间设置在程序内。补全程序：
6.3 将数据、代码、栈放入不同的段
前面的内容中，在程序中用到了数据和栈，将数据、栈和代码都放到一个段内。这样做有两个问题：
程序 6.4:
下面对程序 6.4 做出说明
（1）定义多个段的方法
定义一个段的方法和前面讲的定义代码段的方法没有区别，只是对于不同的段，要有不同的段名
（2）对段地址的引用
（3）“代码段”、“数据段”、“栈段”完全是开发者的安排
以一个具体的程序再次讨论一下所谓的“代码段”、“数据段”、“栈段”。在汇编程序中，可以定义许多的段，比如在程序 6.4 中，定义了 3 个段，“code”、“data”和“stack”。我们可以分别安排它们存放代码、数据和栈。那么如何让 CPU 按照我们的这种安排来执行这个程序呢？看看源程序中对这 3 个段所做的处理：
这样命名了后 CPU 是否就去执行 code 段中的内容，处理 data 段中的数据，将 stack 当作栈了呢？
当然不是，我们这样命名，仅仅是为了使程序便于阅读。这些名词同 start、s、s0 等标号一样，仅在源程序中存在，CPU 并不知道它们。
assume cs:code,ds:data,ss:stack将 cs、ds 和 ss 分别和 code、data、stack 段相连。这样做了后，CPU 是否会将 cs 指向 code，ds 指向 data，ss 指向 stack，从而按照我们的意图来处理这些段呢？当然也不是，要知道 assume 是伪指令，是由编译器执行的，也是仅在源程序中存在的信息，CPU 并不知道它们。不必深究 assume 的作用，只要知道需要用它将你定义的具有一定用途的段和相关寄存器联系起来就可以了
我们在源程序的最后用
end start说明了程序的入口，这个入口将被写入可执行文件的描述信息，可执行文件中的程序被加载入内存后，CPU 的 CS:IP 被设置指向这个入口，从而开始执行程序中的第一条指令。标号start在 code 段中，这样 CPU 就将 code 段中的内容当作指令来执行了。我们在 code 段中，使用指令：总之，CPU 到底如何处理我们定义的段中的内容，完全是靠程序中具体的汇编指令，和汇编指令对 CS:IP、SS:SP、DS 等寄存器的设置来决定的
实验5 编写、调试具有多个段的程序
这一章内容较少，有些知识需要在实践中掌握。必须完成这个实验。
（1）将下面程序编译、连接，用 Debug 加载、跟踪，然后回答问题
（2）将下面的程序编译、连接，用 Debug 加载、跟踪，然后回答问题
（3）将下面的程序编译、连接，用 Debug 加载跟踪，然后回答问题
（4）如果将（1）、（2）、（3）题中的最后一条伪指令
end start改为end（也就是说不指明程序的入口），则哪个程序仍然可以正确执行？请说明原因（5）程序如下，编写 code 段中的代码，将 a 段和 b 段中的数据依次相加，将结果存储到 c 段中。
（6）程序如下，编写 code 段中的代码，用 push 指令将 a 段中的前 8 个字型数据，逆序存储到 b 段中
The text was updated successfully, but these errors were encountered: