RET指令

一．ret指令用栈中的数据，修改IP的内容，从而实现近转移；

 CPU执行ret指令时，进行下面两步操作：

a)         （1）(IP)=((ss)*16+(sp))

b)        （2）(sp)=(sp)+2

二．retf指令用栈中的数据，修改CS和IP的内容，从而实现远转移；

   CPU执行retf指令时，进行下面两步操作：

a)         （1）(IP)=((ss)*16+(sp))

b)        （2）(sp)=(sp)+2

c)         （3）(CS)=((ss)*16+(sp))

d)        （4）(sp)=(sp)+2

三．可以看出，如果我们用汇编语法来解释ret和retf指令，则：

a)         CPU执行ret指令时，相当于进行：

       pop IP

b).CPU执行retf指令时，相当于进行：

       pop IP

       pop CS

四．call 指令

CPU执行call指令，进行两步操作：

a)         （1）将当前的 IP 或 CS和IP 压入栈中；

b)        （2）转移。

call 指令不能实现短转移，除此之外，call指令实现转移的方法和 jmp 指令的原理相同。

解释：

n             call 标号（将当前的 IP 压栈后，转到标号处执行指令）

n             CPU执行此种格式的call指令时，进行如下的操作：

n   (1) (sp) = (sp) – 2

                   ((ss)*16+(sp)) = (IP)

n   (2) (IP) = (IP) + 16位位移

    call 标号

n       16位位移=“标号”处的地址－call指令后的第一个字节的地址；

n       16位位移的范围为 -32768~32767，用补码表示；

n       16位位移由编译程序在编译时算出。

五．综合实例演示：

看下面一段简单的代码：

Mov ax,0

Call s

Mov bx,0

S:add ax,1

Ret

解释如下：

Call s:实际上就是调用s处的子程序。并将Mov bx,0这条指令所对应的偏移地址入栈，此处为什么要入栈呢？实际上就是为了方便ret指令取出ip。

Ret指令实际上就是返回s，能使程序从mov bx,0处执行。

 

六．call 和 ret 的配合使用

1．例子1：

assume cs:code

code segment

start:       mov ax,1

           mov cx,3

          call s

           mov bx,ax      ;(bx) = ?

          mov ax,4c00h

          int 21h

     s:  add ax,ax

          loop s

           ret

code ends

end start

 

我们来看一下 CPU 执行这个程序的主要过程：

n       （1）CPU 将call  s指令的机器码读入，IP指向了call s后的指令mov bx,ax，然后CPU执行call s指令，将当前的 IP值（指令mov bx,ax的偏移地址）压栈，并将 IP 的值改变为标号 s处的偏移地址；

n       （2）CPU从标号 s 处开始执行指令，loop循环完毕，(ax)=8；

n       （3）CPU将ret指令的机器码读入，IP指向了ret 指令后的内存单元，然后CPU 执行 ret 指令 ，从栈中弹出一个值（即 call 先前压入的mov bx,ax 指令的偏移地址）送入 IP 中。则CS:IP指向指令mov bx,ax；

n       （4）CPU从 mov bx,ax 开始执行指令，直至完成。

 

   2．例子2

n       我们看一下程序的主要执行过程：

n       （1）前三条指令执行后，栈的情况如下：

 

n       2）call 指令读入后，(IP) =000EH，CPU指令缓冲器中的代码为 B8 05 00；

   CPU执行B8 05 00，首先，栈中的情况变为：

 

   然后，(IP)=(IP)+0005=0013H。

n       （3）CPU从cs:0013H处（即标号s处）开始执行。

n       （4）ret指令读入后：(IP)=0016H，CPU指令缓冲器中的代码为 C3；CPU执行C3，相当于进行pop IP，执行后，栈中的情况为：

 

  (IP)=000EH；

n       （5）CPU回到 cs:000EH处（即call指令后面的指令处）继续执行。

3．  从上面的讨论中我们发现，可以写一个具有一定功能的程序段，我们称其为子程序，在需要的时候，用call指令转去执行。

4．  可是执行完子程序后，如何让CPU接着call指令向下执行？

5．  call指令转去执行子程序之前，call指令后面的指令的地址将存储在栈中，所以可以在子程序的后面使用 ret 指令，用栈中的数据设置IP的值，从而转到 call 指令后面的代码处继续执行。

 

七．mul 指令

n       因下面要用到，我们介绍一下mul指令，mul是乘法指令，使用 mul 做乘法的时候：

n       (1)相乘的两个数：要么都是8位，要么都是16位。

     8 位： AL中和 8位寄存器或内存字节单元中；

   16 位： AX中和 16 位寄存器或内存字单元中。

n       (2)结果

     8位：AX中；

   16位：DX（高位）和AX（低位）中。

 

n       格式如下：

    mul reg

mul 内存单元

 

例子一：

n       例如：

n       （1）计算100*10

   100和10小于255，可以做8位乘法，程序如下：

        mov al,100

         mov bl,10

         mul bl

      结果： (ax)=1000（03E8H）

例子二：

n       （1）计算100*10000

   100小于255，可10000大于255，所以必须做16位乘法，程序如下：

        mov ax,100

         mov bx,10000

         mul bx

      结果： (ax)=4240H，(dx)=000FH

               （F4240H=1000000）

 

8．参数和结果传递的问题

n       我们设计一个子程序，可以根据提供的N，来计算N的3次方。

n       这里有两个问题：

n       （1）我们将参数N存储在什么地方？

n       （2）计算得到的数值，我们存储在什么地方？

 

很显然，我们可以用寄存器来存储，可以将参数放到 bx 中 ；因为子程序中要计算 N×N×N ，可以使用多个 mul 指令，为了方便，可将结果放到 dx 和 ax中。

n       子程序：

n       说明：计算N的3次方

n       参数： (bx)=N

n       结果： (dx:ax)=N∧3

  cube:mov ax,bx

   mul bx

   mul bx

   ret

n       用寄存器来存储参数和结果是最常使用的方法。对于存放参数的寄存器和存放结果的寄存器，调用者和子程序的读写操作恰恰相反：

n       调用者将参数送入参数寄存器，从结果寄存器中取到返回值；

n       子程序从参数寄存器中取到参数，将返回值送入结果寄存器。

9．批量数据的传递

n       前面的例程中，子程序 cube 只有一个参数，放在bx中。如果有两个参数，那么可以用两个寄存器来放，可是如果需要传递的数据有3个、4个或更多直至 N个，我们怎样存放呢？

n       寄存器的数量终究有限，我们不可能简单地用寄存器来存放多个需要传递的数据。对于返回值，也有同样的问题。

n       在这种时候，我们将批量数据放到内存中，然后将它们所在内存空间的首地址放在寄存器中，传递给需要的子程序。

n       对于具有批量数据的返回结果，也可用同样的方法。

如下代码：

 

10．寄存器冲突的问题

n       设计一个子程序：

n       功能：将一个全是字母，以0结尾的字符串，转化为大写。

n       分析

   应用这个子程序 ，字符串的内容后面定要有一个0，标记字符串的结束。子程序可以依次读取每个字符进行检测，如果不是0，就进行大写的转化，如果是0，就结束处理。

   由于可通过检测0而知道是否己经处理完整个字符串 ，所以子程序可以不需要字符串的长度作为参数。我们可以用jcxz来检测0。

添加主框架

assume cs:code

            data segment

                db 'conversation',0

            data ends

n       代码段中相关程序段如下：

            mov ax,data

            mov ds,ax

            mov si,0

            call capital

其中si运用了多次，怎么避免呢？

   从上而的问题中，实际上引出了个一般化的问题：子程序中使用的寄存器，很可能在主程序中也要使用，造成了寄存器使用上的冲突。

那么我们如何来避免这种冲突呢 ？粗略地看，我们可以有两个方案：

n       （1）在编写调用子程序的程序时 ，注意看看子程序中有没有用到会产生冲突的寄存器，如果有，调用者使用别的寄存器；

n       （2）在编写子程序的时候，不要使用会产生冲突的寄存器。

我们编写子程序的标准框架如下：

 子程序开始：子程序中使用的寄存器入栈

                    子程序内容

                     子程序使用的寄存器出栈

                     返回（ret、retf）

如下代码：

n       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

                  ret

n       要注意寄存器入栈和出栈的顺序。