《汇编语言》第8章 数据处理的两个基本问题

本章对前面的所有内容是具有总结性的。我们知道，计算机是进行数据处理，运算的机器，那么有两个基本的问题就包含在其中：
（1）处理的数据在什么地方？
（2）要处理的数据有多长？
这两个问题，在机器指令中必须给以明确或隐含的说明，否则计算机就无法工作。本章中，我们就要针对8086CPU对这两个基本问题进行讨论。虽然讨论的是在8086CPU的基础上进行的，但是这两个基本问题却是普遍的，对任何一个处理机都存在。
我们定义的描述性符号：reg和sreg.
为了描述上的简洁，在以后的课程中，我们将使用两个描述性的符号reg来表示一个寄存器，用sreg表示一个段寄存器。
reg的集合包括：ax，bx,cx,dx,ah,al,bh,bl,ch,cl,dh,dl,sp,bp,si,di;
sreg的集合包括：ds,ss,cs,es.

8.1 bx,si,di和bp
前3个厅存器我们已经用过了，现在我们进行一下总结。
（1）在8086CPU中，只有这4个寄存器可以用在"[...]"中来进行内存单元的寻址。比如下面的指令都是正确的：
mov ax,[bx]
mov ax,[bx+si]
mov ax,[bx+di]
mov ax,[bp]
mov ax,[bp+si]
mov ax,[bp+di]
而下面的指令是错误的：
mov ax,[cx]
mov ax,[ax]
mov ax,[dx]
mov ax,[ds]

（2）在[...]中，这4个寄存器可以单个出现，或只能以4种组合出现：bx和si，bx和di,bp和si,bp和di。比如下面的指令是正确的：

mov ax,[bx]
mov ax,[si]
mov ax,[di]
mov ax,[bp]
mov ax,[bx+si]
mov ax,[bx+di]
mov ax,[bp+si]
mov ax,[bp+di]
mov ax,[bx+si+idata]
mov ax,[bx+di+idata]
mov ax,[bp+si+idata]
mov ax,[bp+di+idata]
下面的指令是错误的：
mov ax,[bx+bp]
mov ax,[si+di]
（3）只要在[...]中使用寄存器bp，而指令中没有显性地给出段地址，段地址就默认在 ss中。比如下面的指令。
mov ax,[bp]                    含义：(ax)=((ss)*16+(bp))
mov ax,[bp+idata]            含义：(ax)=((ss)*16+(bp)+idata)
mov ax,[bp+si]                含义：(ax)=((ss)*16+(bp)+(si))
mov ax,[bp+si+idata]        含义：(ax)=((ss)*16+(bp)+(si)+idata)

8.2 机器指令处理的数据在什么地方
绝大部分机器指令都是进行数据处理的指令，处理大致可分为3类：读取，写入，运算。在机器指令这一层来讲，并不关心数据的值是多少，而关心指令执行前一刻，它将要处理的数据所在的位置。指令在执行前，所要处理的数据可以在3个地方：CPU内部，内存，端口（嘀 口将在后面的课程中进行讨论），比如表8.1中所列的指令。

8.3 汇编语言中数据位置的表达
在汇编语言中如何表达数据的位置？汇编语言中用3个概念来表达数据的位置。
（1）立即数(idata)
对于直接包含在机器指令中的数据（执行前在CPU的指令缓冲器中），在汇编语言中称为：立即数(idata),在汇编指令中直接给出。
例：mov ax,1
    add bx,2000h
    or     bx,00010000B
    mov al,'a'
（2）寄存器
指令要处理的数据在寄存器中，在汇编指令给出相应的寄存器名。
例：mov ax,bx
    mov ds,ax
    push bx
    mov ds:[0],bx
    push ds
    mov ss,ax
    mov sp,ax

（3）段地址（SA）和偏移地址（EA）
指令要处理的数据在内存中，在汇编指令中可用[X]的格式给EA，SA在某个段寄存器中。
存放段地址的寄存器可以是默认的，比如：
mov ax,[0]
mov ax,[di]
mov ax,[bx+8]
mov ax,[bx+si]
mov ax,[bx+si+8]
等指令，段地址默认在ds中；
mov ax,[bp]
mov ax,[bp+8]
mov ax,[bp+si]
mov ax,[bp+si+8]
等指令，段地址默认在ss中。
存放段地址的寄存器也可以是显性给出的，比如以下的指令。
mov ax,ds:[bp]        含义：(ax)=((ds)*16+(bp))
mov ax,es:[bx]        含义：(ax)=((es)*16+(bx))
mov ax,ss:[bx+si]    含义：(ax)=((ss)*16+(bx)+(si))
mov ax,cs:[bx+si+8]    含义：(ax)=((cs)*16+(bx)+(si)+8)

8.4 寻址方式
当数据存放在内存中的时候，我们可以用多种方式来给定这个内存单元的偏移地址，这种定位内存单元的方法一般被称为寻址方式。
8086CPU有多种寻址方式，我们在前面的课程中都已经用到了，这里进行一下总结，如表8.2所列。

8.5 指令要处理的数据有多长
8086CPU的指令，可以处理两种尺寸的数据，byte和word。所以在机器指令中要指明，指令进行的是字操作还是字节操作。对于这个问题，汇编语言中用以下方法处理。
（1）通过寄存器名指明要处理的数据的尺寸。
例如，下面的指令中，寄存器指明了指令进行的是字操作。
mov ax,1
mov bx,ds:[0]
mov ds,ax
mov ds:[0],ax
inc ax
add ax,1000
下面的指令中，寄存器指明了指令进行的是字节操作。
mov al,1
mov al,bl
mov al,ds:[0]
mov ds:[0],al
inc al
add al,100
（2）在没有寄存器名存在的情况下，用操作符X ptr指明内存单元的长度，X在汇编指令中可以为word或byte。
例如，下面的指令中，用word ptr指明了指令访问的内存单元是一个字单元。
mov word ptr ds:[0],1
inc word ptr [bx]
inc word ptr ds:[0]
add word ptr [bx],2
下面的指令中，用byte ptr指明了指令访问的内存单元是一个字节单元。
mov byte ptr ds:[0],1
inc byte ptr [bx]
inc byte ptr ds:[0]
add byte ptr [bx],2
在没有寄存器参考的内存单元访问指令中，用word ptr或byte ptr显性地指明所要访问的内存单元的长度是很必要的。否则，CPU无法得知所要访问的单元是字单元，还是字节单元。假设我们用debug查看内存的结果如下：
2000:1000 FF FF FF FF FF FF ......
那么指令：
mov ax,2000H
mov ds,ax
mov byte ptr [1000H],1
将使内存中的内容变为：
2000:1000 01 FF FF FF FF FF ......
而指令：
mov ax,2000H
mov ds,ax
mov  word ptr [1000H],1
将使内存中的内容变为：
2000:1000 01 00 FF FF FF FF ......
这是因为mov byte ptr [1000H],1 访问的是地址为ds:1000H的字节单元，修改的是ds:1000H单元的内容；而mov word ptr[1000H],1访问的是地址为ds:1000H的字单元，修改的是ds:1000H和ds:1001H两个单元的内容。
（3）其他方法
有些指令默认了访问的是字单元还是字节单元，比如，push [1000H]就不用指明访问的是字单元还是字节单元，因为push指令只进行字操作。

8.6 寻址方式的综合应用
下面我们通过一个问题来讲一步讨论一下各种寻址方式的作用。
关于DEC公司的一条记录(1982年)如下。
公司名称：DEC  
总裁姓名：Ken Olsen
排    名：137
收    入：40（40亿美元）
著名产品：PDP（小型机）
这些数据在内存中以图8.1所示的方式存放。
可以看到，这些数据被存放在seg段中从偏移地址60H起始的位置，从seg:60起始以ASCII字符的形式存储了3个字节的公司名称：从seg:60+3起始以ASCII字符的形式存储了9个字节的总裁姓名：从seg:60+0C起始存放了一个字型数据，总裁在富翁榜上的字符的形式存储了3个字节的产品名称。

以上是该公司1982年 情况，到了1988年DEC公司的信息有了如下变化。
（1）Ken Olsen在富翁榜上的排名已升至38位；
（2）DEC的收入增加了70亿美元；
（3）该公司的著名产品已变为VAX系列计算机。
我们提出的任务是，编程修改内存中的过时数据。
首先，我们应该分析一下要修改的数据。
要修改内容是：
（1）（DEC公司记录）的排名字段
（2）（DEC公司记录）的收入字段
（3）（DEC公司记录）的产品字段的第一个字符，第二个字符，第三个字符。
从要修改的内容，我们就可以逐步地确定修改的方法。
（1）要访问的数据是DEC公司的记录，所以，首先要确定DEC公司记录的位置：R=seg:60
确定了公司记录的位置后，下面就进一步确定要访问的内容在记录中的位置。
（2）确定排名字段在记录中的位置：0CH。
（3）修改R+0CH处的数据。
（4）确定收入字段在记录中的位置：0EH。
（5）修改R+0EH处的数据。
（6）确定产品字段在记录中的位置：10H。
要修改的产品字段是一个字符串（或一个数组），需要访问字符串中的每一个字符。
（7）确定第一个字符在产品字段中的位置：P=0。
（8）修改R+10H+P处的数据：P=P+1。
（9）修改R+10H+P处的数据：P=P+1。
（10）修改R+10H+P处的数据。

根据上面的分析，程序如下。
mov ax,seg
mov ds,ax
mov bx,b0H                    ;确定记录地址，ds:bx

mov word ptr [bx+0ch],38    ;排名字段改为38
add word ptr [bx+0eh],70    ;收入字段增加中70

mov si,0                    ;用si来定位产品字符串中的字符
mov byte ptr [bx+10h+si],'V'
inc si
mov byte ptr [bx+10h+si],'A'
inc si
mov byte ptr [bx+10h+si],'X'
如果你熟悉C语言的话，我们可以用C语言来描述这个程序，大致应该是这样的：
struct company {                //定义一个公司记录的结构体
    char cn[3];                    //公司名称
    char hn[9];                    //总裁姓名
    int pm;                         //排名
    int sr;                            //收入
    char cp[3]                    //著名产品
};
struct company dec={"DEC", "Ken Olsen", 137, 40, "PDP"};
//定义一个公司记录的变量，内存中将存有一条公司的记录
int main()
{
    int i;
    dec.pm = 38;
    dec.sr = dec.sr + 70;
    i = 0;
    dec.cp[i] = 'V';
    i++;
    dec.cp[i] = 'A';
    i++;
    dec.cp[i] = 'X';
    return 0;
}    
我们再按照C语言的风格，用汇编语言写一下这个程序，注意和C语言相关语句的比对：
mov ax,seg
mov ds,ax
mov bx,60h                             ;记录首址送BX
mov word ptr [bx].0ch,38        ;排名字段改为38  C:dec.pm=38
add word ptr [bx].0eh,70        ;收入字段增加70  C:dec.sr = dec.sr+70
                                               ;产品字段改为字符串‘VAX’
mov si,0                                  ;C:i=0;
mov byte ptr [bx].10h[si],'V'    ;dec.cp[i]='V'
inc si                                       ;i++;
mov byte ptr [bx].10h[si].'A'    ;dec.cp[i]='A'
inc si                                       ;i++
mov byte ptr [bx].10h[si],'X'    ;dec.cp[i]='X'

我们可以看到，8086CPU提供的如[bx+si+idata]的寻址方式为结构化数据的处理提供了方便。使得我们可以在编程的时候，从结构化的角度去看待所要处理的数据。从上面可以看到，一个结构化的数据包含了多个数据项，而数据项的类型又不相同，有的是字型数据，有的是字节数据，有的是数组（字符串）。一般来说，我们可以用[bx+idata+si]的方式来访问结构体中的数据。用bx定位整个结构体，用idata定位结构体中的某一个数据项，用si定位数组项中的每个元素。为此，汇编语言提供了更为贴切的书写方式，如：[bx].idata,[bx].idata[si].
在C语言程序中我们看到，如：dec.cp[i],dec是一个变量名，指明了结构体变量的地址，cp是一个名称，指明了数据项cp的地址，而i用来定位cp中的每一个字符。汇编语言中的做法是：bx,10h[si]。看一下，是不是很相似？

8.7 div 指令
div是除法指令，使用div做除法的时候应注意以下问题。
（1）除数：有8位和16位两种，在一个reg或内存单元中。
（2）被除数：默认放在AX或DX和AX中，如果除数为8位，被除数则为16位，默认在AX中存放；如果除数为16位，被除数则为32位，在DX和AX中存放，DX存放高16位，AX存放低16位。
（3）结果：如果除数为8位，则AL存储除法操作的商，AH存储除法操作的余数；如果除数为16位，则AX存储除法操作的商，DX存储除法操作的余数。
格式如下：
div reg
div 内存单元
现在，我们可以用多种方法来表示一个内存单元了，比如下面的例子；
div byte ptr ds:[0]
含义：     (al)=(ax)/((ds)*16+0)的商
                (ah)=(ax)/((ds)*16+0)的余数
div word ptr es:[0]
含义：     (ax)=[(dx)*10000H+(ax)]/((es)*16+0)的商
                (ah)=[(dx)*10000H+(ax)]/((es)*16+0)的余数        
div byte ptr [bx+si+8]
含义：     (al)=(ax)/((ds)*16+(bx)+(si)+8)的商
                (ah)=(ax)/((ds)*16+(bx)+(si)+8)的余数
div word ptr [bx+si+8]
含义：     (ax)=[(dx)*10000H+(ax)]/((ds)*16+(bx)+(si)+8)的商
                (dx)=[(dx)*10000H+(ax)]/((ds)*16+(bx)+(si)+8)的余数
编程，利用除法指令计算100001/100
首先分析一下，被除数100001大于65535，不能用ax寄存器存放，所以只能用dx和ax两个寄存器联合存放100001，也就是说要进行16位的除法，除数100小于255，可以在一个8位寄存器存放，但是，因为被除数是32位的，除数应为16位，所以要用一个16位寄存器来存放除数100.
因为要分别为dx和ax赋100001的高16位值和低16位值，所以应先将100001表示为16进制形式：186A1H。程序如下：
mov dx,1
mov ax,86A1H        ;(dx)*10000H+(ax)=100001
mov bx,64h              ;100的16进制为64h
div bx
程序执行后，(ax)=03E8H（即1000），(dx)=1（余数为1）。

 

 程序验证OK

8.8 伪指充dd
前面我们用dd和dw定义字节型数据和字型数据。dd是用来定义dword（double word，双字）型数据的。比如：
data segment
    db 1
    dw 1
    dd 1
data ends
在data段中定义了3个数据：
第一个数据为01H，在data:0处，占1个字节；
第二个数据为0001H，在data:1处，占1个字；
第三个数据为00000001H，在data:3处，占2个字。
问题8.1

用div计算data段中第一个数据除以第二个数据后的结果，商存在第三个数据的存储单元中。
data segment
    dd 100001
    dw 100
    dw 0
data ends
分析：
data段中的第一个数据是被除数，为dword（双字）型，32位，所以在做除法之前，用dx和ax存储。应将data:0字单元中的低16位存储在ax中，data:2字单元中的高16位存储在dx中。程序如下。
mov ax,data
mov ds,ax
mov ax,ds:[0]        ;ds:0字单元中的低16位存储在ax中
mov dx,ds:[2]        ;ds:2字单元中的高16位存储在dx中
div word ptr ds:[4]    ;用dx:ax中的32位数据除除以ds:4字单元中的数据
mov ds:[6],ax        ;将商存储在ds:6字单元中

8.9 dup
dup是一个操作符，在汇编语言中同db,dw,dd等一样，也是由编程器识别处理的符号。它是和db,dw,dd等数据定义伪指令配合使用的，用来进行数据的重复。比如：
db 3 dup (0)
定义了3个字节，它们的值都是0，相当于db 0,0,0。
db 3 dup (0,1,2)
定义了9个字节，它们是0，1，2，0，1，2，0，1，2，相当于db 0,1,2,0,1,2,0,1,2。
db 3 dup ('abc','ABC')
定义了18个字节，它们是'abcABCabcABCabcABC’，相当于db 'abcABCabcABCabcABC’。
可见，dup的使用格式如下。
db 重复的次数 dup (重复的字节型数据)
dw 重复的次数 dup (重复的字型数据)
dd 重复的次数 dup (重复的双字型数据)
dup是一个十分有用的操作符，比如要定义一个容量为200个字节的栈段，如果不用dup,则必须：
stack segment
    dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
stack ends
当然，你可以用dd,使程序变得简短一些，但是如果要求定义一个容量为1000字节或10000字节的呢？如果没有dup,定义部分的程序就变得太长了，有了dup就可以轻松解决。如下：
stack segment
    db 200 dup （0）
stack ends