既然表示的数有符号，则必须要能够区分正、负。

首先，我们可以考虑用8位数据的最高位来表示符号，1表示负，0表示正，而用其他位表示数值，如下：

可见，用上面的表示方式，8位数据可以表示-127~127的254个有符号数。从这里我们看出一些问题（注意问号处），8位数据可以表示255种不同的信息，也就是说应该可以表示255个有符号数，可用上面的方法，只能表示254个有符号数。注意，用上面的方法，00000000b和10000000b都表示0，一个是0，一个是-0，当然不可能有-0。可以看出，这种表示有符号数的方法是有问题的，它并不能正确地表示有符号数。

我们再考虑用反码来表示，这种思想是，我们先确定用00000000b~01111111b表示0~127，然后再用它们按位取反后的数据表示负数。如下：

可以看出，用反码表示有符号数存在同样的问题，0出现重码（注意问号处）。

为了解决这种问题，采用一种称为补码的编码方法。这种思想是：先确定用00000000b~01111111b表示0~127，然后再用它们按位取反加1后的数据表示负数。如下：

观察上面的数据，我们可以发现，补码方案中：

1）最高位为1，表示负数；

2）正数的补码取反加1后，为其对应的负数的补码：负数的补码取反加1后，为其绝对值，比如：

1的补码为：00000001b，取反加1后为：11111111b，表示-1；

-1的补码为：11111111b，取反加1后为：00000001，其绝对值为1。

我们从一个负数的补码不太容易看出它所表示的数据，比如：11010101b表示的数据是多少？

但是我们利用补码的特性，将11010101b取反加1后为：00101011b，可以知11010101b表示的负数的绝对值为：2BH，则11010101b表示的负数为-2BH。

那么-20的补码是多少呢？

用补码的特性，-20的绝对值是20，00010100b，将其取反加1后为：11101100b。可知-20H的补码为：1101100b。

那么10000000b表示多少呢？

10000000b取反加1后为：10000000b，其大小为128，所以10000000b表示-128。

8位补码所表示的数的范围：-128~127。

补码为有符号数的运算提供了方便，运算后的结果依旧满足补码规则。

比如：

8086/8088是一个重要的阶段，它们略有区别。8088被IBM用在了它所生产的第一台微机上，该微机的结构事实上成为以后微机的基本结构。

80386是第二个重要的型号，随着微机应用及性能的发展，在微机上构造可靠的多任务操作系统的问题日益突出。

8086/8088不具备实现一个完善的多任务操作系统的功能。为此Intel开发了80286，80286具备了对多任务系统的支持。但对8086/8088的兼容却做得不好。这妨碍了用户对原8086机上的程序的使用。IBM最早基于80286开发了多任务系统OS/2，结果犯了一个战略错误。

随后Intel又开发了80386微处理器，这是一个划时代的新产品。它可以在3个模式下工作：

1）实模式：工作方式相当于一个8086。

2）保护模式：提供支持多任务环境的工作方式，建立保护机制。

3）虚拟8086模式：可从保护模式切换至其中的一种8086工作方式。这种方式的提供使用户可以方便地在保护模式下运行一个或多个原8086程序。

以后的各代微处理器都提供了上述3种工作模式。

也许你会觉得，这三种模式太抽象了，其实CPU的这3种模式只要用过PC机的人都经历过。任何一台使用Intel系列CPU的PC机只要一开机，CPU就工作在实模式下。如果你的机器装的是DOS，那么在DOS加载后CPU仍以实模式工作。如果你的机器装的是Windows，那么Windows加载后，将由Windows将CPU切换到保护模式下工作，因为Windows是多任务系统，它必须在保护模式下运行。如果你在Windows中运行一个DOS下的程序，那么Windows将CPU切换到虚拟8086模式下运行该程序。或者是这样，你点击开始菜单在程序项中进入MS-DOS方式，这时，Windows也将CPU切换到虚拟8086模式下运行。

可以从保护模式直接进入能运行原8086程序的虚拟8086模式是很有意义的，这为用户提供了一种机制，可以在现有的多任务系统中方便地运行原8086系统中的程序。

前面讲过，我们在8086PC机的基础上学习汇编语言，但现在知道，我们实际的编程环境是当前CPU的实模式，当然，有些程序也可以在虚拟8086模式下运行。

从80386到当前的CPU，提供8086实模式的目的是为了兼容。现今CPU的真正有效力的工作模式是支持多任务操作系统的保护模式。这也许会引发你的一个疑问：“为什么我们不在保护模式下学习汇编语言？”

类似问题很多，我们都希望学习更新的东西，但学习的过程是客观的。任何合理的学习过程（尽可能排除走弯路、盲目探索、不成系统）都是一个循序渐进的过程。我们必须先通过一个易于全面把握的事物，来学习和探索一般的规律和方法。信息技术是一个发展非常快、日新月异的技术，新的东西不断出现，使人在学习的时候往往无所适从。在你的身边不断有这样的故事出现：COOL先生用了三天（或更短）的时间就学会了某某语言，并开始用它编软件。。在这个故事的感召下，一个初学者也去尝试，但完全是另外一种结果。COOL先生的快速学习只是露出水面的冰山一角，深藏水下的是他的较为系统的相关基础知识和相关的技术。在开始的时候学习保护模式下的编程，是不现实的，保护模式下所涉及的东西对初学者来说太复杂。你必须知道很多知识后，才能开始编写第一个小程序。相比之下8086就合适很多。

大多数有用的程序都需要处理用户的输入，键盘输入是最基本的输入。程序和数据通常需要长期存储，磁盘是最常用的存储设备。

BIOS为这两种外设的I/O提供了最基本的中断例程。下面将对它们的应用和相关问题进行学习。

int 9中断例程对键盘输入的处理

键盘输入将引发9号中断，BIOS提供了int 9中断例程。

CPU在9号中断发生后，执行int 9中断例程，从60h端口读出扫描码，并将其转化为相应的ASCII码或状态信息，存储在内存的指定空间（键盘缓冲区或状态字节）中。

一般的键盘输入，在CPU执行完int 9中断例程后，都放到了键盘缓冲区中。键盘缓冲区有16个字单元，可以存储15个按键的扫描码和对应的ASCII码。

下面我们按照键盘缓冲区的逻辑结构，来看一下键盘输入的扫描码和对应的ASCII码是如何写入键盘缓冲区的。

注意：在我们的课程中，仅在逻辑结构的基础上，讨论BIOS键盘缓冲区的读写问题。其实键盘缓冲区是用环形队列结构管理的内存区，但我们不对队列和环形队列的实现进行讨论，因为那是另一门专业课《数据结构》的内容。

下面，我们通过下面几个键：

A、B、C、D、E、shift_A、A

的输入过程，简要地看一下int 9中断例程对键盘输入的处理方法：

（1）初始状态下，没有键盘输入，键盘缓冲区空，此时没有任何元素：

（2）按下A键，引发键盘中断：CPU执行int 9中断例程，从60h端口读出A键的通码；然后检测状态字节，看看是否有shift、Ctrl等切换键按下；发现没有切换键按下，则将A键的扫描码1eh和对应的ASCII码，即字母“a”的ASCII码61h，写入键盘缓冲区。缓冲区的字单元中，高位字节存储扫描码，低位字节存储ASCII码。此时缓冲区中的内容如下：

（3）按下B键，引发键盘中断：CPU执行int 9中断例程，从60h端口读出B键的通码；然后检测状态字节，看看是否有切换键按下；发现没有切换键按下，将B键的扫描码30h和对应的ASCII码，即字母“b”的ASCII码62h，写入键盘缓冲区。此时缓冲区中的内容如下：

（4）按下C、D、E键后，缓冲区中的内容如下：

（5）按下左shift键，引发键盘中断：int 9中断例程接收左shift键的通码，设置0040:17处的状态字节的第1位为1，表示左shift键按下。

（6）按下A键，引发键盘中断：CPU执行int 9中断例程；从60h端口读出A键的通码；检测状态字节，看看是否有切换键按下，发现左shift键被按下，则将A键的扫描码1Eh和shift_A对应的ASCCII码，即字母“A”的ASCII码41，写入键盘缓冲区，此时缓冲区中的内容如下：

（7）松开左shift键，引发键盘中断：int 9中断例程接收左shift键的断码，设置0040:17处的状态字节的第1位为0，表示左shift键松开。

（8）按下A键，引发键盘中断：CPU执行int 9中断例程，从60h端口读出A键的通码，然后检测状态字节，看看是否有切换键按下，发现没有切换键按下，则将A键的扫描码1Eh和A对应的ASCCII码，即字母“a”的ASCII码61h，写入键盘缓冲区，此时缓冲区中的内容如下：

使用int 16h中断例程读取键盘缓冲区

BIOS提供了int 16h中断例程供程序员调用。int 16h中断例程中包含的一个最重要的功能是从键盘缓冲区中读取一个键盘输入，该功能的编号为0。

下面的指令从键盘缓冲区中读取一个键盘输入，并将其从缓冲区中删除：

mov ah,0

int 16h

结果：(ah)=扫描码，(al)=ASCII码。

int 16h中断例程的0号功能，进行如下的工作：

1）检测键盘缓冲区中是否有数据；

2）没有则继续做第1步；

3）读取缓冲区第一个字单元中的键盘输入；

4）将读取的扫描码送入ah，ASCII码送入al；

5）将已读取的键盘输入从缓冲区中删除。

可见，BIOS的int 9中断例程和int 16h中断例程是一对相互配合的程序，int 9中断例程向键盘缓冲区中写入，int 16h中断例程从缓冲区中读出。

它们写入和读出的时机不同，int 9中断例程是在有按键按下的时候向键盘缓冲区中写入数据；而int 16h中断例程是在应用程序对其进行调用的时候，将数据从键盘缓冲区中读出。

我们在编写一般的处理键盘输入的程序的时候，可以调用int 16h从键盘缓冲区中读取键盘的输入。

编程，接收用户的键盘输入，输入“r”，将屏幕上的字符设置为红色；输入“g”，将屏幕上的字符设置为绿色；输入“b”，将屏幕上的字符设置为蓝色。

程序如下：

assume cs:code

code segment

 start:mov ah,0

        int 16h

        mov ah,1

        cmp al,'r'

        je red

        cmp al,'g'

        je green

        cmp al,'b'

        je blue

        jmp short sret

    red:shl ah,1

 green:shl ah,1

   blue:mov bx,0b800h

        mov es,bx

        mov cx,2000

      s:add byte ptr es:[bx],11111000b

        or es:[bx],ah

        add bx,2

        loop s

   sret:mov ax,4c00h

        int 21h

code ends

end start

字符串的输入

用户通过键盘输入的通常不仅仅是单个字符而是字符串。

最基本的字符串输入程序，需要具备下面的功能：

1）在输入的同时需要显示这个字符串；

2）一般在输入回车符后，字符串输入结束；

3）能够删除已经输入的字符。

编写一个接收字符串的输入子程序，实现上面三个基本功能。

子程序的参数如下：

(dh)、(dl)=字符串在屏幕上显示的行、列位置；

ds:si指向字符串的存储空间，字符串以0为结尾符。

分析：

（1）字符的输入和删除。

       每个新输入的字符都存储在前一个输入的字符之后，而删除是从最后面的字符进行的。

       看下面的过程：

       空字符串：

       输入“a”：a

       输入“b”：ab

       输入“c”：abc

       输入“d”：abcd

       删除一个字符：abc

       删除一个字符：ab

       删除一个字符：a

       删除一个字符：

       可以看出在字符串输入的过程中，字符的输入和输出是按照栈的访问规则进行了的，即后进先出。这样，我们就可以用栈的方式来管理字符串的存储空间，也就是说，字符串的存储空间实际上是一个字符栈。字符栈中的所有字符，从栈底到栈顶，组成一个字符串。

（2）在输入回车符后，字符串输入结束。

       输入回车符后，可以在字符串中加入0，表示字符串结束。

（3）在输入的同时需要显示这个字符串。

       每次有新的字符输入和删除一个字符的时候，都应该重新显示字符串，即从字符栈的栈底到栈顶，显示所有的字符。

（4）程序的处理过程。

       1）调用int 16h读取键盘输入；

       2）如果是字符，进入字符栈，显示字符栈中的所有字符；继续执行1

       3）如果是退格键，从字符栈中弹出一个字符，显示字符栈中的所有字符；继续执行1；

       4）如果是Enter键，向字符栈中压入0，返回。

       从程序的处理过程中可以看出，字符栈的入栈、出栈和显示栈中的内容，是需要在多处使用的功能，应该将它们写为子程序。

       子程序：字符栈的入栈、出栈和显示。

       参数说明：(ah)=功能号，0表示入栈，1表示出栈，2表示显示；

                            ds:si指向字符栈空间；

                            对于0号功能：(al)=入栈字符；

                            对于1号功能：(al)=返回字符；

                            对于2号功能：(dh)、(dl)=字符串在屏幕上显示的行、列位置。

charstack:       jmp short charstart

       table dw charpush,charpop,charshow

       top dw 0             ;栈顶

 charstart:    push bx

                     push dx

                     push di

                     push es

                     cmp ah,2

                     ja sret

                     mov bl,ah

                     mov bh,0

                     add bx,bx

                     jmp word ptr table[bx]

 charpush:    mov bx,top

                     mov [si][bx],al

                     inc top

                     jmp sret

 charpop:     cmp top,0

                     je sret

                     dec top

                     mov bx,top

                     mov al,[si][bx]

                     jmp sret

 charshow:   mov bx,0b800b

                     mov es,bx

                     mov al,160

                     mov ah,0

                     mul dh

                     mov di,ax

                     add dl,dl

                     mov dh,0

                     add di,dx

                     mov bx,0

 charshows: cmp bx,top

                     jne noempty

                     mov byte ptr es:[dl],’ ‘

                     jmp sret

 noempty:     mov al,[si][bx]

                     mov es:[di],al

                     mov byte ptr es:[di+2], ‘ ‘

                     inc bx

                     add di,2

                     jmp charshows

sret:        pop es

              pop di

              pop dx

              pop bx

              ret

显示栈中字符的时候，要注意清除屏幕上上一次显示的内容。

完整的接收字符串输入的子程序：

getstr:     push ax

getstrs:    mov ah,0

              int 16h

              cmp al,20h

              jb nochar               ;ASCII码小于0，说明不是字符

              mov ah,0

              call charstack         ;字符入栈

              mov ah,2

              call charstack         ;显示栈中的字符

              jmp getstrs

 nochar:cmp ah,0eh            ;退格键的扫描码

              je backspace

              cmp ah,1ch           ;回车键的扫描码

              je enter

              jmp getstrs

backspace:mov ah,1

              call charstack         ;字符出栈

              mov ah,2

              call charstack         ;显示栈中的字符

              jmp getstrs

 enter:     mov al,0

              mov ah,0

              call charstack         ;0入栈

              mov ah,2

              call charstack               ;显示栈中的字符

              pop ax

              ret

应用int 13h中断例程对磁盘进行读写

BIOS提供的访问磁盘的中断例程为int 13h。

入口参数：

(ah)=int 13h的功能号（2表示读扇区、3表示写扇区）

(al)=读取的扇区数/写入的扇区数

(ch)=磁道号

(cl)=扇区号

(dh)=磁头号（对于软盘即面号，因为一个面用一个磁头来读写。）

(dl)=驱动器号       软驱从0开始，0：软驱A，1：软驱B；

                            硬盘从80h开始，80h：硬盘C，81h：硬盘D。

es:bx指向接收从扇区读入数据的内存区/将写入磁盘的数据

返回参数：

操作成功：(ah)=0，(al)=读入的扇区数/写入的扇区数

操作失败：(ah)=出错代码

以下指令，读取0面0道1扇区的内容到内存单元0:200：

mov ax,0

mov es,ax

mov bx,200h

mov al,1

mov ch,0

mov cl,1

mov dl,0

mov dh,0

mov ah,2

int 13h

以下指令，将0:200中的内容写入0面0道1扇区：

mov ax,0

mov es,ax

mov bx,200h

mov al,1

mov ch,0

mov cl,1

mov dl,0

mov dh,0

mov ah,3

int 13h

PC机是如何进入操作系统的？

开机后，CPU自动进入到FFFF:0单元处执行，此处有一条转跳指令。CPU执行该指令后，转去执行BIOS中的硬件系统检测和初始化程序。

初始化程序将建立BIOS所支持的中断向量，即将BIOS提供的中断例程的入口地址登记在中断向量表中。

硬件系统检测和初始化完成后，调用int 19h进行操作系统的引导。

如果设为从软盘启动操作系统，则int 19h将主要完成以下工作：

1）控制0号软驱，读取软盘0道0面1扇区的内容到0:7c00。

2）将CS:IP指向0:7c00。

软盘的0道0面1扇区中装有操作系统引导程序。int 19h将其装到0:7c00处后，设置CPU从0:7c00开始执行此处的引导程序，操作系统被激活，控制计算机。

如何有效合理地组织数据，以及相关的编程技术。

描述了单元长度的标号

assume cs:code

code segment

       a:db 1,2,3,4,5,6,7,8

       b:dw 0

 start:   mov si,offset a

              mov bx, offset b

              mov cx,8

     s:   mov al,cs:[si]

              mov ah,0

              add cs:[bx],ax

              inc si

              loop s

              mov ax,4c00h

              int 21h

code ends

end start

程序中，code、a、b、start、s都是标号。这些标号仅仅表示了内存单元的地址。

我们还可以使用一种标号，这种标号不但表示内存单元的地址，还表示了内存单元的长度，即表示在此标号处的单元，是一个字节单元，还是字单元，还是双字单元。

比如：

assume cs:code

code segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

 start:    mov si,offset a

              mov bx, offset b

              mov cx,8

    s:   mov al,cs:[si]

              mov ah,0

              add cs:[bx],ax

              inc si

              loop s

              mov ax,4c00h

              int 21h

code ends

end start

我们在code段中使用的标号a、b后面没有“:”，它们是同时描述内存地址和单元长度的标号。

标号a，描述了地址code:0，和这个地址开始，以后的内存单元都是字节单元；

而标号b描述了地址code:8，和这个地址开始，以后的内存单元都是字单元。

因为这种标号包含了对单元长度的描述，所以，在指令中，它可以代表一个段中的内存单元。比如，对于程序中的b dw 0。

指令：mov ax,b

相当于：mov ax,cs:[8]

指令：mob b,2

相当于：mov word ptr cs:[8],2

指令：inc b

相当于：inc word ptr cs:[8]

在这些指令中，标号b代表了一个内存单元，地址为code:8，长度为2字节。

下面的指令会引起编译错误：

mov al,b

因为b代表的内存单元是字单元，而al是8位寄存器。

如果我们将程序中的指令：add b,ax，写为add b,al，将出现同样的编译错误。

对于程序中的a db 1,2,3,4,5,6,7,8：

指令：mov al,a[si]

相当于：mov al,cs:0[si]                            ;这种语法比较像高级语言中的数组语法。

相当于：mov al,cs:[si+0]

相当于：mov al,cs:[si].0

指令：mov al,a[3]

相当于：mov al,cs:0[3]

指令：mov al,a[bx+si+3]

相当于：mov al,cs:0[bx+si+3]

可见，使用这种包含单元长度的标号，可以使我们以简洁的形式访问内存中的数据。

以后，我们将这种标号称为数据标号，它标记了存储数据的单元的地址和长度。它不同于仅仅表示地址的地址标号。

检测点16.1

下面的程序将code段中a处的8个数据累加，结果存储到b处的dword中，补全程序。

assume cs:code

code segment

       a dw 1,2,3,4,5,6,7,8

       b dd 0

 start:    mov si,0

              mov cs,8

        s: mov ax, a[si] 

              add   word ptr b ,ax

              adc   word ptr b[2] ,0   ;双字单元的高字单元用来存放进位数值。

              add si, 2       ;内存单元为字节单元。

              loop s

              mov ax,4c00h

              int 21h

code ends

end start

在其他段中使用数据标号

一般来说，我们不在代码段中定义数据，而是将数据定义到其他段中。在其他段中，我们也可以使用数据标号来描述存储数据的单元的地址和长度。

注意：在后面加有“:”的地址标号，只能在代码段中使用，不能在其他段中使用。

下面的程序将data段中a标号处的8个数据累加，结果存储到b标号处的字中。

assume cs:code, ds:data

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

data ends

code segment

 start:    mov ax,data

              mov ds,ax

              mov si,0

              mov ex,8

        s: mov al,a[si]

              mov ah,0

              add b,ax

              inc si

              loop s

              mov 4c00h

              int 21h

code ends

end start

注意，如果想在代码段中，直接用数据标号访问数据，则需要用伪指令assume将标号所在的段和一个段寄存器联系起来。否则编译器在编译的时候，无法确定标号的段地 在哪一个寄存器中。当然，这种联系是编译器需要的，但绝对不是说，我们因编译器的工作需要，用assume指令将段寄存器和某个段相联系，段寄存器中就会真的存放该段的地址。我们在程序中还需要使用指令对段寄存器进行设置。

       比如：在上面的程序中，我们要在代码段code中用data段中的数据标号a、b访问数据，则必须用assume将一个寄存器和data段相联。在程序中，我们用ds寄存器和data段相联，则编译器对相关指令的编译如下：

指令：mov al,a[si]

编译为：mov al,[si+0]

指令：add b,ax

编译为：add [8],ax

因为这些实际编译出的指令，都默认所访问单元的段地址在ds中，而实际要访问的段为data，所以，若要访问正确，在这些指令执行前，ds中必须为data段的段地址。则，我们在程序中使用指令：

mov ax,data

mov ds,ax

设置ds指向data段。

可以将标号当作数据来定义，此时，编译器将标号所表示的地址当作数据的值。比如：

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

       c dw a,b

data ends

数据标号c处存储的两个字型数据为标号a、b的偏移地址。相当于：

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

       c dw offset a, offset b

data ends

再比如：

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

       c dd a,b

data ends

数据标号c处存储的两个双字型数据为标号a的偏移地址和段地址、标号b的偏移地址和段地址。相当于：

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

       c dw offset a, seg a, offset b, seg b

data ends

seg操作符，功能为取得某一标号的段地址。

检测点16.2

下面的程序将data段中a处的8个数据累加，结果存储到b处的字中。补全程序。

assume cs:code,es:data

data segment

       a db 1,2,3,4,5,6,7,8

       b dw 0

data ends

code segment

 start:    mov ax,data

              mov ds,ax

              mov si,0

              mov cx,8

        s: mov al,a[si]

              mov ah,0

              add b,ax

              inc si

              loop s

              mov ax,4c00h

              int 21h

end start

直接定址表

现在，我们讨论用查表的方法编写相关程序的技巧。

编写子程序，以十六进制的形式在屏幕中间显示给定的byte型数据。

分析：一个字节需要用两个十六进制数码来表示，所以，子程序需要在屏幕上显示两个ASCII字符。用“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“A”、“B”、“C”、“D”、“E”、“F”这16个字符来显示十六进制数码。

我们可以将一个byte的高4位和低4位分开，分别用它们的值得到对应的数码字符。比如2Bh，我们可以得到高4位的值为2，低4位的值为11，那么我们如何用这两个数值得到对应的数码字符“2”和“B”呢？

最简单的办法就是一个一个地比较，如下：

如果数值为0，则显示“0”；

如果数值为1，则显示“1”；

…

如果数值为11，则显示“B”；

…

这样做，程序中要使用多条比较、转移指令。程序将比较长，混乱。

显示，我们希望能够在数值0~15和字符“0”~“F”之间找到一种映射关系。这样我们用0~15间的任何数值，都可以通过这种映射关系直接得到“0”~“F”中对应的字符。

数值0~9和字符“0”~“9”之间的映射关系是很明显的，即：

数值+30h = 对应字符的ASCII值。

但是，10~15和“A”~“F”之间的映射关系是：

数值+37h = 对应字符的ASCII值。

可见，我们可以利用数值和字符之间的这种原本存在的映射关系，通过高4位和低4位值得到对应的字符码。但是由于映射关系的不同，我们在程序中必须进行一些比较，对于大于9的数值，我们要用不同的计算方法。

这样做，虽然使程序得到了简化。但是，如果我们希望用更简捷的算法，就要考虑用同一种映射关系从数值得到字符码。所以，我们就不能利用0~9和“0”~“9”之间与10~15和“A”~“F”之间原有的映射关系。

因为数值0~15和字符“0”~“F”之间没有一致的映射关系存在，所以，我们应该在它们之间建立新的映射关系。

具体的做法是，我们建立一张表，表中依次存储字符“0”~“F”，我们可以通过数值0~15直接查找到对应的字符。

子程序如下：

;用al传送要显示的数据

showtyte:       jmp short show

            table db ‘0123456789ABCDEF’    ;字符表

 show: push bx

              push es

              mov ah,al

              shr ah,1

              shr ah,1

              shr ah,1

              shr ah,1          ;右移4位，ah中得到高4位的值。

              and al,00001111b    ;al中为低4位的值

              mov bl,ah

              mov bh,0

              mov ah,table[bx]           ;用高4位的值作为相对于table的偏移，取得对应的字符。

              mov bx,0b800h

              mov es,bx

              mov es:[160*12+40*2],ah            ;显示高4位的十六进制字符码

              mov bl,al

              mov bh,0

              mov al,table[bx]            ;用低4位的值作为相对于table的偏移，对得对应的字符。

              mov es:[160*12+40*2+2],al ;显示低4位的十六进制字符码

              pop es

              pop bx

              ret

可以看出，在子程序中，我们在数值0~15和字符“0”~“F”之间建立的映射关系为：

以数值N为table青史的偏移，可以找到对应的字符。

利用表，在两个数据集合之间建立一种映射关系，使我们可以用查表现方法根据给出的数据得到其在另一个集合中的对应数据。这样做的目的一般来说有三个：

1）为了算法的清晰和简洁；

2）为了加快运算速度；

3）为了使程序易于扩充。

在上面的子程序中，我们更多的是为了算法的清晰和简洁，而采用了查表的方法。

编程的时候要注意程序的容错性，即对于错误的输入要有处理能力。

上面的例子，我们通给出的数据进行计算或比较而得到结果的问题，转化为用给出的数据作为查表的依据，通过查表得到结果的问题。具体的查表方法，是用查表的依据数据，直接计算出所要查找的元素在表中的位置。像这种可以通过依据数据，直接计算出所要找的元素的位置的表，我们称其为：直接定址表。

程序入口地址的直接定址表

我们可以在直接定址表中存储子程序的地址，从而方便地实现不同子程序的调用。

实现一个子程序setscreen，为显示输出提供如下功能：

1）清屏；

2）设置前景色；

3）设置背景色；

4）向上滚动一行。

入口参数说明：

1）用ah寄存器传递功能号：0表示清屏，1表示设置前景色，2表示设置背景色，3表示向上滚动一行；

2）对于2、3号功能，用al传送颜色值，(al)∈{0,1,2,3,4,5,6,7}

下面，讨论一下各种功能如何实现：

1）清屏：将显存中当前屏幕中的字符设为空格符；

2）设置前景色：设置显存中当前屏幕中处于奇地址的属性字节的第0、1、2位；

3）设置背景色：设置显存中当前屏幕中处于奇地址的属性字节的第4、5、6位；

4）向上滚动一行：依次将第n+1行的内容复制到第n行处，最后一行为空。

我们将这4个功能分别写为4个子程序：

;清屏

sub1:       push bx

              push cx

              push es

              mov bx,0b800h

              mov es,bx

              mov bx,0

mov cx,2000

sub1s: mov byte ptr es:[bx],’ ‘

           add bx,2

           loop sub1s

           pop es

           pop cx

           pop bx

           ret

;设置前景色

sub2:       push bx

              push cx

              push es

              mov bx,0b800h

              mov es,bx

              mov bx,1

              mov cx,2000

 sub2s: and byte ptr es:[bx],11111000b

              or es:[bx],al

              add bx,2

              loop sub2s

              pop es

              pop cx

              pop bx

              ret

;设置背景色

sub3:       push bx

              push cx

              push es

              mov cl,4

              shr al,cl

              mov bx,0b800h

              mov es,bx

              mov bx,1

 sub3s: and byte ptr es:[bx],10001111b

              shl al,1

              shl al,1

              shl al,1

              shl al,1

              or es:[bx],al

              add bx,2

              loop sub3s

              pop es

              pop cx

              pop bx

              pop bx

              ret

;向上滚动一行

sub4:       push cx

              push si

              push di

              push es

              push ds

              mov si,0b800h

              mov es,si

              mov ds,si

              mov si,160            ;ds:si指向第n+1行

              mov di,0                ;es:di指向第n行

              cld

              mov cx,24

 sub4s: push cx

              mov cx,160           ;一行的长度为160个字节。

              rep movsb             ;一次复制一行

              pop cx

              loop sub4s

              mov cx,80

              mov si,0

 sub4s1:mov byte ptr [160*24+si],’ ‘   ;最后一行清空

              add si,2

              loop sub4s1

              pop ds

              pop es

              pop di

              pop si

              pop cx

              ret

我们可以将这些功能子程序的入口地址存储在一个表中，它们在表中的位置和功能号相对应。对应关系为：功能号*2=对应的功能子程序在地址表中的偏移。程序如下：

setscreen:       jmp short set

       table: dw sub1,sub2,sub3,sub4

set: push bx

       cmp ah,3    ;判断功能号是否大于3

       ja sret

       mov bl,ah

       mov bh,0

       add bx,bx              ;根据ah中的功能计算对应子程序在table表中的偏移

       call word ptr table[bx]          ;调用对应的功能子程序

sret: pop bx

ret

当然，我们也可以将子程序setscreen如下实现：

setscreen:       cmp ah,0

              je do1

              cmp ah,1

              je do2

              cmp ah,2

              je do3

              cmp ah,3

              je do4

              jmp short sret

 do1:     call sub1

              jmp short sret

 do2:     call sub2

              jmp short sret

 do3:     call sub3

              jmp short sret

 do4:     call sub4

 sret:     ret

       显然，用通过比较功能号进行转移的方法，程序结构比较混乱，不得功能的扩充。比如说，在setscreen中再加入一个功能，则需要修改程序的逻辑，加入新的比较、转移指令。

       用根据功能号查找地址表的方法，程序的结构清晰，便于扩充。如果加入一个新的功能子程序，那么只需要在地址表中加入它的入口地址就可以了。

以前我们讨论的都是CPU对指令的执行。

我们知道，CPU在计算机系统中，除了能够执行指令，进行运算以外，还应该能够对外部设备进行控制，接收它们的输入，向它们进行输出。也就是说，CPU除了有运算能力外，还要有I/O（Input/Output，输入/输出）能力。

比如，我们按下键盘上的确个键，CPU最终要能够处理这个键。在使用文本编辑器时，按下a键后，我们可以看到屏幕上出现“a”，是CPU将从键盘上输入的键所对应的字符送到显示上的。

要及时处理外设的输入，显然需要解决两个问题：

一是外设的输入随时可能发生，CPU如何得知？

二是CPU从何处得到外设的输入？

接口芯片和端口

在前面我们知道，在PC系统的接口卡和主板上，装有各种接口芯片。

这些外设接口芯片的内部有若干寄存器，CPU将这些寄存器当作端口来访问。

外设的输入不直接送入内存和CPU，而是送入相关的接口芯片的端口中；

CPU向外设的输出也不是直接送入外设，而是先送入端口中，再由相关的芯片送到外设。

CPU还可以向外设输出控制命令，而这些控制命令也是先送到相关芯片的端口中，然后再由相关的芯片根据命令对外设实施控制。

可见，CPU通过端口和外部设备进行联系。

外中断信息

现在，我们知道了外设的输入被存放在端口中，可是外设的输入随时都有可能到达，CPU如何及时地知道，并进行处理呢？更一般地讲，就是外设随时都可能发生需要CPU及时处理的事件，CPU如何及时得知并进行处理？

       CPU提供中断机制来满足这种需要。前面讲过，当CPU的内部有需要处理的事情发生的时候，将产生中断信息，引发中断过程。这种中断信息来自CPU的内部。

       还有一种中断信息，来自于CPU外部，当CPU外部有需要处理的事情发生的时候，比如说，外设的输入到达，相关芯片将向CPU发出相应的中断信息。CPU在执行完当前指令后，可以检测到发送过来的中断信息，引发中断过程，处理外设的输入。

       在PC系统中，外中断源一共有两类：

1、可屏蔽中断

       可屏蔽中断是CPU可以不响应的外中断，CPU是否响应可屏蔽中断，要看标志寄存器的IF位的设置。当CPU检测到可屏蔽中断信息时，如果IF=1，则CPU在执行完当前指令后响应中断，引发中断过程；如果IF=0，则不响应可屏蔽中断。

       回忆一下内中断所引发的中断过程：

       1）取中断类型码n；

       2）标志寄存器入栈，IF=0，TF=0；

       3）CS、IP入栈；

       4）(IP)=(n*4)，(CS)=(n*4+2)

       由此转去执行中断处理程序。

       可屏蔽中断所引发的中断过程，除在第1步的实现上有所不同外，基本上和内中断的中断过程相同。因为可屏蔽中断信息来自于CPU外部，中断类型码是通过数据总路线送入CPU的；而内中断的中断类型码是在CPU内部产生的。

       现在，我们可以解释中断过程中将IF设置为0的原因了。将IF置0的原因就是，在进入中断处理程序后，禁止其他的可屏蔽中断。

       当然，如果在中断处理程序中需要处理可屏蔽中断，可以用指令将IF置1。8086CPU提供的设置IF的指令如下：

       sti，用于设置IF=1；

       cli，用于设置IF=0。

2、不可屏蔽中断

       不可屏蔽中断是CPU必须响应的外中断。当CPU检测到不可屏蔽中断信息时，则在执行完当前指令后，立即响应，引发中断过程。

       对于8086CPU，不可屏蔽中断的中断类型码固定为2，所以中断过程中，不需要取中断类型码。则不可屏蔽中断的中断过程为：

       （1）标志寄存器入栈，IF=0，TF=0；

       （2）CS、IP入栈；

       （3）(IP)=(8)，(CS)=(0AH)。

       几乎所有由外设引发的外中断，都是可屏蔽中断。当外设有需要处理的事件（比如说键盘输入）发生时，相关芯片向CPU发出可屏蔽中断信息。不可屏蔽中断是在系统中有必须处理的情况发生时用来通知CPU的中断信息。

PC机键盘的处理过程

下面来看一下键盘输入的处理过程，并以此来体会一下PC机处理外设输入的基本方法。

1、键盘输入

       键盘上的每一个键相当于一个开关，键盘中有一个芯片对键盘上的每一个键的开关状态进行扫描。

       按下一个键时，开关接通，该芯片就产生一个扫描码，扫描码说明了按下的键在键盘上的位置。扫描码被送入主板上的相关接口芯片的寄存器中，该寄存器的端口地址为60H。

       松开按下的键时，也产生一个扫描码，扫描码说明了松开的键在键盘上的位置。松开按键时产生的扫描码也被送入60H端口中。

       一般将按下一个键时产生的扫描码称为通码，松开一个键产生的扫描码称为断码。

       扫描码长度为一个字节，通码的第7位为0，断码的第7位为1，即：

       断码=通码+80H

       比如：g键的通码为22H，断码为a2H。

2、引发9号中断

       键盘的输入到达60H端口时，相关的芯片就会向CPU发出中断类型码为9的可屏蔽中断信息。CPU检测到该中断信息后，如果IF=1，则响应中断，引发中断过程，转去执行int 9中断例程。

3、执行int 9中断例程

       BIOS提供了int 9中断例程，用来进行基本的键盘输入处理，主要的工作如下：

       （1）读出60H端口中的扫描码；

       （2）如果是字符键的扫描码，将该扫描码和它所对应的字符码（即ASCII码）送入内存中的BIOS键盘缓冲区；如果是控制键（比如Ctrl）和切换键（比如CapsLock）的扫描码，则将其转变为状态字节（用二进制位记录控制键和切换键状态的字节）写入内存中存储状态字节的单元。

       （3）对键盘系统进行相关的控制，比如说，向相关芯片发出应答信息。

       BIOS键盘缓冲区是系统启动后，BIOS用于存放int 9中断例程所接收的键盘输入的内存区。该内存区可以存储15个键盘输入，因为int 9中断例程除了接收扫描码外，还要产生和扫描码对应的字符码，所以在BIOS键盘缓冲区中，一个键盘输入用一个字单元存放，高位字节存放扫描码，低位字节存放字符码。

       0040:17单元存储键盘状态字节，该字节记录了控制键和切换键的状态。键盘状态字节各位记录的信息如下：

       0：右shift状态，置1表示按下右shift键；

       1：左shift状态，置1表示按下左shift键；

       2：Ctrl状态，置1表示按下Ctrl键；

       3：Alt状态，置1表示按下Alt键；

       4：ScrolLock状态，置1表示Scroll指示灯亮；

       5：NumLock状态，置1表示小键盘输入的是数字；

       6：CapsLock状态，置1表示输入大写字母；

       7：Insert状态：置1表示处于删除状态。

编写int 9中断例程

键盘输入的处理过程：

1）键盘产生扫描码；

2）扫描码送入60h端口；

3）引发9号中断；

4）CPU执行int 9中断例程处理键盘输入。

上面的过程中，第（1）、（2）、（3）步都是由硬件系统完成的。我们能够改变的只有int 9的中断处理程序。

编程：在屏蔽中间依次显示“a”~“z”，并可以让人看清。在显示的过程中，按下Esc键后，改变显示的颜色。

assume cs:code

code segment

 start:  mov ax,0b800h

              mov es,ax

              mov ah,’a’

       s:     mov es:[160*12+40*2],ah

              inc ah

              cmp ah,’z’

              jna s

              mov ax,4c00h

              int 21h

code ends

end start

上面的程序的执行过程中，我们无法看清屏幕上的显示，因为一个字母刚显示到屏幕上，因为CPU执行指令太快了。

我们应该在每显示一个字母后，延时一段时间，让人看清后，再显示下一个字母。

那么如何延时呢？我们让CPU执行一段时间的空循环，因为现在的CPU的速度都非常快，所以循环的次数一定要大，我们用两个16位寄存器来存放32位的循环次数。如下：

       mov dx,10h

       mov ax,0

 s: sub ax,1

       sbb dx,0

       cmp ax,0

       jne s

       cmp dx,0

       jne s

上面的程序，循环100000h次。我们可以将循环延时的程序段写为一个子程序。

assume cs:code

stack segment

       db 128 dup (0)

stack ends

code segment

 start:    mov ax,stack

              mov ss,ax

              mov sp,128

              mov ax,0b800h

              mov ex,ax

              mov ah,’a’

     s:   mov es:[160*12+40*2],ah

              call delay

              inc ah

              cmp ah,’z’

              jna s

              mov ax,4c00h

              int 21h

 delay:   push ax

              push dx

              mov dx,1000h        ;循环10000000次，读者可以根据自己机器的速度调整循环次数

              mov ax,0

     s1: sub ax,1

              sbb dx,0

              jne sl

              cmp dx,0

              jne s1

              pop dx

              pop ax

              ret

code ends

end start

上面的程序，显示“a”~“z”，并可以让人看清，这个任务已经实现。

那么如何实现，按下Esc键后，改变显示的颜色呢？

       键盘输入到达60h端口后，就会引发9号中断，CPU则转去执行int 9中断例程。我们可以编写int 9中断例程，功能如下：

       （1）从60h端口读出键盘的输入；

       （2）调用BIOS的int 9中断全程，处理其他硬件细节；

       （3）判断是否为Esc键的扫描码，如果是，改变显示的颜色后返回；如果不是则直接返回。

分析：

1、从端口60h读出键盘的输入

       in al,60h

2、调用BIOS的int 9中断例程

       注意，我们写的中断处理程序要成为新的int 9中断例程，主程序必须要将中断向量表中的int 9中断例程的入口地址改为我们写的中断处理程序的入口地址。则在新的中断处理程序中调用原来的int 9中断例程时，中断向量表中的int 9中断例程的入口地址却不是原来的int 9中断例程的地址，所以我们不能使用int 指令直接调用。

       要能在我们写的新的中断例程中调用原来的中断例程，就必须在将中断向量表中的中断例程的入口地址改为新地址之前，将原来的入口地址保存起来。这样，在需要调用的时候我们才能找到原来的中断例程的入口。

       有了入口地址后，我们如何进行调用呢？

       当然不能使用指令int 9来调用，我们可以用别的指令来对int 指令进行一些模拟，从而实现对中断例程的调用。

       int指令在执行的时候，CPU进行下面的工作：

       1）取中断类型码n；

       2）标志寄存器入栈；

       3）IF=0，TF=0；

       4）CS、IP入栈；

       5）(IP)=(n*4)，(CS)=(n*4+2)。

       取中断类型码是为了定位中断例程的入口地址，在我们的问题中，中断例程的入口地址已经知道。所以，我们用别的指令模拟int指令时候，不需要做第(1)步。在假设要调用的中断例程的入口地址在ds:0和ds:2单元中的前提下，我们将int过程用下面几步模拟：

       1）标志寄存器入栈；

       2）IF=0，TF=0；

       3）CS、IP入栈；

       4）(IP)=((ds)*16+0)，(CS)=((ds)*16+2)。

所以int 过程的模拟过程变为：

       1）标志寄存器入栈；

       2）IF=0，TF=0；

       3）call dword ptr ds:[0]

对于（1），可用pushf实现。

对于（2），可用下面的指令实现。

pushf

pop ax

and ah,11111100b                 ;IF和TF为标志寄存的第9位和第8位

push ax

popf

则，模拟int指令的调用功能，调用入口地址在ds:0、ds:2中的中断例程的程序为：

pushf            ;标志寄存器入栈

pushf

pop ax

and ah,11111100b

push ax

popf                             ;IF=0, TF=0

call dword ptr ds:[0]      ;CS、IP入栈；(IP)=((ds)*16+0), (CS)=((ds)*16+2)

3、如果是Esc键扫描码，改变显示的颜色后返回

       如果改变显示的颜色？

       显示的位置是屏幕的中间，即第12行40列，显存中的偏移地址为：160*12+40*2。所以字符的ASCII码要送入b800:160*12+40*2处。而b800:160*12+40*2+1处是字符的属性，我们只要改变此处的数据就可以改变在b800:160*12+40*2处显示的字符的颜色了。

该程序的最后一个问题是，要在程序返回前，将中断向量表中的int 9中断例程的入口地址恢复为原来的地址。否则程序返回后，别的程序将无法使用键盘。

完整的程序如下：

assume cs:code

stack segment

 db 128 dup (0)

stack ends

data segment

 dw 0,0

data ends

code segment

 start:mov ax,stack

        mov ss,ax

        mov sp,128

        mov ax,data

        mov ds,ax

        mov ax,0

        mov es,ax

        push es:[9*4]

        pop ds:[0]

        push es:[9*4+2]

        pop ds:[2]      ;将原来的int 9中断例程的入口地址保存在ds:0、ds:2单元中

        mov word ptr es:[9*4],offset int9

        mov es:[9*4+2],cs   ;在中断向量表中设置新的int 9中断例程的入口地址

        mov ax,0b800h

        mov es,ax

        mov ah,'a'

     s: mov es:[160*12+40*2],ah

        call delay

        inc ah

        cmp ah,'z'

        jna s

        mov ax,0

        mov es,ax

        push ds:[0]

        pop es:[9*4]

        push ds:[2]

        pop es:[9*4+2]    ;将中断向量表中int 9中断例程的入口恢复为原来的地址

        mov ax,4c00h

        int 21h

 delay:push ax

        push dx

        mov dx,1000h

        mov ax,0

     s1:sub ax,1

        sbb dx,0

        cmp ax,0

        jne s1

        cmp dx,0

        jne s1

        pop dx

        pop ax

        ret

        ;-------以下为新的int 9中断例程------------------

 int9: push ax

        push bx

        push es

        in al,60h

        pushf

        pushf

        pop bx

        and bh,11111100b

        push bx

        popf

        call dword ptr ds:[0] ;对int指令进行模拟，调用原来的int 9中断例程

        cmp al,1

        jne int9ret

        mov ax,0b800h

        mov es,ax

        inc byte ptr es:[160*12+40*2+1]   ;将属性值加1，改变颜色

int9ret:pop es

        pop bx

        pop ax

        iret

code ends

end start

检测点15.1

（1）模拟int指令调用原int9中断例程的程序段是可以精简的，因为在进入中断例程后，IF和TF都已经置0，没有必要再进行设置了。

       对于程序段：

       pushf

       pushf

       pop ax

       and ah,11111100b

       push ax

       popf

       call dword ptr ds:[0]

可以精简为：

pushf

call dword ptr ds:[0]

再条指令。

（2）仔细分析上面程序中的主程序，会发现一个潜在的问题？在主程序中，如果在执行设置int9中断例程的段地址和偏移地址的指令之间发生了键盘中断，则CPU将转去一个错误的地址执行，将发生错误。

       排除潜在问题方法：

       在pop ds:[2]指令后加入一条cli指令，并在mov es:[9*4+2],cs指令后加入一条sti指令即可。意思是在这段期间，让IF=0，禁止或屏蔽外中断处事程序的执行。

安装新的int9中断处理例程

安装一个新的int 9中断例程，使得原int 9中断例程的功能得到扩展。

任务：安装一个新的int 9中断例程，功能：在DOS下，按F1键后改变当前屏幕的显示颜色，其他的键照常处理。

分析：

（1）改变屏幕的显示颜色

       改变从B8000开始的4000个字节中的所有奇地址单元中的内容，当前屏幕的显示颜色即发生改变。程序如下：

       mov ax,0b800h

       mov es,ax

       mov bx,1

       mov cx,2000

 s: nc byte ptr es:[bx]

       add bx,2

       loop s

（2）其他键照常处理

       可以调用原int 9中断处理程序，来处理其他的键盘输入。

（3）原int 9中断例程入口地址的保存

       因为在编写的新int 9中断例程中要调用原int 9中断例程，所以，要保存原int 9中断例程的入口地址。保存在哪里？显然不能保存在安装程序中，因为安装程序返回后地址将丢失。我们将地址保存在0:200单元处。

（4）新int 9中断例程的安装

       我们可将新的int 9中断例程安装在0:204处。

完整的程序如下：

assume cs:code

stack segment

 db 128 dup (0)

stack ends

code segment

 start:

        mov ax,stack

        mov ss,ax

        mov sp,128

        push cs

        pop ds

        mov ax,0

        mov es,ax

        mov si,offset int9    ;设置ds:si指向源地址

        mov di,204h           ;设置es:di指向目的地址

        mov cx,offset int9end - offset int9   ;设置cx为传输长度

        cld                   ;设置传输方向为正

        rep movsb

        push es:[9*4]

        pop es:[200h]

        push es:[9*4+2]

        pop es:[202h]     ;保存原有的int 9中断例程入口地址

        cli               ;设置IF为0，禁止CPU执行可屏蔽外中断。

        mov word ptr es:[9*4],204h

        mov word ptr es:[9*4+2],0   ;设置int 9中断向量，指向新的中断例程入口地址

        sti               ;恢复设置IF为1

        mov ax,4c00h

        int 21h

   int9:push ax

        push bx

        push cx

        push es

        in al,60h

        pushf

        call dword ptr cs:[200h]    ;当此中断例程执行时(CS)=0

        ;cmp al,1                  ;F1的扫描码为3bh

        ;jne int9ret

        mov ax,0b800h

        mov es,ax

        mov bx,1

        mov cx,2000

      s:mov byte ptr es:[bx],2

        ;inc byte ptr es:[bx]

        and bx,2

        loop s

int9ret:pop es

        pop cx

        pop bx

        pop ax

        iret

int9end:nop

code ends

end start

通过对键盘输入的处理，了解了CPU对外设输入的通常 通常方法，即：

1）外设的输入送入端口；

2）向CPU发出外中断（可屏蔽中断）信息；

3）CPU检测到可屏蔽中断信息，如果IF=1，CPU在执行完当前指令后响应中断，执行相应的中断例程；

4）可在中断例程中实现对外设输入的处理。

端口和中断机制，是CPU进行I/O的基础。

指令系统总结

8086CPU提供以下几大类指令：

1、数据传送指令

       mov, push, pop, pushf, popf, xchg等。

       实现寄存器和内存、寄存器和寄存器之间的单个数据传送。

2、自述运算指令

       add, sub, adc, sbb, inc, dec, cmp, imul, idiv, aaa 等。

       实现寄存器和内存中的数据的算术运算。它们的执行结果影响标志寄存器的：sf, zf, of, cf, pf, af位。

3、逻辑指令

       and, or, not, xor, test, shl, shr, sal, sar, rol, ror, rcl, rcr等。

       除了not指令外，它们的执行结果都影响标志寄存器的相关标志位。

4、转移指令

       可以修改IP，或同时修改CS和IP的指令统称为转移指令。分为以下几类：

       1）无条件转移指令，比如：jmp；

       2）条件转移指令，比如：jcxz, je, jb, ja, jnb, jna等；

       3）循环指令，比如：loop；

       4）过程，比如：call, ret, reft；

       5）中断，比如：int, iret。

5、处理机控制指令

       这些指令对标志寄存器或其他处理机状态进行设置，比如：cld, std, cli, sti, nop, clc, cmc, stc, hlt, wait, csc, lock等都是处理机控制指令。

6、串处理指令

       这些指令对内存中的批量数据进行处理，比如：movsb, movsw, cmps, scas, lods, stos等。

       基要使用这些指令方便地进行批量数据的处理，则需要和rep, repe, repne等前缀指令配合使用。

前面讲过，各种存储器都和CPU的地址线、数据线、控制线相连。CPU在操控它们的时候，把它们都当作内存来对待，把它们总的看做一个由若干存储单元组成的逻辑存储器，这个逻辑器我们称其为内存地址空间。

在PC机系统中，和CPU通过总线相连的芯片除各种存储器外，还有以下3种芯片：

1）各种接口卡（比如：网卡、显卡）上的接口芯片，它们控制接口卡进行工作；

2）主板上的接口芯片，CPU通过它们对部分外设进行访问；

3）其他芯片，用来存储相关的系统信息，或进行相关的输入输出处理。

在这些芯片中，都有一组可以由CPU读写的寄存器。这些寄存器，它们在物理上可能处于不同的芯片中，但是它们在以下两点上相同：

1）都和CPU的总线相连，当然这种连接是通过它们所在的芯片进行的；

2）CPU对它们进行读或写的时候都通过控制线向它们所在的芯片发出端口读写命令。

可见，从CPU的角度，将这些寄存器都当作端口，对它们进行统一编址，从而建立了一个统一的端口地址空间。每一个端口在地址空间中都有一个地址。

CPU可以直接读写3个地方的数据：

1）CPU内部的寄存器；

2）内存单元；

3）端口中。（芯片中的寄存器）

端口的读写

在访问端口的时候，CPU通过端口地址来定位端口。因为端口所在的芯片和CPU通过总路线相连，所以，端口地址和内存地址一样，通过地址总路线来传送。在PC系统中，CPU最多可以定位64K个不同的端口。则端口地址的范围为0~65535。

对端口的读写不能用mov，push，pop等内存读写指令。

端口的读写指令只有两条：in和out，分别用于从端口读出数据和往端口写入数据。

我们来看一下CPU执行内存访问指令和端口访问指令时候，总线上的信息：

1）访问内存：

       mov ax,ds:[8]               ;假设执行前(ds)=0

       执行时与总路线相关的操作：

       （1）CPU通过地址线将地址信息8发出；

       （2）CPU通过控制线发出内存读命令，选中存储器芯片，并通知它，将要从中读取数据；

       （3）存储器将8号单元中的数据通过数据线送入CPU。

2）访问端口：

       in al,60h         ;从60h号端口读入一个字节

       执行时与总路线相关的操作：

       （1）CPU通过地址线将地址信息60h发出；

       （2）CPU通过控制线发出端口读命令，选中端口所在的芯片，并通知它，将要从中读取数据；

       （3）端口所在的芯片将60h端口中的数据通过数据线送入CPU。

在in和out指令中，只能使用ax或al来存放从端口中读入的数据或要发送到端口中的数据。访问8位端口时用al，访问16位端口时用ax。

对0~255以内的端口进行读写时：

in al,20h         ;从20h端口读入一个字节

out 20h,al              ;往20h端口写入一个字节

对256~65535的端口进行读写时，端口号放在dx中：

mov dx,3f8h          ;将端口号3f8h送入dx

in al,dx                  ;从3f8h端口读入一个字节

out dx,al                ;向3f8h端口写入一个字节

CMOS RAM芯片

我们通过对CMOS RAM的读写来体会一下对端口的访问。

PC机中，有一个CMOS RAM芯片，一般简称为CMOS。此芯片的特征如下：

1）包含一个实时钟和一个有128个存储单元的RAM存储器（早期的计算机为64个字节）。

2）该芯片靠电池供电。所以，关机后其内部的实时钟仍可正常工作，RAM中的信息不丢失。

3）128个字节的RAM中，内部实时钟占用0~0dh单元来保存时间信息，其余大部分单元用来保存系统配置信息，供系统启动时BIOS程序读取。BIOS也提供了相关的程序，使我们可以在开机的时候配置CMOS RAM中的系统信息。

4）该芯片内部有两个端口，端口地址为70h和71h。CPU通过这两个端口来读写CMOS RAM。

5）70h为地址端口，存放要访问的CMOS RAM单元的地址：71h为数据端口，存放从选定的CMOS RAM单元中读取的数据。可见，CPU对CMOS RAM的读写分两步进行了，比如：读CMOS RAM的2号单元：

       （1）将2送入端口70h；

       （2）从71h读出2号单元的内容。

检测点14.1

1）编程：读取CMOS RAM的2号单元的内容。

       mov al,2h

       out 70h,al              ;把2写入地址端口。

       in 71h,al         ;把数据端口的内容读出放入al寄存器。

2）编程：向CMOS RAM的2号单元写入0。

       mov al,2h

       out 70h,al              ;把2写入地址端口

       mov al,0

       out 71h,al              ;把0写入数据端口

shl和shr指令

shl和shr是逻辑移位指令。

shl是逻辑左移指令，它的功能为：

1）将一个寄存器或内存单元中的数据向左移位；

2）将最后移出的一位写入CF中；

3）最低位用0补充。

指令：

mov al,01001000b

shl al,1                  ;将al中的数据左移一位

执行后(al)=10010000b，CF=0。

如果移动位数大于1时，必须将移动位数放在cl中。

比如，指令：

mov al,01010001b

mov cl,3

shl al,cl

执行后(al)=10001000b，因为最后移出的一位是1，所以CF=1。

可以看出，将X逻辑左移一位，相当于执行X=X*2。

shr是逻辑右移指令，它和shl所进行的操作刚好相反：

1）将一个寄存器或内存单元中的数据向右移位；

2）将最后移出的一位写入CF中。

3）最高位用0补充。

指令：

mov al,10000001b

shr al,1                  ;将al中的数据右移一位

执行后(al)=01000000b，CF=1

如果移动位数大于1时，必须将移动位数放在cl中。

比如，指令：

mov al,01010001b

mov cl,3

shr al,cl

执行后(al)=00001010b，因为最后移出的一位是0，所以CF=0。

可以看出将X逻辑右移一位，相当于执行X=X/2。

检测点14.2

编程：用加法和移位指令计算(ax)=(ax)*10

提示：(ax)*10 = (ax)*2 + (ax)*8

assume cs:code

code segment

 start:    mov ax,1000h

              mov bx,ax

              shl bx,1          ;(ax)=(ax)*2

              mov cl,3

              shl ax,cl         ;(ax)=(ax)*8

              add ax,bx              ;(ax)=(ax)*10

code ends

end start

CMOS RAM中存储的时间信息

在CMOS RAM中，存放着当前的时间：年、月、日、时、分、秒。这6个信息的长度都为1个字节，存放单元为：

秒：0     分：2     时：4     日：7     月：8     年：9

这些数据以BCD码的方式存放。

BCD码是以4位二进制数表示十进制数码的编码方法，如下表示：

比如：数值26，用BCD码表示为：0010 0110 （2 6）

可见，一个字节可表示两个BCD码。则CMOS RAM存储时间信息的单元中，存储了用两个BCD码表示的两位十进制数，高4位的BCD码表示十位，低4位的BCD码表示个位。比如：00010100b表示14。

编程：在屏幕中间显示当前的月份。

分析：这个程序主要做两部分工作：

（1）从CMOS RAM的8号单元读出当前月份的BCD码： 

       mov al,8         ;首先要向地址端口70h

       out 70h,al              ;写入要访问的单元的地址。

       in al,71h         ;然后，从数据端口71h中取得指定单元中的数据。

（2）将用BCD码表示的月份以十进制的形式显示到屏幕上。

       BCD码值=十进制数码值，则BCD码值+30h=十进制数对应的ASCII码。

       从CMOS RAM的8号单元读出的一个字节中，包含了两个BCD码表示的两位十进制数，高4位的BCD码表示十位，低4位的BCD码表示个位。比如：00010100表示14。

       我们需要进行两步工作：

1）将从CMOS RAM的8号单元中读出的一个字节，分为两个表示BCD码值的数据。

       mov ah,al              ;al中为从CMOS RAM的8号单元读出的数据

       mov cl,4

       shr ah,cl         ;ah中为月份的十位数码值

       and al,00001111b    ;al中为月份的个位数码值

       2）显示(ah)+30h和(al)+30h对应的ASCII码字符。

完整程序如下：

assume cs:code

code segment

 start:

        mov al,8

        out 70h,al

        in al,71h   ;从CMOS RAM的8号单元读出当前月份的BCD码。

        mov ah,al   ;ah,al都存储着当前月份的BCD码。

        mov cl,4

        shr ah,cl   ;ah中内容逻辑右移4位，则只剩下月份的十位数码。

        and al,00001111b ;al中内容将只剩下月份的个位数码。

        add ah,30h

        add al,30h ;得到十进制数码的ASCII码值。

        mov bx,0b800h

        mov es,bx

        mov byte ptr es:[160*12+40*2],ah ;显示月份的十位数码

        mov byte ptr es:[160*12+40*2+2],al ;显示月份的个位数码

        mov ax,4c00h

        int 21h

code ends

end start

中断信息可以来自CPU的内部和外部，当CPU的内部有需要处理的事情发生的时候，将产生需要马上处理的中断信息，引发中断过程。

上一章讲解了0号中断和单步中断，这一章将讲解另一种重要的内中断，由int指令引发的中断。

int指令

格式：int n

n为中断类型码，它的功能是引发中断过程。

CPU执行int n指令，相当于引发一个n号中断的中断过程，执行过程如下：

1）取中断类型码n；

2）标志寄存器入栈，IF=0，TF=0；

3）CS、IP入栈

4）（IP）=（n*4），(CS)=(n*4+2)

从此处转去执行n号中断的中断处理程序。

可以在程序中使用int指令调用任何一个中断的中断处理程序。

assume cs:code

code segment

 start:    mov ax,0b800h

              move s,ax

              mov byte ptr es:[12*160 +40*2],’!’

              int 0

code ends

end start

这个程序在Windows2000中的DOS方式下执行时，将在屏幕中间显示一个“！”，然后显示“Divide overflow”后返回到系统中。“！”是我们编程显示的，而“Divide overflow”是哪里来的呢？我们的程序中又没有做除法，不可能产生除法溢出。

程序是没有做除法，但是在结尾使用了int 0指令。

CPU执行int 0指令时，将引发中断过程，执行0号中断处理程序，而系统设置的0号中断处理程序的功能是显示“Divide overflow”，然后返回系统。

int指令的最终功能和call指令相似，都是调用一段程序。

一般情况下，系统将一些具有一定功能的子程序，以中断处理程序的方式提供给应用程序调用。我们在编程的时候，可以用int指令调用这些子程序。当然，也可以自己编写一些中断处理程序供别人使用。

中断处理程序可简称为中断例程。

编写供应用程序调用的中断例程

前面已经编写过中断0的中断例程了，现在我们讨论可以供应用程序调用的中断例程的编写方法。

1，示例一

编写、安装中断7ch的中断全程，功能：求一word型数据的平方。

参数：(ax)=要计算的数据。

返回值：dx、ax中存放结果的高16位和低16位。

应用举例：求2*3456^2

assume cs:code

code segment

 start:    mov ax,3456                 ;(ax)=3456

              int 7ch                         ;调用中断7ch的中断例程，计算ax中的数据的平方

              add ax,ax

              adc dx,dx                            ;dx:ax存放结果，将结果乘以2

              mov ax,4c00h

              int 21h          

code ends

end start

分析，我们要做三部分工作：

1）编写实现求平方功能的程序；

2）安装程序，我们将其安装在0:200处；

3）设置中断向量表，将程序的入口地址保存在7ch表项中，使其成为中断7ch的中断例程。

安装程序如下：

assume cs:code

code segment

 start:    mov ax,cs

              mov ds,ax

              mov si, offset sqr          ;设置ds:si指向源地址

              mov ax,0

              mov es,ax

              mov di, 200h                ;设置es:di指向目的地址

              mov cx, offset sqrend – offset sqr              ;设置cx为传输长度

              cld                               ;设置传输方向为正

              rep movsb

              mov ax,0

              mov es,ax

              mov word ptr es:[7ch*4],200h     ;设置中断向量表 偏移地址

              mov word ptr es:[7ch*4+2],0              ;设置中断向量表，段地址

              mov ax,4c00h

              int 21h

 sqr:     mul ax

              iret

 sqrend: nop

code ends

end start

注意，在中断例程sqr的最后，要使用iret指令。用汇编语法描述，iret指令的功能为：

pop IP

pop CS

popf

CPU执行int 7ch指令进入中断例程之前，标志寄存器、当前的CS和IP被压入栈中，在执行完中断例程后，应该用iret指令恢复int 7ch执行前的标志寄存器和CS、IP的值，从而接着执行应用程序。

int指令和iret指令的配合使用与call指令和ret指令的配合使用具有相似的思路。

2，示例二

编写、安装中断7ch的中断例程，功能：将一个全是字母，以0结尾的字符串，转化为大写。

参数：ds:si指向字符串的首地址。

应用举例：将data段中的字符串转化为大写。

assume cs:code

data segment

       db ‘conversation’,0

data ends

code segment

 start:    mov ax,data

              mov ds,ax

              mov si,0

              int 7ch

              mov ax,4c00h

              int 21h

code ends

end start

安装程序如下：

assume cs:code

code segment

 start:    mov ax,cs

              mov ds,ax

              mov si,offset capital

              mov ax,0

              mov es,ax

              mov di,200h

              mov cx,offset capitalend – offset capital

              cld

              rep movsb

              mov ax,0

              mov es,ax

              mov word ptr es:[7ch*4],200h

              mov word ptr es:[7ch*4+2],0

              mov ax,4c00h

              int 21h

 capital: push cx

              push si

       change:   mov cl,[si]

                     mov ch,0

                     jcxz ok

                     and byte ptr [si],11011111b

                     inc si

                     jmp short change

              ok:   pop si

                     pop cx

                     iret

 capitalend:     nop

code ends

end start

在中断例程capital中用到了寄存器si和cx，编写中断例程和编写子程序的时候具有同样的问题，就是要避免寄存器的冲突。应该注意例程中用到的寄存器的值的保存和恢复。

对int、iret和栈的深入理解

问题：用7ch中断例程完成loop指令的功能。

loop s的执行需要两个信息，循环次数和到s的位移，所以7ch中断例程要完成loop指令的功能，也需要这两个信息作为参数。我们用cx存放循环次数，用bx存放位移。

BIOS和DOS所提供的中断例程

在系统板的ROM中存放着一套程序，称为BIOS（基本输入输出系统），BIOS中主要包含以下几部分内容：

1）硬件系统的检测和初始化程序；

2）外部中断和内部中断的中断例程；

3）用于对硬件设备进行了I/O操作的中断例程；

4）其他和硬件系统相关的中断例程。

操作系统DOS也提供了中断例程，从操作系统的角度来看，DOS的中断例程就是操作系统向程序员提供的编程资源。

BIOS和DOS在所提供的中断例程中包含了许多子程序，这些子程序实现了程序员在编程的时候经常需要用到的功能。程序员在编程的时候，可以用int指令直接调用BIOS和DOS提供的中断例程，来完成某些工作。

和硬件设备相关的DOS中断例程中，一般都调用 了BIOS中的中断例程。

BIOS和DOS中断例程的安装过程

前面我们都是自己编写中断例程，将它们放到安装程序中，然后运行安装程序，将它们安装到指定的内存区中。此后，别的应用程序才可以调用。

而BISO和DOS提供的中断例程是如何安装到内存中的呢？

1）开机后，CPU一加电，初始化(CS)=0FFFFH，(IP)=0，自动从FFFF:0单元开始执行程序。FFFF:0处有一条转跳指令，CPU执行该指令后，转去执行BIOS中的硬件系统检测和初始化程序。

2）初始化程序将建立BIOS所支持的中断向量，即将BIOS提供的中断例程的入口地址登记在中断向量表中。注意，对于BIOS所提供的中断例程，只需要将入口地址登记在中断向量表中即可，因为它们是固化到ROM中的程序，一直在内存中存在。

3）硬件系统检测和初始化完成后，调用int 19h进行操作系统的引导。从此将计算机交由操作系统控制。

4）DOS启动后，除完成其他工作外，还将它所提供的中断例程装入内存，并建立相应的中断向量。

检测点13.2

1）我们可以编程改变FFFF:0处的指令，使得CPU不去执行BIOS中的硬件系统检测和初始化程序。错，此处内存单元为只读，无法改写。

2）int 19h中断例程，可以由DOS提供。错，int 19h指令是用于引导操作系统的比如DOS，DOS没有机会改变它。

BIOS中断例程应用

int 10h中断例程是BIOS提供的中断例程，其中包含了多个和屏幕输出相关的子程序。

一般来说，一个供程序员调用的中断例程中往往包括多个子程序，中断例程内部用传递进来的参数来决定执行哪一个子程序。BIOS和DOS提供的中断例程，都用ah来传递内部子程序的编号。

我们看一下int 10h中断例程的设置光标位置功能。

mov ah,2               ;置光标

mov bh,0               ;第0页

mov dh,5               ;行号

mov dl,12              ;列号

int 10h

(ah)=2表示调用第10h号中断例程的2号子程序，功能为设置光标位置，可以提供光标所在的行号(80*25字符模式中：0~24)、列号（80*25字符模式下：0~79），和页号作为参数。

(bh)=0，(dh)=5，(dl)=12，设置光标到第0页，第5页，第12列。

bh中页号的含义：内存地址空间中，B8000h~BFFFFh共32K的空间，为80*25彩色字符模式的显示缓冲区。一屏的内容在显示缓冲区中共占4000字节。

显示缓冲区分为8页，每页4K（≈4000），显示器可以显示任意一页的内容。一般情况下，显示第0页的内容。也就是说，通常情况下，B8000~B8F9F中的4000个字节的内容将出现在显示器上。(2*80*25=4000个字节)

再看一下int 10h中断例程的在光标位置显示字符功能。

mov ah,9               ;置光标

mov al,’a’              ;字符

mov bl,7                ;颜色属性

mov bh,0               ;第0页

mov cx,3               ;字符重复个数

int 10h

(ah)=9表示调用第10h号中断例程的9号子程序，功能为在光标位置显示字符，可以提供要显示的字符、颜色属性、页号、字符重复个数作为参数。

bh中的颜色属性的格式如下：

与显存中的属性字节的格式相同。

编程：在屏幕的5行12列显示3个红底高亮闪烁绿色的’a’。

assume cs:code

code segment

 start: mov ah,2    ;置光标

          mov bh,0    ;第0页

          mov dh,5    ;行号

          mov dl,12   ;列号

          int 10h

          mov ah,9    ;置光标

          mov al,'a' ;字符

          mov bl,11001010b ;颜色属性，闪烁的效果必须在全屏DOS方式下才能看到。

          mov bh,0    ;第0页

          mov cx,3    ;字符重复个数

          int 10h

          mov ax,4c00h

          int 21h

code ends

end start

DOS中断例程应用

int 21h中断例程是DOS提供的中断例程，其中包含了DOS提供给程序员在编程时调用的子程序。

我们从前一直使用的是int 21h中断例程的4ch号功能。即程序返回功能，如下：

mov ah,4ch           ;程序返回

mov al,0                ;返回值

int 21h

(ah)=4ch表示调用第21h号中断例程的4ch号子程序，功能为程序返回，可以提供返回值作为参数。

我们前面使用这个功能的时候经常写作：

mov ax,4c00h

int 21h

我们看一下int 21h中断例程的在光标位置显示字符串功能：

ds:dx 指向字符串        ;要显示的字符串需用“$”作为结束符

mov ah,9                      ;功能号9，表示在光标位置显示字符串

int 21h

(ah)=9表示调用第21h号中断例程的9号子程序，功能为在光标位置显示字符串，可以提供要显示字符串的地址作为参数。

编程：在屏幕的5行12列显示字符串“Welcome to masm!”。

;在屏幕的5行12列显示字符串“Welcome to masm!”

assume cs:code

data segment

 db 'Welcome to masm!','$' ;'$'本身不显示，只起到边界的作用。

data ends

code segment

 start:mov ah,2    ;置光标

        mov bh,0    ;第0页

        mov dh,5    ;行号

        mov dl,12   ;列号

        int 10h

        mov ax,data

        mov ds,ax

        mov dx,0    ;ds:dx指向字符串地首地址data:0

        mov ah,9

        int 21h

        mov ax,4c00h

        int 21h

code ends

end start

上述程序在屏幕的5行12列显示字符串“Welcome to masm”，直到遇见“$”（“$”本身并不显示，只起到边界的作用）。

如果字符串比较长，遇到行尾，程序会自动转到下一行开头处继续显示；如果到了最后一行，还能自动上卷一行。

DOS为程序员提供了许多可以调用的子程序，都包含在int 21h中断例程中，我们这里只对原理进行了讲解，对于DOS提供的所有可调用子程序的情况，读者可以参考相关的书籍。

任何一个通用的CPU，比如8086，都具备一种能力，可以在执行完当前正在执行的指令之后，检测到从CPU外部发送过来的或内部产生的一种特殊信息，并且可以立即对所接收到信息进行处理。这种特殊的信息，我们可以称其为：中断信息。

中断的意思是指，CPU不再接着（刚执行完的指令）向下执行，而是转去处理这个特殊信息。

注意，这里所说的中断信息，是为了便于理解而采用的一种逻辑上的说法。它是对几个具有先后顺序的硬件操作所产生的事件的统一描述。

“中断信息”是要求CPU马上进行某种处理，并向所要进行的该种处理提供了必备的参数的通知信息。

中断信息可以来自CPU的内部和外部。

内中断的产生

对于8086CPU，当CPU内部有下面的情况发生的时候，将产生相应的中断信息：

1） 除法错误，比如：执行div指令产生的除法溢出；

2） 单步执行；

3） 执行int0指令；

4） 执行int指令。

8086CPU用称为中断类型码的数据来标识中断信息的来源。中断类型码为一个字节数据，可以表示256种中断信息的来源。以后，我们将产生中断信息的事件，即中断信息的来源，简称为中断源，上述的4种中断源，在8086CPU中的中断类型码如下：

1） 除法错误：0

2） 单步执行：1

3） 执行int0指令：4

4） 执行int指令，该指令的格式为int n，指令中的n为字节型立即数，是提供给CPU的中断类型码。

中断处理程序

CPU收到中断信息后，需要对中断信息进行处理。

而如何对中断信息进行处理，可以由我们编程决定。

我们编写的，用来处理中断信息的程序被称为中断处理程序。

一般来说，需要对不同的中断信息编写不同的处理程序。

CPU在收到中断信息后，应该转去执行该中断信息的处理程序。

若要8086CPU执行某处的程序，就要将CS:IP指向它的入口（即程序第一条指令的地址）。

可见首要的问题是，CPU在收到中断信息后，如何根据中断信息确定其处理程序的入口。

CPU的设计者必须在中断信息和其处理程序的入口地址之间建立某种联系，使得CPU根据中断信息可以找到要执行的处理程序。

中断信息中包含有标识中断源的类型码。根据CPU的设计，中断类型码的作用就是用来定位中断处理程序。

若要定位中断处理程序，需要知道它的段地址和偏移地址，而如何根据8位的中断类型码得到中断处理程序的段地址和偏移地址呢？

中断向量表

CPU用8位的中断类型码通过中断向量表找到相应的中断处理程序的入口地址。

中断向量表就是中断向量的列表，中断向量，就是中断处理程序的入口地址。

中断向量表，就是中断处理程序入口地址的列表。

中断向量表在内存中保存，其中存放着256个中断源所对应的中断处理程序的入口。

CPU只要知道了中断类型码，就可以将中断类型码作为中断向量表的表项号，定位相应的表项，从而得到中断处理程序的入口地址。

中断向量表在内存中存放，对于8086PC机，中断向量表指定放在内存地址0处。从内存0000:0000到0000:03e8的1000个单元中存放着中断向量表。这是规定。

一个表项存放一个中断向量，也就是一个中断处理程序的入口地址，对于8086CPU，这个入口地址包括段地址和偏移地址，所以一个表项占两个字，四个字节，高地址字存放段地址，低地址字存放偏移地址。

存储N号中断源对应的中断处理程序入口的偏移地址的内存单元的地址为：N*4；

存储N号中断源对应的中断处理程序入口的段地址的内存单元的地址为：N*4+2。

（N从0开始。）

中断过程

可以用中断类型码，在中断向量表中找到中断处理程序的入口。

找到这个入口地址的最终目的是用它设置CS和IP，使CPU执行中断处理程序。

用中断类型码找到中断向量，并用它设置CS和IP，这个工作是由CPU的硬件自动完成的。

CPU硬件完成这个工作的过得被称为中断过程。

CPU收到中断信息后，要对中断信息进行处理，首先将引发中断过程。硬件在完成中断过程后，CS:IP将指向中断处理程序的入口，CPU开始执行中断处理程序。

8086CPU在收到中断信息后，所引发的中断过程：

1）（从中断信息中）取得中断类型码；

2）标志寄存器的值入栈；（因为在中断过程中要改变标志寄存器的值，所以先将其保存在栈中。）

3）设置标志寄存器的第8位TF和第9位IF的值为0；

4）CS的内容入栈；

5）IP的内容入栈；

6）从内存地址为中断类型码*4和中断类型码*4+2的两个字单元中读取中断处理程序的入口地址设置IP和CS。

CPU在收到中断信息之后，到处理该中断信息，就完成一个由硬件自动执行的中断过程（程序员无法改变这个过程中所要做的工作）。

中断过程的主要任务就是用中断类型码在中断向量表中找到中断处理程序的入口地址，设置CS和IP。

因为中断处理程序执行完成后，CPU还要回过头来继续执行被中断的程序，所以要在设置CS、IP之前，先将它们的值保存起来。

因为在执行中断处理程序后，需要恢复在进入中断处理程序之前的CPU现场（某一时刻，CPU中各个寄存器的值）。所以应该在修改标记寄存器之前，将它的值入栈保存。

我们更简洁地描述中断过程，如下：

1） 取得中断类型码N；

2） pushf

3） TF=0，IF=0

4） push CS

5） push IP

6） (IP)=(N*4), (CS)=(N*4+2)

在最后一步完成后，CPU开始执行由程序员编写的中断处理程序。

中断处理程序

由于CPU随时随地可能检测到中断信息，也就是说，CPU随时随地可能执行中断处理程序，所以中断处理程序必须一直存储在内存某段究竟之中。而中断处理程序的入口地址，即中断向量，处理存储在对应的中断向量表表项中。

中断处理程序的编写方法和子程序的比较相似，常规步骤如下：

1） 保存用到的寄存器。

2） 处理中断。

3） 恢复用到的寄存器。

4） 用iret指令返回。

iret指令的功能用汇编语法描述为：

pop IP

pop CS

popf

iret通常和硬件自动完成的中断过程配合使用。

iret指令执行后，CPU回到执行中断处理程序前的执行点继续执行程序。