call和ret指令

call和ret都是用来修改ip或cs:ip，可以用来实现子程序的设计；

 

1.ret和retf

ret    ->修改ip的内容，从而实现近转移；

retf    ->同时修改cs和ip，从而实现远转移；

 

执行ret时：相当于 pop ip

    1】(ip)=((ss)*16+(sp))；也就是将栈顶的值赋值给ip；

    2】(sp)=(sp)+2；也就是栈顶指向栈的下一个字；

执行retf时：相当于pop ip，pop cs

    1】(ip)=((ss)*16+(sp))

    2】(sp)=(sp)+2

    3】(cs)=((ss)*16+(sp))

    4】(sp)=(sp)+2

 

例如：下面的程序执行retf后，cs:ip指向代码第一条指令,也就是程序返回的代码 mov ax,4cooh

stack segment

    db 16 dup (0)

stack ends

code segment

    mov ax,4c00h

    int 21h

    start：mov ax,stack

            mov ss,ax

            mov sp,16

            mov ax,0

            push cs

            push ax

            retf

code ends

 

2.call指令

call    ->将当前的ip或cs:ip压入栈中，然后转移；

call指令和jmp指令相似，但不能实现短转移，有多种格式；

 

1）依据位移进行转移的call指令

格式：

    call 标号

例如：

call start

执行的操作：将当前的ip压入栈后转移到标号处执行指令；

    1】(sp)=(sp)-2，((ss)*16+(sp))=(ip)

    2】(ip)=(ip)+16位位移

        2.1】16位位移=标号处的地址-call指令后的第一个字节的地址

        2.2】16位的位移范围是-32768~32767

        2.3】16位位移在编译时由编译器计算出来

相当于：

    push ip

    jmp near ptr 标号

 

2）转移目标地址在指令中的call指令

格式：

    call far ptr 标号

例如：

call far ptr s

执行的操作：段间转移，将当前cs和ip分别入栈后转移到标号处；

    1】(sp)=(sp)-2

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

        (sp)=(sp)-2

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

    2】(cs)=标号所在段的段地址

        (ip)=标号所在段的偏移地址

相当于：

    push cs

    push ip

    jmp far ptr 标号

 

3）转移目标地址在寄存器中的call指令

格式：

    call 16位寄存器

例如：

call ax

执行的操作：当前ip入栈，ip的值设为寄存器中的值

    (sp)=(sp)-2

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

    (ip)=16位寄存器的值

相当于：

    push ip

    jmp 16位寄存器

 

4）转移地址在内存中的call指令

有两种格式：

    1】call word ptr 内存单元地址

call word ptr ds:[0]

          相当于：

            push ip

            jmp word ptr 内存单元地址

  2】call dword ptr 内存单元地址

call dword ptr ds:[0]

        相当于：

            push cs

            push ip

            jmp dword ptr 内存单元地址

 

3.call和ret配合使用

利用call和ret配合，可以实现具有一定功能的程序的，也叫子程序；

用call指令执行子程序中的代码，将后面的指令地址入栈；

执行完子程序后用ret指令用栈中的数据设置ip，依次保证程序继续向下执行；

 

框架：

例如：下面是计算2的3次方的代码

assume cs:code,ss:stack

stack segment

    db 8 dup (0)

    dp 8 dup (0)

stack ends

code segment

    start:mov ax,stack

        mov ss,ax

        mov sp,16

        mov ax,1000

        call s

        mov ax,4c00h

        int 21h

    s:  add ax,ax

        ret

code ends

end start

 

4.mul指令

mul是乘法指令；

 

格式：

    1】mul 寄存器   

mul ax

    2】mul 内存单元

mul byte ptr ds:[0]

mul word ptr ds:[0]

 

执行过程：

    两个数相乘，要么都是8位，要么都是16位；

    如果都是8位，一个默认放在al中，另一个放在8位寄存器或内存字节单元中；

    如果都是16位，一个默认在ax中，另一个放在16位寄存器或内存字单元中；

执行结果：

    如果是两个8位的数相乘，结果默认放在ax中；

    如果两个16位的数相乘，结果高位在dx中，低位在ax中；

 

例如：计算100*10000，因为10000大于255超出了8位的限制，只能做16位乘法

mov ax,100

mov bx,10000

mul bx

 

5.参数和结果的传递

子程序一般根据提供的参数处理后将结果返回给调用者；

因此需要考虑参数和结果的储存在哪的问题；

 

1）用寄存器来储存参数和结果

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

子程序从参数寄存器中获取参数，将处理结果存入结果寄存器；

 

例如：计算3次方的子程序

        ;...省略

        mov bx,5

        call cube        ;调用子程序，用bx作参数寄存器

        mov ds:[0],ax    ;从结果寄存器ax,dx中获取结果的低位和高位

        mov ds:[2],dx

cube:   mov ax,bx    ;计算3次方的子程序

            mul bx

            mul bx

 

 

2）批量数据的传递

如果参数或结果较少，可以用寄存器来存放；

但是如果有参数过多，就不太合适了，因为寄存器的数量有限；

可以考虑将批量数据存放在内存中，寄存器中存放数据所在内存的首地址、cx中存放数据长度、用loop指令循环调取；

 

例如：将字符串转为大写

assume cs:code,ds:data

data segment

    db 'helloworld'

data ends

 

code segment

    start:  mov ax,data

            mov ds,ax

            mov si,0     ;ds:[si]存放数据首地址

            mov cx,10    ;cx存放数据长度长度

            call method

            mov ax,4c00h

            int 21h

    method: and byte ptr [si],11011111b    ;转为大写

            inc si

            loop method

            ret            

code ends

end start

 

3）用栈传递参数

这种技术常用在高级语言编译器中；

例如：计算(3-1)的3次方

        mov ax,1

        push ax    ;将参数压入栈中

        mov ax,3

        push ax    ;注意入栈顺序

        call difcube

        mov ax,4c00h

        int 21h

 

difcube: push bp        ;将bp原来的值入栈，处理完后再pop回去

        mov bp,sp

        mov ax,[bp+4]    ;将栈中的值3送入ax

        sub ax,[bp+6]    ;3-1=2,将2送入ax

        mov bp,ax

        mul bp

        mul bp

        pop bp

        ret 4        ;程序返回，并且将栈顶回复到初始状态，因为两个参数还占4个字节的空间，所以sp要多移动4个字节

栈的变化：

 

6.寄存器的冲突

如果子程序中需要用到调用者使用的寄存器时，可能产生冲突；

例如：调用者为了做循环需要用到寄存器cx，子程序中也需要做循环也要用到cx；

    而子程序循环完成后cx的值已经被修改了，调用者因此受到了影响；

解决思路：

    1】避免在子程序中使用调用者用过的寄存器；

    2】避免在调用者中使用子程序用过的寄存器；

问题：

    因为调用的不确定性，上面两种方案行不通，我们希望编写子程序和调用者时不要被寄存器的冲突限制；

可行方案：

    可以考虑在编写子程序时，将子程序需要使用的寄存器值先入栈；

    当子程序执行完后，在出栈，将寄存器的值还原；

例如：

method:push cx    ;用到的寄存器入栈

    push si

    ;...业务代码，需要用到寄存器cx和si

ok:    pop si    ；业务代码完成后，寄存器出栈还原，主义出栈顺序

        pop cx

        ret