函数的调用
一、函数调用
（一）call和ret指令
call指令: 相当于用来调用封装的方法
ret指令: 相当于retun指令
例子：
以下代码是输出一个Hello
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建了100个0当做栈段
stack ends
;数据段
data segment
db 100 dup(0)
string db 'Hello!$' //定义一个字符串，起个名字叫 string
data ends
;代码段
code segment
start:
;手动赋值 ds,ss
mov ax, stack
mov ss, ax
mov ax, data
mov ds, ax
;业务逻辑
;ds:dx 在内存中找到字符串
mov dx, offset string
;输出字符串
mov ax, 9h
int 21h
;代码退出
mov ax, 4c00h
int 21h
code ends
end start
现在我需要输出3个Hello（需要把输出封装一下，然后调用）
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建了100个0当做栈段
stack ends
;数据段
data segment
db 100 dup(0)
string db 'Hello!$' //定义一个字符串，起个名字叫 string
data ends
;代码段
code segment
start:
;手动赋值 ds,ss
mov ax, stack
mov ss, ax
mov ax, data
mov ds, ax
;业务逻辑
call print //调用输出语句封装的方法
;代码退出
mov ax, 4c00h
int 21h
;把字符串封装成以下形式
print:
mov dx, offset string
mov ax, 9h
int 21h
ret //记着一定要ret出去
code ends
end start
（二）call和ret原理解析
call就是将下一条指令的偏移地址入栈，然后再跳转到对应的代码处
ret：将栈顶的值出栈，赋值给IP，IP就是偏移地址CS:IP
所以ret以后，cpu还能找到继续执行的指令
注意：既然是ret是让栈顶的值出栈赋值给IP，那就不能在封装的方法中，做入栈操作(push ax),否则将会修改栈顶的值
（三）函数的返回值
思路：
1.最常用：
首先要计算出23值，然后方到寄存器ax中，在ret返回
然后回到业务逻辑这，可以直接接收用bx寄存器(mov bx, ax)
2.
在封装的方法中: mov [0], ax 把值放到ds:[0] 内存的数据段中
在业务逻辑这接收: mov bx, [0] 把值从ds:[0]中取出来放到 bx
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建了100个0当做栈段
stack ends
;数据段
data segment
db 100 dup(0)
string db 'Hello!$' //定义一个字符串，起个名字叫 string
data ends
;代码段
code segment
start:
;手动赋值 ds,ss
mov ax, stack
mov ss, ax
mov ax, data
mov ds, ax
;业务逻辑
call match
mov bx, ax //直接取ax的值，放到bx中就行 方式一
call match1 //方法二
mov bx, [0] //其实是将内存地址ds:[0]中值取出放到 bx中了
;代码退出
mov ax, 4c00h
int 21h
;我现在想着返回一个2的3次方
match:
;计算出2的3次方数值,然后方到ax寄存器中
mov ax, 2
add ax,ax
add ax,ax
ret //记着一定要ret出去
;对应的方法二
match2:
;计算出2的3次方数值,然后方到ax寄存器中
mov ax, 2
add ax,ax
add ax,ax
mov [0],ax //其实是将ax的值，放到内存地址为ds:[0]的内存中了
ret //记着一定要ret出去
code ends
end start
（四）函数传参
例如:我想着把10和20相加
方法1：参考返回值，在代码段把10放到cx寄存器(mov cx, 10)，把20放到dx寄存器(mov dx, 20)，在封装方法中把cx和dx相加(mov ax,cx ; add ax,dx)
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建了100个0当做栈段
stack ends
;数据段
data segment
db 100 dup(0)
string db 'Hello!$' //定义一个字符串，起个名字叫 string
data ends
;代码段
code segment
start:
;手动赋值 ds,ss
mov ax, stack
mov ss, ax
mov ax, data
mov ds, ax
;业务逻辑
mov cx,10
mov dx,20
call sum
mov bx, ax //直接取ax的值，放到bx中就行
;代码退出
mov ax, 4c00h
int 21h
;返回值一般放到ax寄存器中
;传参2个(分别放到cx, dx寄存器中)
sum:
mov ax, cx
add ax, dx
ret
code ends
end start
方法2：
对于多个参数，一般是通过栈来传参数，在代码段把参数入栈，在封装方法中，取出。
这个取出需要注意，并不是pop取出，不能移动SP指针，而是通过SP+2这样来取值
注意: 由于系统会把调用封装方法的下一行指令的偏移地址放到栈顶，ret的时候在从栈顶取出
所以在封装的函数中，不能改变SP指针的位置
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建100个0当做栈段等着别人来用
stack ends
;数据段
data segment
db 100 dup(0)
data ends
;代码段
code segment
start:
;手动赋值ss
mov ax, stack
mov ss, ax
;手动赋值ds
mov ax, data
mov ds, ax
//业务逻辑处理
;入栈2个参数
push 1122h
push 3344h
call sum
add sp,4 ;涉及到栈平衡
mov bx, ax
mov ax, 4c00h //退出
int 21h
code ends
;返回值放到ax中
;传参
sum:
;入栈以后如图1，但是可不能pop取值，如果pop ax,指针sp就会往下移，ret就会出错
;所以
mov bp, sp ;把sp指针给bp，bp是辅助sp指针
mov ax, ss:[bp+2] ;通过ss:[0] ，栈：偏移地址取出来，类似ds:[0]
add ax, ss:[bp+4]
ret
end start
二、栈平衡
栈平衡: 简单总结 栈使用之前和使用之后，sp指针要保持一样
（一）栈平衡原理分析
原理分析:
如上图1所示，这是当你调用1 个函数(call sum)以后栈地址的分布。如果此时再调用第二个函数的时候，sp就会从40000H开始，继续往上移动，而不是从栈顶了,如图2
当在调用第三次的时候，就会又累加，因此造成栈空间浪费，调用多了造成栈溢出。
因此需要解决这种情况。如何解决？？？？
只需要将sp+4就可以解决，例如图1，第一个函数结束以后，就add sp, 4(指针就回到栈顶了)
这样就可以将原来的数据覆盖了，从而实现了内存销毁，保持栈平衡!
1.外平衡
把add sp,4 放到函数调用结束，就是外平衡!!!
push 1122h
push 3344h
call sum
add sp,4 ;涉及到栈平衡
2.内平衡
在函数返回值ret中，ret 4，这是内平衡!
sum:
mov bp, sp ;把sp指针给bp，bp是辅助sp指针
mov ax, ss:[bp+2] ;通过ss:[0] ，栈：偏移地址取出来，类似ds:[0]
add ax, ss:[bp+4]
ret 4
注意 ret 4 还有add sp,4 这个4可不是乱写的，是根据你入栈的空间来的，你占用多少，你就加回去多少
（二）函数递归
函数递归也会造成栈溢出，函数的递归是发生在函数内部，函数并没有结束，无法将sp指针移动
如下错误代码，会造成递归
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建100个0当做栈段等着别人来用
stack ends
;数据段
data segment
db 100 dup(0)
data ends
;代码段
code segment
start:
;手动赋值ss
mov ax, stack
mov ss, ax
;手动赋值ds
mov ax, data
mov ds, ax
//业务逻辑处理
;入栈2个参数
push 1122h
push 3344h
call sum
add sp,4 ;涉及到栈平衡
mov bx, ax
mov ax, 4c00h //退出
int 21h
code ends
;返回值放到ax中
;传参
sum:
;入栈以后如图1，但是可不能pop取值，如果pop ax,指针sp就会往下移，ret就会出错
;所以
mov bp, sp ;把sp指针给bp，bp是辅助sp指针
mov ax, ss:[bp+2] ;通过ss:[0] ，栈：偏移地址取出来，类似ds:[0]
add ax, ss:[bp+4]
call sum ;在次调用，这样造成了循环
ret
end start
（三）函数中调用函数与函数结束调用函数比较
问题:
在封装的函数1中，调用函数2，在函数2中调用涵数3，…这样效率高 ？？？
还是在函数1调用结束以后，调用函数2，函数2结束调用函数3，…这样效率高？
分析：
在函数1中调用函数2，此时函数1并没有结束，就调用了函数2，因此，栈空间开辟了函数1和2的。
同理，在函数2还未结束的时候就调用函数3，此时栈空间继续开辟，以此类推，调用的函数越多，栈空间占用的越多，直到最后一个函数调用结束，才能依次销毁，最终返回栈顶！
而，在函数1调用结束以后，在调用函数2，栈空间就不会依次累加，2结束以后调用3，也不会累加！！！
结论：
函数调用结束以后在调用函数 > 函数内调用函数
（四）函数的约定
__cdecl ：参数从右至左入栈,是外平衡
sum (a, b)
push b
push a
add sp, 4
__stdcall: 参数从右至左入栈,是内平衡
sum (a, b)
push b
push a
ret 4
__fastcall: 优先使用寄存器传参，寄存器不够用，在用push从右至左，并且是内平衡
sum (a, b, c, d, e, f)
mov bx ,a
mov cx, b
mov dx, c
push f
push e
push d
ret 6
Xcode使用的就是__fastcall
总结:函数调用的本质
1.参数: push参数值
2.返回值: 一般都放在ax寄存器中
1.栈平衡: 保持栈平衡
三、函数的局部变量
例如：一段函数如下，分析其中的汇编流程
int sum (int a, int b)
{
int c = 3;
int d = 4;
int e = c+d
return a + b + e;
}
int main (int argc, char*argv[])
{
sum (10, 2)
return 0;
}
转换汇编流程：
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建100个0当做栈段等着别人来用
stack ends
;数据段
data segment
db 100 dup(0)
data ends
;代码段
code segment
start:
;手动赋值ss
mov ax, stack
mov ss, ax
;手动赋值ds
mov ax, data
mov ds, ax
//业务逻辑处理
;入栈2个参数
push 1122h
push 3344h
call sum
add sp,4 ;涉及到栈平衡
mov bx, ax
mov ax, 4c00h //退出
int 21h
code ends
;返回值放到ax中
;传参
sum:
mov bp,sp ;先把sp的值赋值给bp
sub sp,10 ;在给sp-10，向上拉伸10个字节空间，用来放局部变量
;定义2个局部变量
mov word prt ss:[bp-2],3
mov word ptr ss:[bp-4],4
mov ax, ss:[bp-2] ;把3取出来给了ax
add ax, ss:[bp-4] ;ax在和4相加给了ax
mov word ptr ss:[bp-6],ax ;在把值继续存入bp-6中
mov ax, ss:[bp+2] ;取出参数3344
add ax, ss:[bp+4] ;将3344和1122相加
add ax, ss:[bp-6] ;取出局部变量的结果7，在相加
;恢复sp
mov sp, bp
ret
end start
（一）局部变量流程分析
（二）bp指针无法恢复问题
但是，如果在函数中再次调用另一段函数，会出现什么问题？
（三）保护bp指针
因此我们需要把bp的值进行保护起来!
保护了bp寄存器需要注意一下，取参数的时候就不是ss:[bp+2]了，就是ss:[bp+4] 和 ss:[bp+6] 了
‘bp-’ 往上走肯定是局部变量!
‘bp+’ 往下走肯定是参数！
（四）保护其它寄存器
在函数当中，有的时候可能还会用到其它的通用寄存器，例如:si di bx寄存器，因此需要把他们原有的值保护起来
保护方式同样和bp一样。
assume cs:code, ds:data, ss:stack
;栈段
stack segment
db 100 dup(0) //创建100个0当做栈段等着别人来用
stack ends
;数据段
data segment
db 100 dup(0)
data ends
;代码段
code segment
start:
;手动赋值ss
mov ax, stack
mov ss, ax
;手动赋值ds
mov ax, data
mov ds, ax
//业务逻辑处理
;入栈2个参数
push 1122h
push 3344h
call sum
add sp,4 ;涉及到栈平衡
mov bx, ax
mov ax, 4c00h //退出
int 21h
code ends
;返回值放到ax中
;传参
sum:
push bp ;把原有bp的值保护起来
mov bp,sp ;在把sp的值赋值给bp
sub sp,10 ;在给sp-10，向上拉伸10个字节空间，用来放局部变量
;保护其它寄存器
push si
push di
push bx
;业务逻辑了----定义2个局部变量
mov word prt ss:[bp-2],3
mov word ptr ss:[bp-4],4
mov ax, ss:[bp-2] ;把3取出来给了ax
add ax, ss:[bp-4] ;ax在和4相加给了ax
mov word ptr ss:[bp-6],ax ;在把值继续存入bp-6中
mov ax, ss:[bp+4] ;取出参数3344
add ax, ss:[bp+6] ;将3344和1122相加
add ax, ss:[bp-6] ;取出局部变量的结果7，在相加
;恢复其它寄存器,注意恢复其它寄存器的顺序
pop bx
pop di
pop si
;恢复sp
mov sp, bp
;恢复bp
pop bp
ret
end start
用图片区域来表示栈空间分布情况:
（五）保护局部变量的空间
如果说你拉伸一段栈空间，(sub sp,10), 正好sp指针所指的位置是一个退出函数，那么程序就会出问题。
因为你永远不知道你拉伸的空间内之前存在什么指令。因此像这种不确定的，我们需要填充一堆数据来覆盖它。
在windows中填充的是 int 3 (CCCC)指令，也就是一堆断点指令。
;只从sum函数写起
sum:
push bp ;把原有bp的值保护起来
mov bp,sp ;在把sp的值赋值给bp
sub sp,10 ;在给sp-10，向上拉伸10个字节空间，用来放局部变量
;保护其它寄存器
push si
push di
push bx
;给局部变量填充int 3（cccc）指令
;stosw的作用，将ax的值拷贝到es:di中，同时di的值会+2
mov ax, 0cccch
;让es=ss,不能这样写mov es,ss ，必须通过一个中间变量
mov bx, ss
mov es, bx
;让di-10，和也就是整个局部变量的最上面（一开始不是拉伸了10个空间吗）
;因为每次复制di都会+2，
mov di,bp
sub di,10 ;
;cx觉得这个复制，执行几次，
mov cx,5 ;执行5次整个di+10了就，di就会回到bp的位置
rep stosw
;rep 的作用是重复执行某个命令(执行此时是由cx决定)
;业务逻辑了----定义2个局部变量
mov word prt ss:[bp-2],3
mov word ptr ss:[bp-4],4
mov ax, ss:[bp-2] ;把3取出来给了ax
add ax, ss:[bp-4] ;ax在和4相加给了ax
mov word ptr ss:[bp-6],ax ;在把值继续存入bp-6中
mov ax, ss:[bp+4] ;取出参数3344
add ax, ss:[bp+6] ;将3344和1122相加
add ax, ss:[bp-6] ;取出局部变量的结果7，在相加
;恢复其它寄存器,注意恢复其它寄存器的顺序
pop bx
pop di
pop si
;恢复sp
mov sp, bp
;恢复bp
pop bp
总结：函数调用本质(内存)
1. push参数
2. push函数返回地址
3. push bp (保留之前bp的值)
4. mov bp, sp （保留sp之前的值，方便以后恢复）
5. sub sp,空间大小 (拉伸空间给局部变量)
6. 保护可能用到其它的寄存器
7. 使用cc(int 3)填充局部变量空间
8. ----------------执行业务逻辑----------
9. 恢复其它寄存器之前的值
10. mov sp, bp (恢复sp)
11. pop bp (恢复bp)
12. ret (将函数的返回值出栈，执行下一条指令)
13. 恢复栈平衡 (add sp, 参数所占空间)
1826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
