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

静静悄悄 發表於 2021-8-23 19:02:00

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

<h2 id="王爽汇编语言第四版-超级笔记">王爽《汇编语言》第四版超级笔记</h2>
<div class="toc"><div class="toc-container-header">目录</div><ul><li>王爽《汇编语言》第四版超级笔记<ul><li>第8章数据处理的两个基本问题<ul><li>8.1 bx、si、di和bp</li><li>8.2 机器指令处理的数据在什么地方、数据位置的表达</li><li>8.3 寻址方式、寻址方式的综合应用</li><li>8.4 指令要处理的数据有多长</li><li>8.5 div 指令、伪指令 dd、dup</li></ul></li></ul></li></ul></div>
<h3 id="第8章-数据处理的两个基本问题">第8章数据处理的两个基本问题</h3>
本章对前面的所有内容是具有总结性的。
计算机是进行数据处理、运算的机器，那么有两个基本的问题就包含在其中：
<ul>
<li>
处理的数据在什么地方？
</li>
<li>
要处理的数据有多长？
</li>
</ul>
这两个问题，在机器指令中必须给以明确或隐含的说明，否则计算机就无法工作。
本章中，我们就要针对8086CPU对这两个基本问题进行讨论。虽然讨论是在8086CPU的基础上进行的，但是这两个基本问题却是普遍的，对任何一个处理器都存在。
我们定义的描述性符号：reg和sreg。
为了描述上的简洁，在以后的课程中，我们将使用描述性的符号reg来表示一个寄存器，用sreg表示一个段寄存器。
reg的集合包括：ax、bx、ex、dx、ah、al、bh、bl、ch、cl、dh、dl、sp、bp、si、di；
sreg的集合包括：ds、ss、cs、es。
<h4 id="81-bxsidi和bp">8.1 bx、si、di和bp</h4>
寄存器总结如下：
(1) 在8086CPU中，只有这4个寄存器可以用在“[...]”中来进行内存单元的寻址。比如下面的指令都是正确的：
<blockquote>
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax,
</blockquote>
而下面的指令是错误的：
<blockquote>
mov ax, 
mov ax, 
mov ax, 
mov ax,
</blockquote>
(2) 在[...]中，这4个寄存器可以单个出现，或只能以4种组合出现：bx和si、bx和di、bp和si、bp和di。比如下面的指令是正确的：
<blockquote>
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax,
</blockquote>
下面的指令是错误的：
<blockquote>
mov ax, 
mov ax,
</blockquote>
(3) 只要在[…]中使用寄存器bp，而指令中没有显性地给岀段地址，段地址就默认在ss中。比如下面的指令。
<blockquote>
mov ax, 含义:(ax)=((ss)x16+(bp))
mov ax, 含义:(ax)=((ss)x16+(bp)+idata)
mov ax, 含义:(ax)=((ss)x16+(bp)+(si))
mov ax, 含义:(ax) =((ss)x16+(bp)+(si)+idata)
</blockquote>
<h4 id="82-机器指令处理的数据在什么地方数据位置的表达">8.2 机器指令处理的数据在什么地方、数据位置的表达</h4>
绝大部分机器指令都是进行数据处理的指令，处理大致可分为3类：读取、写入、运算。
在机器指令这一层来讲，并不关心数据的值是多少，而关心指令执行前一刻，它将要处理的数据所在的位置。
指令在执行前，所要处理的数据可以在3个地方：CPU内部、内存、端口(端口将在后面的课程中进行讨论)，比如表8.1中所列的指令。
<img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210823185659044-862397064.png" alt="image" loading="lazy">
<hr>
在汇编语言中如何表达数据的位置？汇编语言中用3个概念来表达数据的位置。
（1）立即数(idata)
对于直接包含在机器指令中的数据(执行前在CPU的指令缓冲器中)，在汇编语言中称为：立即数(idata)，在汇编指令中直接给出。
<blockquote>
例： 
mov ax,1 
add bx,2000h 
or bx,00010000b 
mov al,'a'
</blockquote>
（2）寄存器
指令要处理的数据在寄存器中，在汇编指令中给岀相应的寄存器名。
<blockquote>
例： 
mov ax,bx 
mov ds,ax 
push bx 
mov ds:,bx 
push ds 
mov ss,ax 
mov sp,ax
</blockquote>
（3）段地址(SA)和偏移地址(EA)
指令要处理的数据在内存中，在汇编指令中可用的格式给出EA，SA在某个段寄存器中。
存放段地址的寄存器可以是默认的，比如：
<blockquote>
mov ax, 
mov ax, 
mov ax, 
mov ax, 
mov ax,
</blockquote>
等指令，段地址默认在ds中；
<blockquote>
mov ax, 
mov ax, 
mov ax, 
mov ax,
</blockquote>
等指令，段地址默认在ss中。
存放段地址的寄存器也可以是显性给出的，比如以下的指令。
<blockquote>
mov ax,ds:            含义：(ax)=((ds)x16+(bp)) 
mov ax,es:             含义：(ax)=((es)x16+ (bx)) 
mov ax,ss:        含义：(ax)=((ss)x16+(bx)+(si)) 
mov ax,cs:    含义：(ax)=((cs)x16+(bx)+(si)+8)
</blockquote>
<h4 id="83-寻址方式寻址方式的综合应用">8.3 寻址方式、寻址方式的综合应用</h4>
当数据存放在内存中的时候，我们可以用多种方式来给定这个内存单元的偏移地址，这种定位内存单元的方法一般被称为寻址方式。
8086CPU有多种寻址方式，我们在前面的课程中都己经用到了，这里进行一下总结，如表8.2所列。
<img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210823185720642-1728552410.png" alt="image" loading="lazy">
<hr>
下面我们通过一个问题来进一步讨论一下各种寻址方式的作用。
关于DEC公司的一条记录（1982年）如下。
公司名称：DEC 
总裁姓名：Ken Olsen 
排名：137 
收入：40（40亿美元） 
著名产品：PDP（小型机）
这些数据在内存中以图8.1所示的方式存放。
<img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210823185739788-1586334811.png" alt="image" loading="lazy">
可以看到，这些数据被存放在seg段中从偏移地址60H起始的位置，从seg:60起始以ASCII字符的形式存储了3个字节的公司名称；从seg:60+3起始以ASCII字符的形式存储了9个字节的总裁姓名；从seg:60+0C起始存放了一个字型数据，总裁在富翁榜上的排名；从seg:60+0E起始存放了一个字型数据，公司的收入；从seg:60+10起始以ASCII字符的形式存储了3个字节的产品名称。
以上是该公司1982年的情况，到了1988年DEC公司的信息有了如下变化。
（1）Ken Olsen在富翁榜上的排名己升至38位； 
（2）DEC的收入增加了70亿美元； 
（3）该公司的著名产品己变为VAX系列计算机。
我们提出的任务是，编程修改内存中的过时数据。
首先，我们应该分析一下要修改的数据。
要修改内容是：
（1）(DEC公司记录)的(排名字段) 
（2）(DEC公司记录)的(收入字段) 
（3）(DEC公司记录)的(产品字段)的(第一个字符)、(第二个字符)、(第三个字符)
从要修改的内容，我们就可以逐步地确定修改的方法。
（1）要访问的数据是DEC公司的记录，所以，首先要确定DEC公司记录的位置：
<blockquote>
R=seg:60
</blockquote>
确定了公司记录的位置后，下面就进一步确定要访问的内容在记录中的位置。
（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处的数据。
根据上面的分析，程序如下。
<pre><code>mov ax,seg
mov ds,ax
mov bx,60h ;确定记录地址，ds:bx

mov word ptr ,38 ;排名字段改为38
add word ptr ,70 ;收入字段增加70

mov si,0 ;用si来定位产品字符串中的字符
mov byte ptr ,'V'
inc si
mov byte ptr ,'A'
inc si
mov byte ptr ,'X'
</code></pre>
如果你熟悉c语言的话，我们可以用c语言来描述这个程序，大致应该是这样的:
<pre><code>struct company ( /*定义一个公司记录的结构体*/
 char cn; /*公司名称*/
 char hn; /*总裁姓名*/
 int pm; /*排名*/
 int sr; /*收入*/
 char cp; /*著名产品*/
};

struct company dec={"DEC","Ken Olsen",137,40,"PDP"}; /*定义一个公司记录的变量，内存中将存有一条公司的记录*/

main()
{
int i;
dec.pm=38;
dec.sr=dec.sr+70;
i=0;
dec.cp='V';
i++;
dec.cp='A';
i++;
dec.cp='X';
return 0;
}
</code></pre>
我们再按照c语言的风格，用汇编语言写一下这个程序，注意和C语言相关语句的比对：
<pre><code>mov ax,seg
mov ds,ax
mov bx,60h ;记录首址送BX

mov word ptr .0ch,38 ;排名字段改为38 ;C:dec.pm=38;

add word ptr .0eh,70 ;收入字段增加70 ;C: dec.sr=dec.sr+70; ;产品字段改为字符串'VAX'

mov si,0 ;C:i=0;
mov byte ptr .10h,'V' ;dec.cp='V';
inc si ;i++；
mov byte ptr .10h,'A' ;dec.cp='A';
inc si ;i++；
mov byte ptr .10h,'X' ;dec.cp='X';
</code></pre>
我们可以看到，8086CPU提供的如的寻址方式为结构化数据的处理提供了方便。使得我们可以在编程的时候，从结构化的角度去看待所要处理的数据。
从上面可以看到，一个结构化的数据包含了多个数据项，而数据项的类型又不相同，有的是字型数据，有的是字节型数据，有的是数组(字符串)。
一般来说，我们可以用的方式来访问结构体中的数据。用bx定位整个结构体，用idata定位结构体中的某一个数据项，用si定位数组项中的每个元素。为此，汇编语言提供了更为贴切的书写方式，如：.idata、.idata。
在C语言程序中我们看到，如：dec.cp，dec是一个变量名，指明了结构体变量的地址，cp是一个名称，指明了数据项cp的地址，而i用来定位cp中的每一个字符。汇编语言中的做法是：bx.10h。
<h4 id="84-指令要处理的数据有多长">8.4 指令要处理的数据有多长</h4>
8086CPU的指令，可以处理两种尺寸的数据：byte和word。
所以在机器指令中要指明，指令进行的是字操作还是字节操作。对于这个问题，汇编语言中用以下方法处理。
（1）通过寄存器名指明要处理的数据的尺寸。
例如，下面的指令中，寄存器指明了指令进行的是字操作。
<blockquote>
mov ax,1 
mov bx,ds: 
mov ds,ax 
mov ds:,ax 
inc ax 
add ax,1000
</blockquote>
下面的指令中，寄存器指明了指令进行的是字节操作。
<blockquote>
mov al,1 
mov al,bl 
mov al,ds: 
mov ds:,al 
inc al 
add al,100
</blockquote>
（2）在没有寄存器名存在的情况下，用操作符X ptr 指明内存单元的长度，X在汇编指令中可以为word或byte。
例如，下面的指令中，用word ptr指明了指令访问的内存单元是一个字单元。
<blockquote>
mov word ptr ds:,1 
inc word ptr 
inc word ptr ds: 
add word ptr ,2
</blockquote>
下面的指令中，用byte ptr指明了指令访问的内存单元是一个字节单元。
<blockquote>
mov byte ptr ds:,1 
inc byte ptr 
inc byte ptr ds: 
add byte ptr ,2
</blockquote>
在没有寄存器参与的内存单元访问指令中，用word ptr或byte ptr显性地指明所要访问的内存单元的长度是很必要的。否则，CPU无法得知所要访问的单元是字单元，还是字节单元。
假设我们用Debug查看内存的结果如下：
2000:1000 FF FF FF FF FF FF ......
那么指令:
<blockquote>
mov ax,2000H 
mov ds,ax 
mov byte ptr ,1
</blockquote>
将使内存中的内容变为：
2000:1000 01 FF FF FF FF FF .....
而指令：
<blockquote>
mov ax,2000H 
mov ds,ax 
mov word ptr ,1
</blockquote>
将使内存中的内容变为：
2000:1000 01 00 FF FF FF FF .....
这是因为mov byte ptr ,1访问的是地址为ds:1000H的字节单元，修改的是 
ds:1000H单元的内容；而mov word ptr ,1访问的是地址为ds:1000H的字单元，修改的是ds:1000H和ds:1001H两个单元的内容。
（3）其他方法
有些指令默认了访问的是字单元还是字节单元，比如，push 就不用指明访问的是字单元还是字节单元，因为push指令只进行字操作。
<h4 id="85-div-指令伪指令-dddup">8.5 div 指令、伪指令 dd、dup</h4>
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存储除法操作的余数。
格式如下：
<blockquote>
div reg 
div 内存单元
</blockquote>
我们可以用多种方法来表示一个内存单元了，比如下面的例子：
<pre><code>div byte ptr ds:
含义：(al)=(ax)/((ds)x16+0)的商
(ah)=(ax)/((ds)x16+0)的余数

div word ptr es:
含义：(ax)=[(dx)x10000H+(ax)]/((es)x16+0)的商
(dx)=[(dx)x10000H+(ax)]/((es)x16+0)的余数

div byte ptr
含义：(al)=(ax)/((ds)x16+(bx)+(si)+8)的商
(ah)=(ax)/((ds)x16+(bx)+(si)+8)的余数

div word ptr
含义：(ax)=[(dx)x10000H+(ax)]/((ds)x16+ (bx)+(si)+8)的商
(dx)=[(dx)x10000H+(ax)]/((ds)x16+(bx)+(si)+8)的余数
</code></pre>
编程，利用除法指令计算100001/100。
首先分析一下，被除数100001大于65535，不能用ax寄存器存放，所以只能用dx和ax两个寄存器联合存放100001，也就是说要进行16位的除法。
除数100小于255，可以在一个8位寄存器中存放，但是，因为被除数是32位的，除数应为16位，所以要用一个16位寄存器来存放除数100。
因为要分别为dx和ax赋100001的高16位值和低16位值，所以应先将100001表示为16进制形式：186A1H。程序如下：
<blockquote>
mov dx,1 
mov ax,86A1H ;(dx)x10000H+(ax)=100001 
mov bx,100 
div bx
</blockquote>
程序执行后，(ax)=03E8H(即1000)，(dx)=1(余数为1)。读者可自行在Debug中实践。
编程，利用除法指令计算1001/100。
首先分析一下，被除数1001可用ax寄存器存放，除数100可用8位寄存器存放，也就是说，要进行8位的除法。程序如下。
<blockquote>
mov ax,1001 
mov bl,100 
div bl
</blockquote>
程序执行后，(al)=0AH(即10)，(ah)=1(余数为1)。读者可自行在Debug中实践。
<hr>
前面我们用db和dw定义字节型数据和字型数据。dd是用来定义dword(double word，双字)型数据的。比如：
<pre><code>data segment
db 1
dw 1
dd 1
data ends
</code></pre>
在data段中定义了3个数据：
<ul>
<li>第一个数据为01H，在data:0处，占1个字节；</li>
<li>第二个数据为0001H，在data:1处，占1个字；</li>
<li>第三个数据为00000001H，在data:3处，占2个字。</li>
</ul>
问题8.1
用div计算data段中第一个数据除以第二个数据后的结果，商存在第三个数据的存储单元中。
<pre><code>data segment
dd 100001
dw 100
dw 0
data ends
</code></pre>
思考后看分析。
分析：
data段中的第一个数据是被除数，为dword(双字)型，32位，所以在做除法之前，用dx和ax存储。
应将data:0字单元中的低16位存储在ax中，data:2字单元中的高16位存储在dx中。程序如下。
<pre><code>mov ax,data
mov ds,ax
mov ax,ds: ;ds:0字单元中的低16位存储在ax中
mov dx,ds: ;ds:2字单元中的高16位存储在dx中
div word ptr ds: ;用dx:ax中的32位数据除以ds:4字单元中的数据
mov ds:,ax ;将商存储在ds:6字单元中
</code></pre>
<hr>
dup是一个操作符，在汇编语言中同db、dw、dd等一样，也是由编译器识别处理的符号。
它是和db、dw、dd等数据定义伪指令配合使用的，用来进行数据的重复。比如：
<blockquote>
db 3 dup (0)
</blockquote>
定义了3个字节，它们的值都是0，相当于db 0,0,0。
<blockquote>
db 3 dup (0,1,2)
</blockquote>
定义了9个字节，它们是0、1、2、0、1、2、0、1、2，相当于db 0,1,2,0,1,2,0,1,2。
<blockquote>
db 3 dup ('abc','ABC')
</blockquote>
定义了18个字节，它们是'abcABCabcABCabcABC'，相当于 
db 'abcABCabcABCabcABC'。
可见，dup的使用格式如下。
<blockquote>
db 重复的次数 dup （重复的字节型数据） 
dw 重复的次数 dup （重复的字型数据） 
dd 重复的次数 dup （重复的双字型数据）
</blockquote>
dup是一个十分有用的操作符，比如要定义一个容量为200个字节的栈段，如果不用dup，则必须：
<pre><code>stack segment
dw 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
dw 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
dw 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
stack ends
</code></pre>
当然，你可以用dd，使程序变得简短一些，但是如果要求定义一个容量为1000字节或10000字节的呢？
如果没有dup，定义部分的程序就变得太长了，有了dup就可以轻松解决。如下：
<pre><code>stack segment
db 200 dup (0)
stack ends
</code></pre> 
来源：https://www.cnblogs.com/jpSpaceX/p/15161151.html

頁: [1]

琼殿技术论坛's Archiver

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

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