《汇编语言》第三版检测点答案.md · dsapr/AssemblyLanguageTest

# **王爽《汇编语言》第三版检测点答案**

>注：该答案为个人整理所得，如有纰漏，欢迎指正。
## 检测点1.1
---

### 问题
（1） 1个CPU的寻址能力为8KB，那么他的地址总线的宽度为【 】。  
（2） 1KB的存储器有 【 】个存储单元。存储单元编号从【 】到【 】。  
（3） 1KB的存储器可以存储【 】个bit，【 】个Byte。  
（4） 1GB、1MB、1KB分别是【 】Byte。  
（5） 8080、8088、8026、80386的地址总线宽度分别为16根、20根、24根、32根，则他们的寻址能力分别为：【 】(KB)、【 】(MB)、【 】(MB)、【 】(GB)。  
（6） 8080、8088、8086、8026、80386的数据总线宽度分别为8根、8根、16根、16根、32根。则它们一次可以传送的数据为：【 】(B)、【 】(B)、【 】(B)、【 】(B)、【 】(B)。  
（7） 从内存中读取1024字节的数据，8086至少要读【 】次，80386至少要读【 】次。  
（8）在存储器中，数据和程序以【 】形式存放。

### 答案
（1） 1个CPU的寻址能力为8KB，那么他的地址总线的宽度为【 **13** 】。  
（2） 1KB的存储器有 【 **1024** 】个存储单元。存储单元编号从【 **0000** 】到【 **1023** 】。  
（3） 1KB的存储器可以存储【 **1024 x 8** 】个bit，【 **1024** 】个Byte。  
（4） 1GB、1MB、1KB分别是【**1024x1024x1024、1024x1024、1024** 】Byte。  
（5） 8080、8088、8026、80386的地址总线宽度分别为16根、20根、24根、32根，则他们的寻址能力分别为：【 **64** 】(KB)、【 **1** 】(MB)、【 **16** 】(MB)、【 **4** 】(GB)。  
（6） 8080、8088、8086、8026、80386的数据总线宽度分别为8根、8根、16根、16根、32根。则它们一次可以传送的数据为：【 **1** 】(B)、【 **1** 】(B)、【 **2** 】(B)、【 **2** 】(B)、【 **4** 】(B)。  
（7） 从内存中读取1024字节的数据，8086至少要读【 **512** 】次，80386至少要读【 **256** 】次。  
（8）在存储器中，数据和程序以【 **二进制码** 】形式存放。

### 解析
略。

## 检测点2.1
---

### 问题
（1） 写出每条汇编指令执行后相关寄存器中的值。

| 指令 | 寄存器 |
|--|--|
| mov ax, 62627 | AX = __ |
| mov ah, 31H | AX = __ |
| mov al, 23H | AX = __ |
| add ax, ax | AX = __ |
| mov bx, 826CH | BX = __ |
| mov cx, ax | CX = __ |
| mov ax, bx | AX = __ |
| add ax, bx | AX = __ |
| mov al, bh | AX = __ |
| mov ah, bl | AX = __ |
| add ah, ah | AX = __ |
| add al, 6 | AX = __ |
| add al, al | AX = __ |
| mov ax, cx | AX = __ |

（2） 只能使用目前学过的汇编指令，最多使用4条指令，编程计算2的4次方。

### 答案

（1） 写出每条汇编指令执行后相关寄存器中的值。

（2） 只能使用目前学过的汇编指令，最多使用4条指令，编程计算2的4次方。
```
mov ax, 2H
add ax, ax
add ax, ax
add ax, ax
```

### 解析
略。

## 检测点2.2
---

### 问题
（1） 给定段地址为0001H，仅通过变化偏移地址寻址，CPU的寻址范围为【 】到【 】。  
（2） 有一数据存放在内存20000H单元中，现给定段地址为SA,若想用偏移地址寻到此单元。则SA应满足的条件是：最小为【 】，最大为【】。  
提示，反过来思考一下，当段地址给定为多少，CPU无论怎么变化偏移地址都无法寻到20000H单元。

### 答案
（1） 给定段地址为0001H，仅通过变化偏移地址寻址，CPU的寻址范围为【 **00010H** 】到【 **1000FH** 】。  
（2） 有一数据存放在内存20000H单元中，现给定段地址为SA,若想用偏移地址寻到此单元。则SA应满足的条件是：最小为【 **1001H** 】，最大为【 **2000H** 】。

### 解析
（1）偏移地址最小为 0000H，最大为FFFFH。按（段地址*16 + 偏移地址）计算可得。  
（2）偏移地址最小为 0000H，最大为FFFFH。偏移地址取最小值0000H时，段地址最大为2000H。偏移地址取最大值FFFFH时，段地址为：(20000H - FFFFH)/16 = 10001H/16 = 1000H。
因为段地址要满足可以寻址到20000H单元的条件，所以段地址取1001H。

## 检测点2.3
---

### 问题
下面的3条指令执行后，CPU几次修改IP？都是在什么时候？最后IP中的值是多少？  
mov ax, bx  
sub ax, ax  
jmp ax
### 答案
三条指令执行后，CPU共计4次修改IP。

第1次是在mov ax, bx指令加载至指令缓冲器后。  
第2次是在sub ax, ax指令加载至指令缓冲器后。  
第3次是在jmp ax指令加载至指令缓冲器后。  
第4次是在jmp ax指令执行完毕后。

最后IP中的值是0000H。
### 解析
8086CPU的工作过程可以简要描述如下：  
（1） 从CS:IP指向的内存单元读取指令，读取的指令进入指令缓冲器；  
（2） IP = IP + 所读取指令的长度，从而指向下一条指令；  
（3） 执行指令。转到步骤（1），重复这个过程。

“Jmp 段地址：偏移地址” 指令的功能为：用指令中给出的段地址修改CS，偏移地址修改IP。  
“Jmp 偏移地址” 指令的功能为：用寄存器中的值修改IP。

## 检测点3.1
---
### 问题
（1）在Debug中，用“d 0:0 1f”查看内存，结果如下。  
```
0000:0000 70 80 f0 30 EF 60 30 E2-00 80 80 12 66 20 22 60  
0000:0010 62 26 E6 D6 CC 2E 3C 3B-AB BA 00 00 26 06 66 88
 ```
下面的程序执行前，AX=0，BX=0，写出每条汇编指令执行完后相关寄存器中的值。

|指令|寄存器|
|-|-|-|
| mov ax, 1 |  |
| mov dx, ax |  |
| mov ax, [0000] | AX=__ |
| mov bx, [0001] | BX=__ |
| mov ax, bx | AX=__ |
| mov ax, [0000] | AX=__ |
| mov bx, [0002] | BX=__ |
| add ax, bx | AX=__ |
| add ax, [0004] | AX=__ |
| mov ax, 0 | AX=__ |
| mov al, [0002] | AX=__ |
| mov bx, 0 | BX=__ |
| mov bl, [000C] | BX=__ |
| add al, bl | AX=__ |

（2）内存中的情况如图3.6所示（图片位于课本P56）。

各寄存器的初始值：CS=2000H，IP=0，DS=1000H，AX=0，BX=0；

1. 写出CPU执行的指令序列（用汇编指令写出）。  
2. 写出CPU执行每条指令后，CS、IP和相关寄存器中的数值。
3. 再次体会：数据和程序有区别吗？如何确定内存中的信息哪些是数据，哪些是程序？

### 答案
（1）

（2）

1. CPU执行序列如下：

```c
mov ax, 6622H  
jmp 0ff0:0100
mov ax, 2000H
mov ds, ax
mov ax, [0008]
mov ax, [0002]
```
2. CPU执行每条指令后，CS、IP和相关寄存器中的数值如下表所示：

| 指令          | CS    | IP    | DS    | AX    | BX    |
|---------------|-------|-------|-------|-------|-------|
| mov ax, 6622H | 2000H | 0003H | 1000H | 6622H | 0000H |
| jmp 0ff0:0100 | 0ff0H | 0100H | 1000H | 6622H | 0000H |
| mov ax, 2000H | 0ff0H | 0103H | 1000H | 2000H | 0000H |
| mov ds, ax    | 0ff0H | 0105H | 2000H | 2000H | 0000H |
| mov ax, [0008]| 0ff0H | 0108H | 2000H | C389H | 0000H |
| mov ax, [0002]| 0ff0H | 010BH | 2000H | EA66H | 0000H |

3. 程序和数据没有区别，都是内存单元中的二进制码。当内存单元被CS:IP指定时其存储的就被当做程序执行。当内存单元被DS:[address]指定时其存储的就是数据。

### 解析
略。

## 检测点3.2
---
### 问题
（1）补全下面的程序，使其可以将10000H~1000FH中的8个字，逆序复制到20000H~2000FH中。逆
序复制的含义如图3.17（P70）所示（图中内存里的数据均为假设）。

```c
mov ax, 1000H
mov dx, ax
______________
______________
______________
push [0]
push [2]
push [4]
push [6]
push [8]
push [A]
push [C]
push [E]
```
（2）补全下面的程序，使其可以将10000H~1000FH中的8个字，逆序复制到20000H~2000FH中。

```c
mov ax, 2000H
mov ds, ax
______________
______________
______________
pop [E]
pop [C]
pop [A]
pop [8]
pop [6]
pop [4]
pop [2]
pop [0]
```
### 答案
（1）
```c
mov ax, 2000H
mov ss, ax
mov sp, 0010H
```
（2）
```c
mov ax 1000H
mov ss, ax
mov sp, 0000H
```
### 解析
略。

## 检测点 6.1
---
### 问题
（1）下面的程序实现依次用内存0:0~0:15单元中的内容改写程序中的数据，完成程序：
```c
assume cs:codesg

codesg segment
  dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h

start:  mov ax, 0
        mov ds, ax
        mov bx, 0

mov cx, 8
    s:  mov ax, [bx]

______________
        add bx, 2
        loop s

mov ax, 4c00h
        int 21h
codesg ends
end

```
（2）下面的程序实现依次用内存0:00~0:15单元中的内容改写程序中的数据，数据的传送用栈来
进行。栈空间设置在程序内。完成程序：
```c
assume cs:codesg

codesg segment

dw 0123h,0456h,0789h,0abch,0defh,0fedh,0cbah,0987h

dw 0,0,0,0,0,0,0,0,0,0,0,0

start:  mov ax, ______________
        mov ss, ax
        mov sp, ______________

mov ax, 0
        mov ds, ax
        mov bx, 0
        mov cx, 8
    s:  push [bx]

______________
        add bx, 2
        loop 2

mov ax, 4c00h
        int 21h

codesg ends
end start
```
### 答案
（1）
```c
mov cs:[bx], ax
```
（2）
```c
mov ax, cx
...
mov sp 24h
...
pop cx:[bx]
```
### 解析
略。

## 检测点 9.1
---
### 问题

（1）程序如下

```c
assume cs:code

data segment
?
data ends

code segment
  start:mov ax, data
        mov ds, ax
        mov bx, 0
        jmp word ptr [bx+1]
code ends
end start

```
若要使程序中的jmp指令执行后，CS：IP指向程序的第一条指令，在data段中应该定义哪些数据？

（2）程序如下：

```c
assume cs:code

data segment
    dd 12345678H
data ends

code segment
    start:  mov ax, data
            mov ds, ax
            mov bx, 0
            mov [bx], ______________
            mov [bx+2], ______________
            jum dword ptr ds:[0]
code ends
end start
```
补全程序，使jmp指令执行后，CS:IP指向程序第一条指令。

（3）用debug查看内存，结果如下：

```c
2000:1000 BE 00 06 00 00 00 ......
```
则此时，CPU执行指令：
```c
mov ax, 2000H
mov es, ax
jmp dword ptr es:[1000H]
```
后，（CS）=?，（IP）=?
### 答案

（1）完整程序如下

```c
assume cs:code

data segment
  db 0, 0, 0    ;第一个字节可以取8位任意值
data ends

code segment
  start:mov ax, data
        mov ds, ax
        mov bx, 0
        jmp word ptr [bx+1]
code ends
end start
```

（2）完整程序如下：

```c
assume cs:code

data segment
    dd 12345678H
data ends

code segment
    start:  mov ax, data
            mov ds, ax
            mov bx, 0
            mov [bx], bx
            mov [bx+2], cs
            jmp dword ptr ds:[0]
code ends
end start
```
（3）

（CS）= 0006H，（IP）=00BEH

### 解析

略。

## 检测点 9.2
---
### 问题

补全程序，利用jcxz指令，实现在内存2000H段中查找第一个值为0的字节，找到后，将它的偏移地址存储在dx中。

```c
assume cs:code

code segment

start:  mov ax, 2000H
            mov ds, ax
            mov bx, 0
        s:  ______________
            ______________
            ______________
            ______________
            jmp short s
        ok: mov ds, bx

mov ax, 4c00h
            int 21h

code ends
end start

```

### 答案

完整程序如下：

```c
assume cs:code

code segment
    start:  mov ax, 2000H
            mov ds, ax
            mov bx, 0

s:  mov ch, 0
			      mov cl, [bx]
			      jcxz ok
			      inc bx
            jmp short s

ok: mov ds, bx

mov ax, 4c00h
            int 21h

code ends
end start
```

### 解析
略。

### 检测点9.3

### 问题

补全编程，利用loop指令，实现在内存2000H段中查找第一个值为0的字节，找到后，将它的偏移地址存储在dx中。

```c
assume cs:code

code segment

start:mov ax, 2000H
			mov ds, ax
			mov bx, 0

s:	mov cl, [bx]
			mov ch, 0
			______________
			inc bx
			loop s

ok:	dec bx
			mov dx, bx

mov ax, 4c00h
			int 21h
code ends
end start
```

### 答案

完整程序如下：

```c
assume cs:code

code segment

start:mov ax, 2000H
			mov ds, ax
			mov bx, 0

s:  mov cl, [bx]
			mov ch, 0
			inc cx
			inc bx
			loop s

ok: dec bx
			mov dx, bx

mov ax, 4c00h
			int 21h
code ends
end start
```

### 解析
略。

## 检测点10.1
---
### 问题

补全程序，实现从内存1000:0000处开始执行指令。

```c
assume cs:code

stack segment
	db 16 dup (0)
stack ends

code segment
	start:	mov ax, stack
			mov ss, ax
			mov sp, 16
			mov ax, ____
			push ax
			mov ax, ____
			push ax
			retf
code ends
```

### 答案

```c
...
mov ax, 1000h
...
mov ax, 0000
...

```

### 解析
略。

## 检测点 10.2
---

### 问题

下面的程序执行后，ax中的值为多少？

| 内存地址 | 机器码 | 汇编指令 |
|---------|--------|---------|
|1000:0   |b8 00 00| mov ax, 0|
|1000:3   |e8 01 00| call s   |
|1000:6   |40      | inc ax   |
|1000:7   |58      | s:pop ax |

### 答案

ax值为6

### 解析
预加载指令 call s 时，ip指向下条指令地址 ip = 6。

## 检测点10.3
---
### 问题

下面的程序执行后，ax中的数值为多少？

| 内存地址 | 机器码 | 汇编指令 |
|---------|--------|--------|
|1000:0   | b8 00 00 | mov ax, 0 |
|1000:3   | 9A 09 00 00 10 | call far ptr s |
|1000:8   | 40       | inc ax |
|1000:9   | 58       | s : pop ax |
|         |          |add ax, ax|
|         |          |pop bx    |
|         |          |add ax, bx|

### 答案

ax = 1010h

### 解析
各条指令执行后，相关寄存器的值的变化如下表所示：

## 检测点10.4
---

### 问题

下面的程序执行后，ax中的数值为多少？

| 内存地址 | 机器码 | 汇编指令 |
|---------|--------|---------|
| 1000:0  | b8 06 00 | mov ax, 6  |
| 1000:3  | ff d0    | call ax    |
| 1000:5  | 40       | inc ax     |
| 1000:6  |          | mov bp, sp |
|         |          | add ax, [bp] |

### 答案

ax = 000bh

### 解析

各条指令加载及执行后相关寄存器的变化情况如下表所示：

| 汇编指令 | 指令加载完毕 | 指令执行完毕 |
|----------|------------|-------------|
| mov ax, 6 | ip=3      | ax=6        |
| call ax   | ip=5      | ip=6,ss:[sp]=5 |
| inc ax    |           |             |        
| mov bp, sp|           | bp = sp     |
| add ax, [bp] |        | ax=6 + ss:[bp]=6+ss:[sp]=6+5=000bH |

## 检测点10.5
---

### 问题

（1）下面程序执行后，ax中的数值为多少？（注意：用call指令的原理来分析，不要在debug中单步跟踪来验证你的结论。对于此程序，在Debug中单步跟踪的结果，不能代表CPU的实际执行结果。）

```c

assume cs:code

stack segment
	dw 8 dup (0)
stack ends

code segment

start:	mov ax, stack
			mov ss, ax
			mov sp, 16
			mov ds, ax
			mov ax, 0
			call word ptr ds:[0eh]
			inc ax
			inc ax
			inc ax
			mov ax, 4c00h
			int 21h

code ends

end start

```

（2）下面程序执行后，ax和bx的数值为多少？

```c

assume cs:code

data segment
	dw 8 dup (0)
data ends

code segment

start:	mov ax, data
			mov ss, ax
			mov sp, 16
			mov word ptr ss:[0], offset s
			mov ss:[2], cs
			call dword ptr ss:[0]
			nop
		s:	mov ax, offset s
			sub ax, ss:[0cH]
			mov bx, cs
			sub bx, ss:[0eH]
			mov ax, 4c00h
			int 21h

code ends

end start

```

### 答案
（1）

ax = 3

（2）

ax = 1, bx = 0

### 解析
（1）

当执行call word ptr ds:[0EH]时，执行两步操作，第一步将原IP值入栈，第二步
将ds:[0EH]处的值赋值给IP。**实际上这两步操作的是同一个内存单元。**

>此处有个疑问
>刚尝试了一下用debug跟踪，但跟踪结果与理论分析不一致，不知道为什么
>

（2）

在执行【call dword ptr 内存单元地址】指令时，入栈顺序是CS→IP。赋值时双字内存单元前一个字储存的是IP的值，后一个字存储的是CS的值。

## 检测点11.1
---
### 问题：

写出下面每条指令执行后，ZF、PF、SF等标志位的值。

|指令|ZF（零标志位）|PF（奇偶标志位）|SF（符号标志位）|
|:-||||
|sub al, al|ZF = ___|PF = ___|SF = ___|
|mov al, 1|ZF = ___|PF = ___|SF = ___|
|push ax|ZF = ___|PF = ___|SF = ___|
|pop bx|ZF = ___|PF = ___|SF = ___|
|add al, bl|ZF = ___|PF = ___|SF = ___|
|add al, 10|ZF = ___|PF = ___|SF = ___|
|mul al|ZF = ___|PF = ___|SF = ___|

### 答案：

|指令|ZF（零标志位）|PF（奇偶标志位）|SF（符号标志位）|
|:-||||
|sub al, al|ZF = 1|PF = 1|SF = 0|
|mov al, 1 |ZF = 1|PF = 1|SF = 0|
|push ax   |ZF = 1|PF = 1|SF = 0|
|pop bx    |ZF = 1|PF = 1|SF = 0|
|add al, bl|ZF = 0|PF = 0|SF = 0|
|add al, 10|ZF = 0|PF = 1|SF = 0|
|mul al    |ZF = 0|PF = 1|SF = 0|

### 解析：

注意，在8086CPU的指令集中，有的指令是影响标志寄存器的，比如，add、sub、mul、div、inc、or、and等，它们大都是运算指令（逻辑运算，或算术运算）；有的指令的执行对标志寄存器没有影响，比如，mov、push、pop等，它们大都是传送指令。

## 检测点11.2
---
### 问题：

写出下面每条指令执行后，ZF、PF、SF、CF、OP等标志位的值。

|指令|CF|OF|SF|ZF|PF
|-|-|-|-|-|-|
|sub al, al   | | | | | |
|mov al, 10H  | | | | | |
|add al, 90H  | | | | | |
|mov al, 80H  | | | | | |
|add al, 80H  | | | | | |
|mov al, 0FCH | | | | | |
|add al, 05H  | | | | | |
|add al, 7DH  | | | | | |
|add al, 0BH  | | | | | ||

### 答案：

|指令|CF|OF|SF|ZF|PF
|-|-|-|-|-|-|
|sub al, al   |0 |0 |0 |1 |1 |
|mov al, 10H  |0 |0 |0 |1 |1 |
|add al, 90H  |0 |0 |1 |0 |1 |
|mov al, 80H  |0 |0 |1 |0 |1 |
|add al, 80H  |1 |1 |0 |1 |1 |
|mov al, 0FCH |1 |1 |0 |1 |1 |
|add al, 05H  |1 |0 |0 |0 |0 |
|add al, 7DH  |1 |0 |0 |0 |0 |
|add al, 0BH  |0 |1 |1 |0 |1 |

### 解析：

**CF(CarryFlag)** ：进位标志位，记录**无符号运算**结果是否有进位/借位。如果有进位或者借位，则CF = 1。

**OF(OverflowFlag)**：溢出标记位，记录**有符号运算**结果是否溢出，如果溢出，则OF = 1。

**SF(SignFlag)**：符号标记位，记录有符号运算结果，如果是有符号运算结果为负数时，SF = 1。

**ZF(ZeroFlag)**：零标记位，记录运算结果是否为0，如果运算结果为0，则ZF = 1。

**PF(ParityFlag)**：奇偶标记位，记录运算结果二进制数中1的个数是否是偶数，如果1的个数为偶数，则PF = 1。

同时需要注意mov、push、pop等传送指令对flag没有影响。

## 检测点11.3
---
### 问题
（1）补全下面的程序，统计F000:0处32个字节中，大小在[32,128]的数据的个数。

```
    mov ax, 0f000h
    mov ds, ax

mov bx, 0
    mov dx, 0
    mov cx, 32
s:  mov al, [bx]
    cmp al, 32
    ______________
    cmp al, 128
    ______________
    inc dx
s0: inc bx
    loop s
```
（2）补全下面的程序，统计F000:0处32个字节中，大小在(32, 128)的数据的个数。
```
    mov ax, 0f000h
    mov ds, ax

mov bx, 0
    mov dx, 0
    mov cx, 32
s:  mov al, [bx]
    cmp al, 32
    ______________
    cmp al, 128
    ______________
    inc dx
s0: inc bx
    loop s
```
### 答案
（1）

```
...
jb so
...
ja so
...
```

（2）

```
...
jna so
...
jnb so
...
```

### 解析
jb：低于则转移

ja：高于则转移

jna：不高于则转移

jnb：不低于则转移

## 检测点 11.4
---
### 问题
下面的程序执行后：（ax）= ?

```
mov ax, 0
push ax
popf
mov ax, 0fff0h
add ax, 0010h
push f
pop ax
and al, 11000101B
and ah, 00001000B
```
### 答案
(ax) = 0000 0000 0100 0101

### 解析
```
mov ax, 0fff0h
add ax, 0010h
```
这两句代码执行过后，ax = 0000 0000 0000 0000。有进位，无溢出，结果为0。
所以各标志位的值分别为：
```
zf = 1
pf = 1
sf = 0
cf = 1
of = 0
df = 0
```

## 检测点12.1
---
### 问题
（1）用Debug查看内存，情况如下：
```
0000:0000 68 10 A7 00 8B 01 70 00-16 00 9D 03 8B 01 70 00
```
则3号中断源对应的中断处理程序的入口地址为：【 】。

（2）存储N号中断源对应的中断处理程序入口的偏移地址的内存单元的地址为：【 】。
存储N号中断源对应的中断处理程序入口的段地址的内存单元的地址为：【 】。

### 答案
（1）0070:018B

（2）4N, 4N+2

### 解析
（1）在中断向量表中，一个中断向量占两个字，也即四个字节。高地址字存放段地址，低地址字存放偏移地址。

（2）同上。

##  检测点13.1
---

### 问题

（1）在上面的内容中，我们用7ch中断例程实现loop的功能，则上面的7ch中断例程所能进行的最大转移位移是多少？

（2）用7ch中断例程完成 jmp near ptr s 指令的功能，用bx向中断例程传送转移位移。应用举例：在屏幕的第12行，显示 data 段中以0结尾的字符串。
代码范例略。

### 答案
（1）

7ch中断例程所能进行的最大转移位移范围是 [-32768, 32767]。即16位补码所能表示的数的范围。

在7ch例程中，只需满足 -32768 =< [bp+2] + bx <= 32767即可。当 [bp+2] = 0 时，bx最大可以为32767，最小可以为-32768。

（2）
```c

;检测点13.1（2）
;用7ch中断例程完成 jmp near ptr s 指令的功能，用bx向中断例程传送转移位移。
;应用举例：在屏幕的第12行，显示data段中以0结尾的字符串

assume cs:code
data segment
		db 'conversation', 0
data ends

code segment

start:
		;复制中断例程至指定内存地址 0000:0200h ↓
		mov ax, cs
		mov ds, ax
		mov si, offset jmpnp
		mov ax, 0
		mov es, ax
		mov di, 0200h
		mov cx, offset jmpnpend - offset jmpnp
		cld
		rep movsb

;设置中断例程所对应的中断向量表表项 ↓
		mov ax, 0
		mov es, ax
		mov word ptr es:[7ch * 4], 0200h
		mov word ptr es:[7ch * 4 + 2], 0

;应用程序 ↓
		mov ax, data
		mov ds, ax
		mov si, 0
		mov ax, 0b800h
		mov es, ax
		mov di, 12*160

s:	cmp byte ptr ds:[si], 0
		je ok
		mov al, ds:[si]
		mov es:[di], al
		mov byte ptr es:[di+1], 01000010b	;红底绿字
		inc si
		add di, 2
		mov bx, offset s - offset ok
		int 7ch

ok:	mov ax, 4c00h
		int 21h

;中断例程 ↓
	jmpnp: 		push bp
				mov bp, sp
				add [bp + 2], bx
				pop bp
				iret
	jmpnpend:	nop

code ends
end start

```

### 解析
略。

## 检测点13.2
---

### 问题

判断下面说法的正误：

（1）我们可以编程改变 FFFF:0 处的指令，使得 CPU 不去执行 BIOS 中的硬件系统检测和初始化程序。

（2）int 19h 中断例程，可以由DOS提供。

### 答案

（1）
错误。
FFFF:0位于系统ROM区，只可读不可写。

（2）
错误。
硬件系统检测和初始化完成后，然后调用 int 19h 进行操作系统的引导，之后才会把计算机交付给操作系统（此处是指 DOS ）控制。

### 解析

略。

dsapr/AssemblyLanguageTest

About

Releases

Contributors

Activities

dsapr/AssemblyLanguageTest .gitee-modal { width: 500px !important; }

About

Releases

Contributors

Activities

Search

dsapr/AssemblyLanguageTest