[汇编]《汇编语言》第5章［BX］和 loop 指令
<h2 id="王爽汇编语言第四版-超级笔记">王爽《汇编语言》第四版 超级笔记</h2><p></p><div class="toc"><div class="toc-container-header">目录</div><ul><li>王爽《汇编语言》第四版 超级笔记<ul><li>第5章［BX］和 loop 指令<ul><li>5.1 </li><li>5.2 loop 指令</li><li>5.3 Debug和汇编编译器masm对指令的不同处理</li><li>5.4 loop和的联合应用</li><li>5.5 段前缀及使用</li><li>5.6 一段安全的空间</li></ul></li></ul></li></ul></div><p></p>
<h3 id="第5章bx和-loop-指令">第5章［BX］和 loop 指令</h3>
<p><strong>1、［bx］和 内存单元的描述</strong></p>
<p>［bx］是什么呢？和［0］有些类似，［0］表示内存单元，它的偏移地址是0。</p>
<p>比如在下面的指令中（在Debug中使用）：</p>
<p>mov ax,</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址为0，段地址在ds中。</p>
<p>mov al,</p>
<p>将一个内存单元的内容送入al，这个内存单元的长度为1字节（字节单元），存放一个字节，偏移地址为0，段地址在ds中。</p>
<p>要完整地描述一个内存单元，需要两种信息：</p>
<ul>
<li>①内存单元的地址；</li>
<li>②内存单元的长度（类型）。</li>
</ul>
<p>用［0］表示一个内存单元时，0表示单元的偏移地址，段地址默认在ds中，单元的长度（类型）可以由具体指令中的其他操作对象（比如说寄存器）指出。</p>
<p>［bx］同样也表示一个内存单元，它的偏移地址在bx中，比如下面的指令：</p>
<p>mov ax,</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址在bx中，段地址在ds中。</p>
<p>mov al,</p>
<p><strong>2、loop</strong></p>
<p>英文单词“loop”有循环的含义，显然这个指令和循环有关。</p>
<p><strong>3、我们定义的描述性的符号："（）”</strong></p>
<p>我们将使用一个描述性的符号“（）”来表示一个寄存器或一个内存单元中的内容。比如：</p>
<p>（ax）表示ax中的内容、（al）表示al中的内容;</p>
<p>(20000H)表示内存20000H单元的内容(()中的内存单元的地址为物理地址)；</p>
<p>注意，“()”中的元素可以有3种类型：</p>
<ul>
<li>①寄存器名；</li>
<li>②段寄存器名；</li>
<li>③内存单元的物理地址(一个20位数据)。</li>
</ul>
<p>我们看一下(X)的应用，比如：</p>
<blockquote>
<p>(1) ax中的内容为0010H，可以这样来描述：(ax)=0010H；</p>
<p>(2) 2000:1000处的内容为0010H，可以这样来描述：(21000H)=0010H；</p>
<p>(3) 对于mov ax,的功能，可以这样来描述：(ax)=((ds)x16+2)；</p>
<p>(4) 对于mov ,ax的功能，可以这样来描述：((ds)x16+2)=(ax)；</p>
<p>(5) 对于add ax,2的功能，可以这样来描述：(ax)=(ax)+2；</p>
<p>(6) 对于add ax,bx的功能，可以这样来描述：(ax)=(ax)+(bx)；</p>
<p>(7) 对于push ax的功能，可以这样来描述：<br>
(sp)=(sp)-2<br>
((ss)x16+(sp))=(ax)</p>
<p>(8) 对于pop ax的功能，可以这样来描述：<br>
(ax)=((ss)x16+(sp))<br>
(sp)=(sp)+2</p>
</blockquote>
<p>“(X)”所表示的数据有两种类型：①字节；②字。</p>
<p>是哪种类型由寄存器名或具体的运算决定。</p>
<p><strong>4、约定符号idata表示常量</strong></p>
<p>我们在Debug中写过类似的指令：mov ax,，表示将ds:0处的数据送入ax中。</p>
<p>指令中，在里用一个常量0表示内存单元的偏移地址。</p>
<p>以后，我们用idata表示常量。比如：</p>
<p>mov ax, 就代表 mov ax,、mov ax,、mov ax, 等。</p>
<p>mov bx,idata 就代表 mov bx,1、mov bx,2、mov bx,3 等。</p>
<p>mov ds,idata 就代表mov ds,1、mov ds,2 等，它们都是非法指令。</p>
<h4 id="51-bx">5.1 </h4>
<p>mov ax,</p>
<p>功能：bx中存放的数据作为一个偏移地址EA，段地址SA默认在ds中，将SA:EA处的数据送入ax中。即：(ax)=((ds)x16+(bx))。</p>
<p>mov ,ax</p>
<p>功能：bx中存放的数据作为一个偏移地址EA，段地址SA默认在ds中，将ax中的数据送入内存<br>
SA:EA处。即：((ds)x16+(bx))=(ax)。</p>
<p><strong>问题5.1</strong></p>
<p>程序和内存中的情况如图5.1所示，写出程序执行后，21000H-21007H单元中的内容。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817144829826-1009026385.png" alt="image" loading="lazy"></p>
<p>思考后看分析。</p>
<p>注意，inc bx 的含义是bx中的内容加1，比如下面两条指令:</p>
<p>mov bx,1<br>
inc bx</p>
<p>执行后，bx=2。</p>
<p>分析：</p>
<p>（1）先看一下程序的前3条指令：</p>
<p>mov ax,2000H<br>
mov ds,ax<br>
mov bx,1000H</p>
<p>这3条指令执行后，ds=2000H，bx=1000H。</p>
<p>（2）接下来，第4条指令：</p>
<p>mov ax,</p>
<p>指令执行前：ds=2000H，bx=1000H，则mov ax, 将把内存2000:1000处的字型数据送入ax中。该指令执行后，ax=00beH。</p>
<p>（3）接下来，第5、6条指令：</p>
<p>inc bx<br>
inc bx</p>
<p>这两条指令执行前bx=1000H，执行后bx=1002H。</p>
<p>（4）接下来，第7条指令：</p>
<p>mov ,ax</p>
<p>指令执行前：ds=2000H，bx=1002H，则mov ,ax 将把ax中的数据送入内存2000:1002处。</p>
<p>指令执行后，2000:1002单元的内容为BE，2000:1003单元的内容为00。</p>
<p>（5）接下来，第8、9条指令：</p>
<p>inc bx<br>
inc bx</p>
<p>这两条指令执行前bx=1002H，执行后bx=1004H。</p>
<p>（6）接下来，第10条指令：</p>
<p>mov ,ax</p>
<p>指令执行前：ds=2000H，bx=1004H，则mov ,ax 将把ax中的数据送入内存2000:1004处。</p>
<p>指令执行后，2000:1004单元的内容为BE，2000:1005单元的内容为00。</p>
<p>（7）接下来，第11条指令：</p>
<p>inc bx</p>
<p>这条指令执行前bx=1004H，执行后bx=1005H。</p>
<p>（8）接下来，第12条指令：</p>
<p>mov ,al</p>
<p>指令执行前：ds=2000H，bx=1005H，则mov ,al 将把al中的数据送入内存2000:1005处。</p>
<p>指令执行后，2000:1005单元的内容为BE。</p>
<p>（9）接下来，第13条指令：</p>
<p>inc bx</p>
<p>这条指令执行前bx=1005H，执行后bx=1006H。</p>
<p>（10）接下来，第14条指令：</p>
<p>mov ,al</p>
<p>指令执行前：ds=2000H，bx=1006H，则mov ,al 将把al中的数据送入内存2000:1006处。</p>
<p>指令执行后，2000:1006单元的内容为BE。</p>
<p>程序执行后，内存中的情况如图5.2所示。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817144919164-319701173.png" alt="image" loading="lazy"></p>
<h4 id="52-loop-指令">5.2 loop 指令</h4>
<p>loop指令的格式是：loop标号，CPU执行loop指令的时候，要进行两步操作：</p>
<ul>
<li>①(cx)=(cx)-l；</li>
<li>②判断CX中的值，不为零则转至标号处执行程序，如果为零则向下执行。</li>
</ul>
<p>从上面的描述中，可以看到，CX中的值影响着loop指令的执行结果。</p>
<p>通常(注意，我们说的是通常)我们用loop指令来实现循环功能，CX中存放循环次数。</p>
<p>下面我们通过一个程序来看一下loop指令的具体应用。</p>
<p>编程计算2^12。</p>
<p>分析：2<sup>12=2x2x2x2x2x2x2x2x2x2x2x2，若设(ax)=2，可计算(ax)=(ax)x2x2x2x2x2x2x2x2x2x2x2，最后(ax)中为2</sup>12的值。Nx2可用N+N实现，程序如下。</p>
<pre><code>assume cs:code
code segment
mov ax,2
;做11次 add ax,ax
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>可见，按照我们的算法，计算2^12需要11条重复的指令add ax,ax，我们显然不希望这样来写程序，这里，可用loop来简化我们的程序。</p>
<p><strong>程序5.1</strong></p>
<pre><code>assume cs:code
code segment
mov ax,2
mov cx,11
s: add ax,ax
loop s
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>下面分析一下程序5.1。</p>
<p>（1）标号</p>
<p>在汇编语言中，标号代表一个地址，程序5.1中有一个标号s。它实际上标识了一个地址，这个地址处有一条指令：add ax,ax。</p>
<p>（2）loop s</p>
<p>CPU执行loop s的时候，要进行两步操作:</p>
<ul>
<li>①(cx)=(cx)-l ；</li>
<li>②判断ex中的值，不为0则转至标号s所标识的地址处执行(这里的指令是add ax,ax)，如果为0则执行下一条指令(下一条指令是mov ax,4c00h)。</li>
</ul>
<p>（3）以下3条指令</p>
<pre><code> mov cx,11
s : add ax,ax
loop s
</code></pre>
<p>执行loop s时，首先要将(cx)减1，然后若(cx)不为0，则向前转至s处执行add ax,ax。</p>
<p>所以，可以利用cx来控制add ax,ax的执行次数。</p>
<p>下面我们详细分析一下这段程序的执行过程，从中体会如何用cx和loop s相配合实现循环功能。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817144949023-1897628321.png" alt="image" loading="lazy"><br>
<img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817144958119-1923806008.png" alt="image" loading="lazy"></p>
<p>从上面的过程中，我们可以总结出用cx和loop指令相配合实现循环功能的3个要点：</p>
<p>(1) 在cx中存放循环次数；</p>
<p>(2) loop指令中的标号所标识地址要在前面；</p>
<p>(3) 要循环执行的程序段，要写在标号和loop指令的中间。</p>
<p>用cx和loop指令相配合实现循环功能的程序框架如下。</p>
<pre><code> mov cx,循环次数
s:
循环执行的程序段
loop s
</code></pre>
<p>编程，用加法计算123x236，结果存在ax中。思考后看分析。</p>
<p>分析：</p>
<p>可用循环完成，将123加236次。可先设(ax)=0，然后循环做236次(ax)=(ax)+123。</p>
<p>程序如下</p>
<p><strong>程序5.2</strong></p>
<pre><code>assume cs:code
code segment
mov ax,0
mov cx,236
s:add ax,123
loop s
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<h4 id="53-debug和汇编编译器masm对指令的不同处理">5.3 Debug和汇编编译器masm对指令的不同处理</h4>
<p>我们在Debug中写过类似的指令：</p>
<p>mov ax,</p>
<p>表示将ds:0处的数据送入ax中。</p>
<p>但是在汇编源程序中，指令“mov ax,”被编译器当作指令“mov ax,0”处理。</p>
<p>下面通过具体的例子来看一下Debug和汇编编译器masm对形如“mov ax,”这类指令的不同处理。</p>
<p>任务：将内存2000:0、2000:1、2000:2、2000:3单元中的数据送入al、bl、cl、dl中。</p>
<p>（1）在Debug中编程实现：</p>
<pre><code>mov ax,2000
mov ds,ax
mov al,
mov bl,
mov cl,
mov dl,
</code></pre>
<p>（2）汇编源程序实现：</p>
<pre><code>assume cs:code
code segment
mov ax,2000h
mov ds,ax
mov al,
mov bl,
mov cl,
mov dl,
mov axz 4c00h
int 21h
code ends
end
</code></pre>
<p>我们看一下两种实现的实际实施情况：</p>
<p>（1）Debug中的情况如图5.16所示。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817145032806-927555698.png" alt="image" loading="lazy"></p>
<p>（2）将汇编源程序存储为compare.asm，用masm、link生成compare.exe，用Debug加载compare.exe，如图5.17所示。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817145102988-1208582231.png" alt="image" loading="lazy"></p>
<p>从图5.16、图5.17中我们可以明显地看出，Debug和编译器masm对形如“mov ax,”这类指令在解释上的不同。</p>
<p>我们在Debug中和源程序中写入同样形式的指令："mov al,"、"mov bl,"、"mov cl,"、"mov dl,”，但Debug和编译器对这些指令中的“”却有不同的解释。</p>
<p>Debug将它解释为“”是一个内存单元，“idata”是内存单元的偏移地址；而编译器将“”解释为“idata”。</p>
<p>那么我们如何在源程序中实现将内存2000:0、2000:1、2000:2、2000:3单元中的数据送入al、bl、cl、dl中呢?</p>
<p>目前的方法是，可将偏移地址送入bx寄存器中，用的方式来访问内存单元。比如我们可以这样访问2000:0单元：</p>
<pre><code>mov ax,2000h
mov ds,ax ;段地址2000h送入ds
mov bx,0 ;偏移地址0送入bx
mov al, ;ds:bx单元中的数据送入al
</code></pre>
<p>这样做是可以，可是比较麻烦，我们要用bx来间接地给出内存单元的偏移地址。</p>
<p>我们还是希望能够像在Debug中那样，在“[]”中直接给出内存单元的偏移地址。这样做，在汇编源程序中也是可以的，只不过，要在“[]”的前面显式地给出段地址所在的段寄存器。比如我们可以这样访问2000:0单元：</p>
<blockquote>
<p>mov ax,2000h<br>
mov ds,ax<br>
mov al,ds:</p>
</blockquote>
<p>比较一下汇编源程序中以下指令的含义。</p>
<ul>
<li>“mov al,”，含义：(al)=0，将常量0送入al中(与mov al,0含义相同)；</li>
<li>“mov al,ds:”，含义：(al)=((ds)x16+0)，将内存单元中的数据送入al中；</li>
<li>“mov al,”，含义：(al)=((ds)x16+(bx))，将内存单元中的数据送入al中；</li>
<li>“mov al,ds:”，含义：与“mov al,”相同。</li>
</ul>
<p>从上面的比较中可以看出：</p>
<p>（1）在汇编源程序中，如果用指令访问一个内存单元，则在指令中必须用“[…]”来表示内存单元，如果在“[]”里用一个常量idata直接给出内存单元的偏移地址，就要在“[]”的前面显式地给出段地址所在的段寄存器。比如</p>
<p>mov al,ds:</p>
<p>如果没有在“[]”的前面显式地给出段地址所在的段寄存器，比如</p>
<p>mov al,</p>
<p>那么，编译器masm将把指令中的“”解释为“idata”。</p>
<p>（2）如果在“[]”里用寄存器，比如bx，间接给出内存单元的偏移地址，则段地址默认在ds中。当然，也可以显式地给出段地址所在的段寄存器。</p>
<h4 id="54-loop和bx的联合应用">5.4 loop和的联合应用</h4>
<p>考虑这样一个问题，计算ffff:0～ffff:b单元中的数据的和，结果存储在dx中。</p>
<p>我们还是先分析一下。</p>
<p>（1）运算后的结果是否会超出dx所能存储的范围？</p>
<p>ffff:0～ffff:b内存单元中的数据是字节型数据，范围在0～255之间，12个这样的数据相加，结果不会大于65535，可以在dx中存放下。</p>
<p>（2）我们能否将ffff:0～ffff:b中的数据直接累加到dx中？</p>
<p>当然不行，因为ffff:0～ffff:b中的数据是8位的，不能直接加到16位寄存器dx中。</p>
<p>（3）我们能否将ffff:0～ffff:b中的数据累加到dl中，并设置(dh)=0，从而实现累加到dx中？</p>
<p>这也不行，因为dl是8位寄存器，能容纳的数据的范围在0～255之间，ffff:0～ffff:b中的数据也都是8位，如果仅向dl中累加12个8位数据，很有可能造成进位丢失。</p>
<p>（4）我们到底怎样将ffff:0～ffff:b中的8位数据，累加到16位寄存器dx中？</p>
<p>从上面的分析中，可以看到，这里面有两个问题：类型的匹配和结果的不超界。</p>
<p>具体地说，就是在做加法的时候，我们有两种方法：</p>
<blockquote>
<p>1、(dx)=(dx)+内存中的8位数据；</p>
<p>2、(dl)=(dl)+内存中的8位数据。</p>
</blockquote>
<p>第一种方法中的问题是两个运算对象的类型不匹配，第二种方法中的问题是结果有可能超界。</p>
<p>怎样解决这两个看似矛盾的问题？</p>
<p>目前的方法(在后面的课程中我们还有别的方法)就是得用一个16位寄存器来做中介。</p>
<p>将内存单元中的8位数据赋值到一个16位寄存器ax中，再将ax中的数据加到dx上，从而使两个运算对象的类型匹配并且结果不会超界。</p>
<p><strong>程序5.5</strong></p>
<pre><code>assume cs:code
code segment
mov ax,0ffffh
mov ds, ax ;设置(ds)=ffffh
mov dx,0 ;初始化累加寄存器，(dx)=0
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+0)=(ffff0h)
add dx,ax ;向dx中加上ffff:0单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+1)=(ffff1h)
add dx,ax ;向dx中加上ffff:1单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+2)=(ffff2h)
add dx,ax ;向dx中加上ffff:2单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+3)=(ffff3h)
add dx,ax ;向dx中加上ffff:3单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+4)=(ffff4h)
add dx,ax ;向dx中加上ffff:4单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+5)=(ffff5h)
add dx,ax ;向dx中加上ffff:5单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+6)=(ffff6h)
add dx,ax ;向dx中加上ffff:6单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+7)=(ffff7h)
add dx,ax ;向dx中加上ffff:7单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+8)=(ffff8h)
add dx,ax ;向dx中加上ffff:8单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+9)=(ffff9h)
add dx,ax ;向dx中加上ffff:9单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+0ah)=(ffffah)
add dx,ax ;向dx中加上ffff:a单元的数值
mov al,ds:
mov ah,0 ;(ax)=((ds)x16+0bh)=(ffffbh)
add dx,ax ;向dx中加上ffff:b单元的数值
mov ax,4c00h ;程序返回
int 21h
code ends
end
</code></pre>
<p>上面的程序很简单，不用解释，你一看就懂。不过，在看懂了之后，你是否觉得这个程序编得有些问题？</p>
<p>它似乎没有必要写这么长。这是累加ffff:0～ffff:b中的12个数据，如果要累加0000:0～0000:7fff中的32K个数据，按照这个程序的思路，将要写将近10万行程序（写一个简单的操作系统也就这个长度了）。</p>
<p><u><strong>问题5.4</strong></u></p>
<p>应用loop指令，改进程序5.5，使它的指令行数让人能够接受。</p>
<p>分析：</p>
<p>可以看出，在程序中，有12个相似的程序段，我们将它们一般化地描述为:</p>
<blockquote>
<p>mov al,ds:;ds:X指向ffff:X单元<br>
mov ah,0;(ax)=((ds)x16+(X))=(ffffXh)<br>
add dx,ax;向dx中加上ffff:X单元的数值</p>
</blockquote>
<p>从程序实现上，我们将循环做。</p>
<blockquote>
<p>(al)=((ds)x16+X)<br>
(ah)=0<br>
(dx)=(dx)+(ax)</p>
</blockquote>
<p>一共循环12次，在循环开始前(ds)=ffffh，X=0，ds:X指向第一个内存单元。每次循环后，X递增，ds:X指向下一个内存单元。</p>
<p>完整的算法描述如下。</p>
<p>初始化：</p>
<blockquote>
<p>(ds)=ffffh<br>
X=0<br>
(dx)=0</p>
</blockquote>
<p>循环12次：</p>
<blockquote>
<p>(al)=((ds)x16+X)<br>
(ah)=0<br>
(dx)=(dx)+(ax)<br>
X=X+1</p>
</blockquote>
<p>可见，表示内存单元偏移地址的X应该是一个变量，因为在循环的过程中，偏移地址必须能够递增。</p>
<p>这样，在指令中，我们就不能用常量来表示偏移地址。我们可以将偏移地址放到bx中，用［bx］的方式访问内存单元。在循环开始前设(bx)=0，每次循环，将bx中的内容加1即可。</p>
<p>最后一个问题是，如何实现循环12次？</p>
<p>我们的loop指令该发挥作用了。更详细的算法描述如下。</p>
<p>初始化：</p>
<blockquote>
<p>(ds)=ffffh<br>
(bx)=0<br>
(dx)=0<br>
(cx)=12</p>
</blockquote>
<p>循环12次：</p>
<pre><code>s:(al)=((ds)x16+(bx))
(ah)=0
(dx)=(dx)+(ax)
(bx)=(bx)+1
loop s
</code></pre>
<p>最后，我们写出程序。</p>
<p><strong>程序5.6</strong></p>
<pre><code>assume cs:code
code segment
mov ax,0ffffh
mov ds,ax
mov bx,0 ;初始化ds :bx指向ffff: 0
mov dx,0 ;初始化累加寄存器dx，(dx)=0
mov ex,12 ;初始化循环计数寄存器cx，(cx)=12
s:mov al,
mov ah,0
add dx,ax ;间接向dx中加上((ds)x16+(bx))单元的数值
inc bx;ds:bx指向下一个单元
loop s
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>在实际编程中，经常会遇到，用同一种方法处理地址连续的内存单元中的数据的问题。</p>
<p>我们需要用循环来解决这类问题，同时我们必须能够在每次循环的时候按照同一种方法来改变要访问的内存单元的地址。</p>
<p>这时，就不能用常量来给出内存单元的地址(比如，、、中，0、1、2是常量)，而应用变量。“mov al,”中的bx就可以看作一个代表内存单元地址的变量，我们可以不写新的指令，仅通过改变bx中的数值，改变指令访问的内存单元。</p>
<h4 id="55-段前缀及使用">5.5 段前缀及使用</h4>
<p>指令“mov ax,”中，内存单元的偏移地址由bx给出，而段地址默认在ds中。</p>
<p>我们可以在访问内存单元的指令中显式地给出内存单元的段地址所在的段寄存器。比如：</p>
<p>（1） mov ax,ds:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址在bx中，段地址在ds中。</p>
<p>（2）mov ax,cs:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址在bx中，段地址在cs中。</p>
<p>（3）mov ax,ss:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址在bx中，段地址在ss中。</p>
<p>（4）mov ax,es:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址在bx中，段地址在es中。</p>
<p>（5）mov ax,ss:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址为0，段地址在ss中。</p>
<p>（6）mov ax,cs:</p>
<p>将一个内存单元的内容送入ax，这个内存单元的长度为2字节（字单元），存放一个字，偏移地址为0，段地址在cs中。</p>
<p>这些岀现在访问内存单元的指令中，用于显式地指明内存单元的段地址的“ds:”“cs:”“ss:”“es:”，在汇编语言中称为<strong>段前缀</strong>。</p>
<hr>
<p>我们考虑一个问题，将内存ffff:0～ffff:b单元中的数据复制到0:200～0:20b单元中。</p>
<p>分析一下。</p>
<p>（1）0:200～0:20b单元等同于0020:0～0020:b单元，它们描述的是同一段内存空间。</p>
<p>（2）复制的过程应用循环实现，简要描述如下。</p>
<p>初始化：</p>
<p>X=0</p>
<p>循环12次：</p>
<p>将ffff:X单元中的数据送入0020:X(需要用一个寄存器中转)</p>
<p>X=X+1</p>
<p>（3）在循环中，源始单元ffff:X和目标单元0020:X的偏移地址X是变量。我们用bx来存放。</p>
<p>（4）将0:200～0:20b用0020:0～0020:b描述，就是为了使目标单元的偏移地址和源始单元的偏移地址从同一数值0开始。</p>
<p><strong>程序5.8</strong></p>
<pre><code>assume cs:code
code segment
mov bx,0 ;(bx)=0,偏移地址从0开始
mov cx,12 ;(cx)=12,循环12次
s: mov ax,0ffffh
mov ds,ax ;(ds)=0ffffh
mov dl, ;(dl)=((ds)x16+(bx)),将 ffff:bx中的数据送入dl
mov ax,0020h
mov ds,ax ;(ds)=0020h
mov ,dl ;((ds)x16+(bx))=(dl),将中dl的数据送入0020:bx
inc bx ;(bx) = (bx)+1
loop s
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>因源始单元ffff:X和目标单元0020:X相距大于64KB，在不同的64KB段里，程序5.8中，每次循环要设置两次ds。</p>
<p>这样做是正确的，但是效率不高。我们可以使用两个段寄存器分别存放源始单元ffff:X和目标单元0020:X的段地址，这样就可以省略循环中需要重复做12次的设置ds的程序段。</p>
<p>改进的程序如下。</p>
<p><strong>程序5.9</strong></p>
<pre><code>assume cs:code
code segment
mov ax,0ffffh
mov ds,ax ;(ds)=0ffffh
mov ax,0020h
mov es,ax ;(es)=0020h
mov bx,0 ;(bx)=0,此时ds:bx指向ffff:0,es:bx指向0020:0
mov cx,12 ;(cx)=12,循环 12 次
s:mov dl, ;(dl)=((ds)x16+(bx)),将ffff:bx中的数据送入dl
mov es:,dl;((es)x16+(bx))=(dl),将dl中的数据送入0020:bx
inc bx ;(bx)=(bx)+1
loop s
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>程序5.9中，使用es存放目标空间0020:0～0020:b的段地址，用ds存放源始空间ffff:0～ffff:b的段地址。</p>
<p>在访问内存单元的指令“mov es:,al”中，显式地用段前缀“es:”给出单元的段地址，这样就不必在循环中重复设置ds。</p>
<h4 id="56-一段安全的空间">5.6 一段安全的空间</h4>
<p>在8086模式中，随意向一段内存空间写入内容是很危险的，因为这段空间中可能存放着重要的系统数据或代码。比如下面的指令：</p>
<blockquote>
<p>mov ax,1000h<br>
mov ds,ax<br>
mov al,0<br>
mov ds:,al</p>
</blockquote>
<p>我们以前在Debug中，为了讲解上的方便，写过类似的指令。但这种做法是不合理的，因为之前我们并没有论证过1000:0中是否存放着重要的系统数据或代码。</p>
<p>如果1000:0中存放着重要的系统数据或代码，“mov ds:,al”将其改写，将引发错误。</p>
<p>比如下面的程序。</p>
<p><strong>程序5.7</strong></p>
<pre><code>assume cs:code
code segment
mov ax,0
mov ds,ax
mov ds:,ax
mov ax,4c00h
int 21h
code ends
end
</code></pre>
<p>将源程序编辑为p7.asm，编译、连接后生成p7.exe，用Debug加载，跟踪它的运行，如图5.18所示。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817145308840-409624762.png" alt="image" loading="lazy"></p>
<p>图5.18中，我们可以看到，源程序中的“mov ds:,ax”被masm翻译为机器码"a3 26 00"，而Debug将这个机器码解释为"mov ,ax"。</p>
<p>可见，汇编源程序中的汇编指令“mov ds:,ax”和Debug中的汇编指令"mov ,ax"同义。</p>
<p>我们看一下“mov ,ax”的执行结果，如图5.19所示。</p>
<p><img src="https://img2020.cnblogs.com/blog/1162354/202108/1162354-20210817145319214-1502633804.png" alt="image" loading="lazy"></p>
<p>图5.19中，是在windows2000的DOS方式中，在Debug里执行“mov ,ax”的结果。</p>
<p>如果在实模式（即纯DOS方式）下执行程序p7.exe，将会引起死机。产生这种结果的原因是0:0026处存放着重要的系统数据，而“mov ,ax”将其改写。</p>
<p>可见，在不能确定一段内存空间中是否存放着重要的数据或代码的时候，不能随意向其中写入内容。</p>
<p>同样不能忘记，我们正在学习的是汇编语言，要通过它来获得底层的编程体验，理解计算机底层的基本工作机理。所以我们尽量直接对硬件编程，而不去理会操作系统。</p>
<p>注意，我们在纯DOS方式(实模式)下，可以不理会DOS，直接用汇编语言去操作真实的硬件，因为运行在CPU实模式下的DOS，没有能力对硬件系统进行全面、严格的管理。</p>
<p>但在Windows2000、Unix这些运行于CPU保护模式下的操作系统中，不理会操作系统，用汇编语言去操作真实的硬件，是根本不可能的。硬件已被这些操作系统利用CPU保护模式所提供的功能全面而严格地管理了。</p>
<p>在一般的PC机中，DOS方式下，DOS和其他合法的程序一般都不会使用0:200～0:2ff(00200h～002ffh)的256个字节的空间。</p>
<p>所以，我们使用这段空间是安全的。不过为了谨慎起见，在进入DOS后，我们可以先用Debug查看一下，如果0:200～0:2ff单元的内容都是0的话，则证明DOS和其他合法的程序没有使用这里。</p>
<p>好了，我们总结一下：</p>
<p>（1）我们需要直接向一段内存中写入内容；</p>
<p>（2）这段内存空间不应存放系统或其他程序的数据或代码，否则写入操作很可能引发错误；</p>
<p>（3）DOS方式下，一般情况，0:200～0:2ff空间中没有系统或其他程序的数据或代码；</p>
<p>（4）以后，我们需要直接向一段内存中写入内容时，就使用0:200～0:2ff这段空间。</p><br><br>
来源：https://www.cnblogs.com/jpSpaceX/p/15130952.html
頁:
[1]