第十章 CALL和RET指令

Dear 丶 2022-02-16 13:56 317阅读 0赞

本博文系列参考自<<汇编语言>>第三版，作者:王爽

call与ret都是转移指令，它们可以改变IP值，或者同时改变CS与IP的值，往往在程序中使用它们进行子程序模块的设计。

##  1 指令介绍  ##

在介绍call和ret指令之前，我们先总结以下前两章的学习思路。这个思路同样可以扩展到第10章。

1.  第八章 数据处理的两个问题：数据的位置和长度。  
    mov ax,bx | mov ax,0 | mov al,0  
    mov byte ptr ds:\[si\],0 | mov word ptr ds:\[si\] ,0 | mov dword ptr ds:\[si\] ,0
2.  第九章 转移指令的原理 ：转移的位置和需要处理的长度（修改ip或者cs和ip）  
    jmp word ptr ds:\[si\] | jmp dword ptr ds:\[si\]  
    jmp near ptr 标号 | jmp far ptr 标号  
    （我基本，不会去计算长度是不是够了。编译器会进行判断。跨越长度不够的时候，编译器会保存）（loop只能进行短转移，但是课设1，我代码写的不好，长度过长，只好用jmp来代替loop）
3.  CALL和RET指令  
    3.1 ret 指令用栈中的数据，修改ip的内容，从而实现近转移。  
      push IP  
      jmp near 标号  
    3.2 retf指令用于修改CS和IP的值，从而实现远转移。  
      push CS  
      push IP  
      jmp far ptr 标号  
    3.3 call 指令  
     ALL指令的执行步骤(call不能实现短转移):  
     （1）将当前的IP或CS与IP压入栈中  
     （2）;转移

call指令和ret指令搭配，便可以实现子程序机制（调用&&返回）

##  2 指令的练习  ##

这里面有些技巧，只有当亲自动手尝试，才能感觉出它的妙用。  
下面会有我做的实验。绝对不希望在做出实验之前参考。当然，做完实验，瞅一瞅，对比一下，多读程序还是很好的。

### 2.1 显示字符串 ###

编写一个通用的子程序来实现这个功能。我们提供灵活的调用接口，使得调用者可以决定显示的位置（行、列）、内容和颜色。  
详细的内容，见书上。

;----------------------------------------------------------
    ;实验10.1
    ;问题
    ;编写一个通用子程序
    ;提供良好的调用接口
    ;使调用者可以决定显示的 位置（行，列），内容，颜色
    
    ;子程序描述
    ;名称：show_str
    ;功能：在指定的位置，用指定颜色，显示指定的内容，用0作为结束符
    ;参数：(dh)=行号(取值范围0~24) ,(dl)=列号(取值范围0~79)
    ;      (cl)=颜色 ， ds:si指向字符串的首地址 
    ;----------------------------------------------------------
                                                  
    ;---------------------------------------------------------
    ;范例：在屏幕8行3列，用绿色显示data段中的字符串
    
    assume cs:code
    
    data segment
        db 'welcome come to masm!',0
    data ends   
    
    code segment
    start:
        ;初始化参数
        mov dh,8   ;设置行位置
        mov dl,3     ;设置列位置
        mov cl,02h   ;设置显示方式：绿色
        mov ax,data  ;设置字符串的首地址
        mov ds,ax
        mov si,0
        
        ;调用显示函数，显示
        call show_str 
        
        ;中断返回
        mov ax,4c00h
        int 21
        
        
        ;显示函数子程序
    show_str: push dx ;把子程序用到的寄存器保存到栈中
        push cx ;有点保存断点的味道
        push ds ;当然栈是不会溢出的，没有那么多寄存器
        push si ;如果子程序中用到栈，注意使用完之后，sp要还原 
        push ax 
        push di
        push es 
        push bx
        
        
        mov al,dh
        mov bl,160
        mul bl 
        mov di,ax   ;160*dh
        mov al,dl
        mov bl,2    ;2*dl
        mul bl
        add di,ax  ;显示位置放在di中。先把位置算出来，释放dx,bx两个寄存器
         
        mov ax,0b800h
        mov es,ax
        mov ch,0
        mov ah,cl;颜色保存在高字节
    loop1:mov al,[si];内容保存在低字节
        mov cl,[si]
        jcxz ok  
        mov es:[di],ax  
        inc si
        add di,2
        loop loop1
        
    ok: pop bx
        pop es
        pop di  
        pop ax
        pop si  ;保存的寄存器内容返回
        pop ds  ;从哪里来，到哪里去
        pop cx
        pop dx  
        
        ret
        
    
    code ends
    end start

![在这里插入图片描述][20190423204744510.png]

### 2.2 解决除法溢出的问题 ###

解决商过大，溢出的问题。eg：1000000/10  
 X / N = i n t ( H / N ) ∗ 65536 + \[ r e m ( H / N ) ∗ 65536 + L \] / N X/N = int(H/N) \* 65536 + \[rem(H/N) \*65536+L\]/N X/N=int(H/N)∗65536\+\[rem(H/N)∗65536\+L\]/N  
（1）第一次除法的商，作为结果的高位。  
（2）第二次除法：被除数的高位来自第一次除法的余数。被除数的低位为L；除完之后，高位作为结果的低位，余数作为结果的余数。  
（先理解，这个公式的含义，代码还是很好写的）

;--------------------------------------- 
    ;dacao 2019/4/19 阴天
    
    ;实验10.2
    
    ;子程序描述 
    ;名称：divdw
    ;功能：进行不会产生溢出的除法运算，被除数是dword型，除数为word型，结果为word型。
    ;参数：(ax)=dword型数据的低16位
    ;      (dx)=dword型数据的高16位
    ;      (cx)=除数
    ;返回：(ax)=结果的低16位
    ;      (dx)=结果的高16位
    ;      (cx)=余数
    
    ;应用举例
    ;1000000/10(F4240H/0AH)
    ;mov ax,4240h
    ;mov dx,0000fh
    ;mov cx,0ah
    ;call divdw
    ;结果：(dx)=0001h,(ax)=86a0h,(cx)=0
    ;---------------------------------------
    
    assume cs:code
    code segment
    start:mov ax,0          ;4240H
        mov dx,0            ;0000fh
        mov cx,0ah 
        call divdw
        
        HLT
        mov ax,4c00h
        int 21h
          
        
        ;divdw子程序
    divdw:;push ax ;怕费脑子，把常用的寄存器都塞到栈里面保存
        push bx   ;（传入）传出的寄存器注释掉就好
        ;push cx
        ;push dx
        push si
        push di
        push ds
        push es   
        
        push dx;把高位，低位，除数压入栈中保存。  后面依次会用结果的高位，低位，余数覆盖
        push ax ;空出寄存器使用；注意使用完之后，要恢复原样。
        push cx 
        
        mov si,sp  ;si指向栈顶位置。直接用sp会报错，而且也不是特别安全
        
        mov ax,ss:[si+4]
        mov dx,0   ;第一次除法高位补零
        mov bx,ss:[si];除数为16位
        div bx
        mov ss:[si+4],ax ;结果的商覆盖被除数的高位    ;div指令：商放在ax中，余数放在dx中
         
        ;mov dx,dx 上面除法的余数，作为本次除法的高位
        mov ax,ss:[si+2]
        mov bx,ss:[si]
        div bx
        mov ss:[si+2],ax ;结果的商覆盖被除数的低位
        mov ss:[si],dx  ;结果的余数覆盖除数
        
        pop cx ;余数
        pop ax ;结果低位
        pop dx ;结果高位
        
        pop es
        pop ds
        pop di
        pop si
        ;pop dx
        ;pop cx
        pop bx
        ;pop ax
        
        ret
    
    code ends
    end start

### 2.3 数值显示 ###

编程，将data段中的数据以十进制的形式显示出来。、  
总体思路：每次除10，取余数，压栈。最后出栈，进入内存。

;----------------------------------- 
    ;大草 
    
    ;实验10.3
    ;数值显示
    ;子程序描述 
    ;名称：dtoc
    ;功能：将word型数据数据转变成十进制的字符串，字符串以0为结束符
    ;参数: (ax)=word 型数据
    ;   ds:si指向字符串的首地址
    ;返回 无
    
    ;应用举例
    ;将数据12666以10进制的形式在屏幕8行3列，用绿色显示出来。
    ;在显示的时候，调用函数show_str
    ;---------------------------------------   
    
    
    assume cs:code
    
    data segment 
        db 10 dup(0)
    data ends
    
    code segment
    start:mov ax,0
        mov bx,data
        mov ds,bx
        mov si,0
        call dtoc  ;将12666转换成字符串，放在数据段
        
        mov dh,8
        mov dl,3
        mov cl,2
        call show_str  ;显示数据段内容 
        
        mov ax,4c00h  ;中断结束
        int 21h
        
        
        ;子程序：将10进制数(不超过65536)，转换成字符串，存储在数据段   
    dtoc:push ax
        push bx
        push cx
        push dx
        push si
        push di
        push ds
        push es  
        
        mov di,0  ;初始化di
        mov bx,10 ;10进制
    loop1:mov dx,0  ;为防止溢出，被除数扩展到32位，高位补零 
        push dx  ;将余数压入栈中  商放在ax中不动
        inc di   ;记录数据长度
        mov cx,ax
        jcxz ok1
        div bx
        loop loop1
        
    ok1: mov cx,di
    loop2:pop ax
        add ax,30h  ;转换成字符
        mov ds:[si],al  ;将字强制转换成字节 ,放入数据段 
        inc si
        loop loop2
        
        
        pop es
        pop ds
        pop di
        pop si
        pop dx
        pop cx
        pop bx
        pop ax 
        
        ret
        
        
        
      
        ;显示函数子程序
    show_str: push dx ;把子程序用到的寄存器保存到栈中
        push cx ;有点保存断点的味道
        push ds ;当然栈是不会溢出的，没有那么多寄存器
        push si ;如果子程序中用到栈，注意使用完之后，sp要还原 
        push ax 
        push di
        push es 
        push bx
        
        
        mov al,dh
        mov bl,160
        mul bl 
        mov di,ax   ;160*dh
        mov al,dl
        mov bl,2    ;2*dl
        mul bl
        add di,ax  ;显示位置放在di中。先把位置算出来，释放dx,bx两个寄存器
         
        mov ax,0b800h
        mov es,ax
        mov ch,0
        mov ah,cl;颜色保存在高字节
    loop3:mov al,[si];内容保存在低字节
        mov cl,[si]
        jcxz ok2  
        mov es:[di],ax  
        inc si
        add di,2
        loop loop3
        
    ok2: pop bx
        pop es
        pop di  
        pop ax
        pop si  ;保存的寄存器内容返回
        pop ds  ;从哪里来，到哪里去
        pop cx
        pop dx  
        
        ret
    
    
    code ends
    end start

## 3 总结： ##

call和ret指令，仅仅是调用和返回。它不像C语言，函数具有封装性。这里面的使用，尤其要注意寄存器的保护。  
（1）如果一个寄存器在子程序中被使用了，要进行压栈保护。  
（2）如果要作为参数的传入和传出，则不需要处理。  
（3）push（压栈）和pop（出栈），一定要成对的出现，这样才能是子程序正确的返回。

## 4 课程设计一  ##

将实验7中的power idea 公司的数据按一定格式在屏幕上显示。  
（下面的程序结构和处理不是很好。但是…）

data segment
        db '1975','1976','1977','1978','1979'
        db '1980','1981','1982','1983','1984'
        db '1985','1986','1987','1988','1989'
        db '1990','1991','1992','1993','1994'
        db '1995'
        ;以上是表示21年的21个字符串    年份
        dd 16,22,382,1356,2390
        dd 8000,16000,24486,50065,97479
        dd 140417,197514,345980,590827,803530
        dd 1183000,1843000,2759000,3753000,4649000
        dd 5937000
        ;以上是表示21年公司总收入的21个dd型数据    收入
        dw 3,7,9,13,28
        dw 38,130,220,476,778
        dw 1001,1442,2258,2793,4037
        dw 5635,8226,11542,14430,15257
        dw 17800
        ;以上是表示21年公司雇员人数的21个word型数据      雇员数目
    data ends
    
    table segment
        db 21 dup('year sum ne ?? ') ;总长度16        ;位置：071e
    table ends
    
    tmpscreem segment
    	db 'year sum ne ?? '       ;位置：0732                        
    tmpscreem ends      
        
    
    
    assume cs:code
    code segment
    start: 
        mov ax,table
        mov ds,ax
        mov si,0
        mov ax,tmpscreem
        mov es,ax
        mov di,0
        
        call formdata   ;形成数据
        
        ;预处理数据    
        ;凡是涉及到dd型的数据提取，高字节用dx，低字节用ax
        
        mov cx,21
    loopBigSolve:push cx 
        push cx ;这里保存两份cx
         
        mov ax,cx    ; si = (21-cx)*16 读取数据的每一行起始位置
        mov bx,21
        sub bx,ax
        mov ax,16
        mul bx
        mov si,ax
        mov di,0    ;下（每）一次重新开始赋值这一行
        
        ;处理年份
        mov ax,ds:[si]
        mov dx,ds:[si+2]
        mov es:[di],ax
        mov es:[di+2],dx
        mov byte ptr es:[di+4],0 ;预处理，放置一个零
        add si,5
        add di,5  
        
        ;处理总收入
        mov ax,ds:[si]
        mov dx,ds:[si+2]
        mov cx,0ah
        mov bx,0;用来记录压栈次数（字符串长苏）
        
    loopdiv:call divdw
        add cx,30h ;余数转换成ASIIC
        push cx
        inc bx
        mov cx,dx  ;判断 商=ax+bx是否为零 
        add cx,ax
        jcxz finsdiv 
        mov cx,0ah ;重新给除数赋值
        jmp loopdiv 
        
         
    finsdiv:mov cx,bx
    looppop:pop bx ;强制转换成字节型
        mov es:[di],bl 
        inc di 
        loop looppop
        
        mov byte ptr es:[di],0
        add si,5
        add di,1
        
        ;处理人数  ;处理人均收入
        mov cx,2
    loopPerAndIcom: 
        ;push cx
        mov ax,ds:[si]
        push ds  
        push si 
        mov bx,es
        mov ds,bx
        mov si,di
        call dtoc  ;小溢出处理的除法，并将转换之后的数据段，放入ds:si内存.将si注释掉，我需要si的传出
        mov di,si
        mov byte ptr ds:[di],0
        inc di
        pop si
        pop ds
        add si,3 
        ;pop cx
        loop  loopPerAndIcom 
        
       
        
        ;显示一行。a little difficult
        pop cx  ;把多保留的一份cx弹出（这是我目前可以想到最好的方法）
        ;push dx
        push ds
        push si
        ;push ax 
        
        mov dh,cl
        ;sub 21,dh  ;dh = 21 -dh
        mov al,21
        sub al,dh
        mov dh,al
        mov dl,0
        ;mov cl,02h
        mov ax,es
        mov ds,ax    ;开始ds:si 指向 es:0
        mov si,0 
         
        mov cx,4    ;每一行，有4条信息
    loophang:
        push cx
        mov cl,02h 
        call show_str       ;函数要把si传出，把它注销掉。
        inc si    ;跳过零  
        ;mov ax,si
        ;mov dl,al  ;显示屏的位置也要跟着变动
        add dl,15
        pop cx 
        loop loophang
        
        ;pop ax
        pop si       
        pop ds
        ;pop dx
        
        
        pop cx
        loop loopBigSolve
         
           
        HLT   
        mov ax,4c00h
        int 21h    
        
        
    
    
    ;-------------------------------------------
    ;实验七：提供数据
    formdata:push ax
    	push bx	
    	push cx
    	push dx
    	push si
    	push di
    	push ds
    	push es
    
        ;初始段  
        mov ax,data
        mov ds,ax
        mov ax,table
        mov es,ax 
             
        ;先把年份放入
        mov bx,0 
        mov bp,0         
        mov cx,21
    s:  ;mov dd ptr 一个double的长度，一个寄存器存不下
        ;像除法一样，小端放在ax中，大端放在dx中
        mov ax,ds:[bx]
        mov dx,ds:[bx+2]
        mov es:[bp],ax
        mov es:[bp+2],dx
        mov byte ptr es:[bp+4],' '  ;放一个空格 ;
        add bx,4 
        add bp,10h
        loop s 
        
        
        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        ;把收入放进去 
        mov bp,0
        mov cx,21
    s1:    
        mov ax,ds:[bx]   ;由于连续，bx指针继续累加
        mov dx,ds:[bx+2]
        mov es:[bp+5],ax
        mov es:[bp+7],dx
        mov byte ptr es:[bp+9],' '  ;放一个空格 
        add bx,4 
        add bp,10h
        loop s1
        
        
        ;;;;;;;;;;;;;;;;;;;;;;;;;;
        ;把雇员放入
        mov bp,0
        mov cx,21
    s2:
        mov ax,ds:[bx]   ;由于连续，bx指针继续累加
        mov es:[bp+0ah],ax
        mov byte ptr es:[bp+0ch],' '  ;放一个空格 
        add bx,2 
        add bp,10h
        loop s2
        
        
        ;;;;;;;;;;;;;;;;;;;;;;;;
        ;求人均收入  
        ;不要傻不拉几的去数据段调取
        mov bp,0
        mov cx,21 
    s3:    
        mov ax,es:[bp+5]
        mov dx,es:[bp+7]
        div word ptr es:[bp+0ah] 
        mov es:[bp+0dh],ax  
        mov byte ptr es:[bp+0fh],' ' ;放一个空格
        add bp,10h  
        loop s3
    
        pop es
        pop ds
        pop di
        pop si
        pop dx
        pop cx
        pop bx
        pop ax
    
        ret	
    ;-----------------------------------------------------  
    
    
    ;-----------------------------------------------------   
        ;显示函数子程序
    show_str: push dx ;把子程序用到的寄存器保存到栈中
        push cx ;有点保存断点的味道
        push ds ;当然栈是不会溢出的，没有那么多寄存器
        ;push si ;如果子程序中用到栈，注意使用完之后，sp要还原 
        push ax 
        push di
        push es 
        push bx
        
        
        mov al,dh
        mov bl,160
        mul bl 
        mov di,ax   ;160*dh
        mov al,dl
        mov bl,2    ;2*dl
        mul bl
        add di,ax  ;显示位置放在di中。先把位置算出来，释放dx,bx两个寄存器
         
        mov ax,0b800h
        mov es,ax
        mov ch,0
        mov ah,cl;颜色保存在高字节
    loop1:mov al,[si];内容保存在低字节
        mov cl,[si]
        jcxz ok  
        mov es:[di],ax  
        inc si
        add di,2
        loop loop1
        
    ok: pop bx
        pop es
        pop di  
        pop ax
        ;pop si  ;保存的寄存器内容返回
        pop ds  ;从哪里来，到哪里去
        pop cx
        pop dx  
        
        ret
    ;---------------------------------------------------------------  
    
    
    ;--------------------------------------------------------------
    ;大数除法
        ;divdw子程序
    divdw:;push ax ;怕费脑子，把常用的寄存器都塞到栈里面保存
        push bx   ;（传入）传出的寄存器注释掉就好
        ;push cx
        ;push dx
        push si
        push di
        push ds
        push es   
        
        push dx;把高位，低位，除数压入栈中保存。  后面依次会用结果的高位，低位，余数覆盖
        push ax ;空出寄存器使用；注意使用完之后，要恢复原样。
        push cx 
        
        mov si,sp  ;si指向栈顶位置。直接用sp会报错，而且也不是特别安全
        
        mov ax,ss:[si+4]
        mov dx,0   ;第一次除法高位补零
        mov bx,ss:[si];除数为16位
        div bx
        mov ss:[si+4],ax ;结果的商覆盖被除数的高位    ;div指令：商放在ax中，余数放在dx中
         
        ;mov dx,dx 上面除法的余数，作为本次除法的高位
        mov ax,ss:[si+2]
        mov bx,ss:[si]
        div bx
        mov ss:[si+2],ax ;结果的商覆盖被除数的低位
        mov ss:[si],dx  ;结果的余数覆盖除数
        
        pop cx ;余数
        pop ax ;结果低位
        pop dx ;结果高位
        
        pop es
        pop ds
        pop di
        pop si
        ;pop dx
        ;pop cx
        pop bx
        ;pop ax
        
        ret
    ;------------------------------------------------------------  
      
      
    ;-----------------------------------------------------------------
        ;子程序：将10进制数(不超过65536)，转换成字符串，存储在数据段   
    dtoc:push ax
        push bx
        push cx
        push dx
        ;push si
        push di
        push ds
        push es  
        
        
        mov di,0
        mov bx,10 ;10进制
    loopdtoc1:mov dx,0  ;为防止溢出，被除数扩展到32位，高位补零   
        div bx
        push dx  ;将余数压入栈中  商放在ax中不动
        inc di   ;记录数据长度
        mov cx,ax
        jcxz okdtoc1
        jmp loopdtoc1
        
    okdtoc1: mov cx,di
    loopdtoc2:pop ax
        add ax,30h  ;转换成字符
        mov ds:[si],al  ;将字强制转换成字节 ,放入数据段 
        inc si
        loop loopdtoc2
        
        
        pop es
        pop ds
        pop di
        ;pop si
        pop dx
        pop cx
        pop bx
        pop ax 
        
        ret
    ;----------------------------------------------------------
    code ends
    end start

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4ODE2OTI0_size_16_color_FFFFFF_t_70]

--------------------

这次课设之后，便离开了三个一工程。  
。。。。。。。。。。。。。。。。。  
debug && emu8086  
。。。。。。。。。。。。。。。。。

[20190423204744510.png]: /images/20220216/b1ff6c24eaa9400199aadc5c50193836.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4ODE2OTI0_size_16_color_FFFFFF_t_70]: /images/20220216/536dc921b81945d38e5c17b46175e4f0.png