call 和 ret 指令

body, table{font-family: 微软雅黑; font-size: 13.5pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px solid gray; padding: 4px; background-color: #DDD;} td{border: 1px solid gray; padding: 4px;} tr:nth-child(2n){background-color: #f8f8f8;}

call 和 ret 指令都是转移指令，他们都修改 IP , 或同时修改 CS 和 IP 。经常被用来实现子程序设计。

ret 指令用栈中的数据( 弹出一个数据 )，修改 IP 内容实现近转移

retf 指令用栈中数据( 弹出两个数据 )，修 改 CS 和 IP  的内容，实现远转移

; CPU 执行 ret 指令 1、(IP)=((SS)*16+(SP)) 2、(sp)=(sp)+2 相当于： pop IP

; CPU 执行 retf 指令 1、(IP)=((SS)*16+(SP)) 2、(SP)=(SP)+2 3、(CS)=((SS)*16+(SP)) 4、(SP)=(SP)+2 相当于： pop IP pop CS

;程序执行 ret 指令后， (IP)=0，CS:IP指向代码段第一条指令 assume cs:code 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 ax         mov bx , 0         ret         ; ip 被设置为0，指令转移到mov ax , 4c00 code ends end start assume cs:code code segment         mov ax , 4c00h         int 21h start:            mov ax , 0         push ax         mov bx , 0         ret       code ends end start        ; 一样的效果

;程序执行　reft 后，CS:IP　指向代码段第一条指令 assume cs:code 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         mov bx , 0         retf code ends end start assume cs:code code segment         mov ax , 4c00h         int 21h start:         mov ax , 0         push cs         push ax         mov bx , 0         retf code ends end start

---

call 指令

1、将当前的 IP 或 CS 和 IP 压入栈中；

2、转移

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

---

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

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

CPU 执行这种指令进行如下操作

1、(SP)=(SP)-2                   ((SS)*16+(SP))=(IP)

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

---

CPU 执行 “call  标号”时，相当于： push IP         jmp near ptr 标号

16位位移=“标号”处的地址-call 指令后的第一个字节的地址；范围 -32768~32767 ；16位位移是编译程序在编译的时候算出来的。

内存地址	机器码	汇编指令
076A：0 076A：3 076A：6 076A：7	B8 00 00 E8 01 00 40 58	mov ax , 0        call s   ; 执行时 call 0007        inc ax s:    pop ax

当 IP=3的时候指向 call s ；执行这条指令的时候 IP 偏移到 6，也就是下一条指令；call s == push IP   jmp near ptr 标号   此时栈中只有一个数据6，最后pop ax , 所以ax=6;

---

转移的目的地址在指令中的 call 指令

“call far ptr 标号” 实现的是段间转移。  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 标号

内存地址	机器码	汇编指令
076A：0 076A：3 076A：8 076A：9 076A：A	B8 00 00 9A 09 00 6A 07 40 58 5B	mov ax , 0          call far ptr s     ; call 076A:0009          inc ax s:      pop ax         pop bx

执行call far ptr s 的时候，cpu把下一条指令的位置 CS:IP =076A:0008 压入栈中保存，然后计算到标号 s 的偏移，转到标号处执行；此时出栈 ax=IP=0008，bx=CS=076A；

---

转移地址在寄存器中的 call 指令

指令格式：call 16 位寄存器 功能：(SP)=(SP)-2            ((SS)*16+(SP))=(IP)            (IP)=(16位寄存器)

相当于进行： push IP jmp 16位寄存器

内存地址	机器码	汇编指令
076A：0 076A：3 076A：5 076A：6 076A：8 076A :  B	B8 00 00 FF D0  40 8B EC 03 46 00 58	mov ax , 6          call ax                  inc ax s:      mov bp , sp          add ax , [bp]   ; ax=000B , 这里取的是ss:bp内存里的值，因为sp==bp，所以是堆栈顶数据5，5+6=B          pop ax             ; ax=0005

call ax ; 指令执行时当前 IP 偏移到 inc ax 即：IP=5；进栈；指令跳转到IP=6处执行，ax=6+栈顶元素=000B；出栈，ax =5

---

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

1、call word ptr　内存单元地址 相当于： push IP jmp word ptr 内存单元地址 mov sp , 10h mov ax , 0123h mov ds:[0] , ax call word ptr ds:[0]   ;执行这条指令，IP进栈，栈中存放000D 执行后：(IP)=0123H，(SP)=0EH

2、call dword ptr 内存单元地址 相当于： push CS push IP jmp dword ptr 内存单元地址 mov sp , 10h mov ax , 0123h mov ds:[0] , ax mov word ptr ds:[2] , 0 call dword ptr ds:[0] 执行后：(CS)=0 , (IP)=0123h，(sp)=0Ch

---

call 和 ret 的配合使用

assume cs:codesg

codesg segment

start:  mov ax , 1

        mov cx , 3

        call s        ; 栈中进栈(IP)，执行到这行指令的时候，IP指向mov bx , ax

        mov bx , ax     ;(bx)=8Z

        mov ax , 4c00h

        int 21h

s:        add ax , ax

        loop s

        ret           ;从栈中取一个数当做ip(刚好指向mov bx , ax)

codesg ends

end

---

mul 指令

  乘法指令

1、两个相乘的数：两个数相乘要么都是8位，要么都是16位。如果都是8位，一个默认放在 AL 中，另外一个放在 8 位寄存器或内存字节单元中；如果是16位，一个默认放在 AX 中，另外一个放在16位寄存器或内存字单元中。

2、结果：如果是8位乘法，结果默认放在 AX 中；如果是16位乘法，结果默认高位放在 DX ，低位在 AX 中存放。

指令格式： mul reg mul 内存单元

内存单元可以用不同的寻址方式给出，eg： mul byte ptr ds:[0] 含义：(ax)=(al)*((ds)*16+0) mul word ptr [bx+si+8] 含义：(ax)=(ax)((ds)*16+(bx)+(si)+8) ; 结果的低16位      (dx)=(ax)((ds)*16+(bx)+(si)+8) ; 结果的高16位

; 计算 100*10   ; 两个数都小于255，可以做8位乘法 mov al , 100 mov bl , 10 mul bl 结果：(ax)=1000(03E8H)

; 计算 100*10000 ; 10000大于255，必须做16位乘法 mov ax , 100 mov bx , 10000 mul bx 结果：(ax)=4240H , (dx)=000FH ; F4240H=1000000

---

模块化程序设计

  call 和 ret 指令支持汇编语言编程中的模块化设计。

---

参数和结果传递的问题

  子程序一般要根据提供的参数处理一定的事务，处理后将结果（返回值）提供给调用者。即：如何存储子程序需要的参数和产生的返回值。

assume cs:codesg , ds:datasg datasg segment         dw 1,2,3,4,5,6,7,8       ;(16个字节(00)）         dd 0,0,0,0,0,0,0,0       ;(32个字节(00) ) datasg ends codesg segment start:  mov ax , datasg         mov ds , ax         mov si , 0            ;偏移0指向第一个数1         mov di , 16         ;偏移16指向存放结果内存单元的首地址         mov cx , 8           ; 8个数，进行8次循环 s:      mov bx , [si]           call cube         mov [di] , ax             ;把结果的低16位放到低位两个字节（00 01）         mov [di].2 , dx          ;把结果的高16位放到高位的两个字节（02 03）         add si , 2                   ;偏移2个单位取到下一个数2 ; ds:si 指向下一个 word 单元         add di , 4                  ;偏移到下一个存储结果的内存地址（04 05 06 07） ; ds:di 指向下一个 dword 单元         loop s         mov ax , 4c00h         int 21h cube:        mov ax , bx   ; 对拿到的数进行立方运算         mul bx         mul bx         ret codesg ends end start

// 程序初始状态 // 程序运行两次，也就是得出1的三次方（00 00 00 01）和2的三次方（00 00 00 08） 1的三次方等于 0001，低16位存放1（01 00），高16位存放0； // 改写程序的初始第一个值为9 9的三次方等于 2D9 , 低16位存放2D9 （D9 02）, 高16位存放0（00 00） //第一个数是9运行一次循环的内存情况 //第一个数是100（64H），100^3=F4240H，低位4240H放在低16位（40 42），F放在高16位（0F 00）

 

---

批量数据的传递

  如果子程序要传递多个参数，寄存器有限？

  可以将批量数据放到内存中，然后将他们的内存空间首地址放在寄存器中，传递给需要的子程序。对于具有批量数据的返回结果，也可以用同样的方法。

  

assume cs:codesg , ds:datasg datasg segment         db 'conversation' datasg ends codesg segment start:        mov ax , datasg         mov ds , ax         mov si , 0           ; ds:si指向字符串（批量数据）所在空间的首地址         mov cx , 12        ; cx 存放字符串的长度         call capital         mov ax , 4c00h         int 21h capital:and byte ptr [si] , 11011111b         inc si         loop capital         ret codesg ends end start

除了用寄存器传递参数外，还有一种通用的方法就是用栈来传递参数。

---

寄存器冲突的问题

；改进上面的程序，字符串后面加一个0表示结束，就可以不用cx assume cs:codesg , ds:datasg datasg segment         db 'conversation' , 0 datasg ends codesg segment start:        mov ax , datasg         mov ds , ax         mov si , 0         call capital         mov ax , 4c00h         int 21h capital:mov cl , [si]      ; 当读到最后一个的时候为 0          mov ch , 0         jcxz ok                ; 读到最后 (cx)=0         and byte ptr [si] , 11011111b         inc si         jmp short capital ok:        ret                  ; 出栈，设置cs:ip指向 mov ax , 4c00h codesg ends end start

◆编写调用子程序的程序的时候不必关心子程序到底使用了哪些寄存器；

◆编写子程序的时候不必关心调用者使用了哪些寄存器

◆不会发生寄存器冲突

；编写程序将 data 段中的字符串全部转化为大写

assume cs:code , ds:data

data segment

        db 'word' , 0

        db 'unix' , 0

        db 'wind' , 0

        db 'good' , 0

data ends

code segment

start:            mov ax, data

                     mov ds , ax

                     mov bx , 0

                     mov cx , 4                                             ; 设置循环次数4

s:                   mov si , bx 

                     call capital                                            ;  调用子程序处理字符串

                     add bx , 5                                             ;  偏移量加 5 ，处理下一个字符串

                     loop s

                     mov ax , 4c00h

                     int 21h

capital:         push cx                                                 ; 执行子程序防止有冲突寄存器，先压栈保存主程序寄存器值

                     push si 

change:        mov cl , [si]

                      mov ch , 0

                      jcxz ok                                                   ; 判断(cx)是否等于0，如果等于0表示读完一个字符串

                      and byte ptr [si] , 11011111b

                      inc si

                      jmp short change

ok:                 pop si                                                    ; 结束了一次子程序的调用，恢复主程序的相应寄存器的值

                      pop cx

                      ret                                                         ; 返回call下一行指令，执行下一次循环

code ends

end start