函数call相关[ASM]

前言:
   __cdecl:C/C++函数默认调用约定,参数依次从右向左传递,并压入堆栈,最后由调用函数清空堆栈,这种方式适用于传递参数个数可变的被调用函数,只有被调用函数才知道它传递了多少个参数给被调用函数,比如printf();

__stdcall:参数由右向左传递,并压入堆栈,由被调用函数清空堆栈,当函数有可变参数个数时,函数调用约定自动转换成__cdecl调用约定;

__thiscall:C++非静态成员函数默认调用约定,不能使用个数可变参数,调用非静态成员函数时,this指针直接保存在ecx寄存器中,不入栈,其他方面同__stdcall;

__fastcall:凡是接口函数都必须指明其调用规范,除非接口函数是类的非静态成员函数;


1).简洁的编程模型抽象

 由于是简单而本质的抽象,因此我们不考虑分页机制、MMU(memory management unit)之类的。正是如此,它们本来对于我们就是透明的。

所以内存就被考虑为一个从编号(地址)0开始、以编号(地址)0xffff ffff结束的字节序列。每一个字节都被顺序地编号。编号就是字节的地址。
在32位FLAT模式汇编中,本来就是如此。

在程序加载入内存后,程序的指令和数据都按某种方式存放在内存里面。要访问和执行他们,只需要知道他们的地址就可以了。

最重要的东西登场,它就是eip,指令指针寄存器,或称程序计数器。eip中的值程序员无法修改(嗯,可是汇编程序员呢?汇编程序员也无法修改它的值吗?废话,汇编程序员也是程序员啊!),它的值就是下一条即将执行的指令的地址。就是说eip永远指向下一条指令。

然后就是esp,它指向栈的栈顶。当向栈压入数据或从栈弹出数据时,esp的值不断变化,但无论如何变化,它都指向栈顶。

最后就是ebp,它用来把栈中的某个地址作为基址(基本地址,这样理解就是了),它用来标识栈中的某个固定位置,因此可以通过它访问这个固定位置附近的数据。

80X86的栈是向下增长的。也就是说,当向栈压入4个字节的数据时,esp = esp - 4; 当从栈中弹出4个字节时,esp = esp + 4。

以上!多么幸福的事情啊,32位汇编只需要在意这3个寄存器就可以了!

栈图1
栈图1



这你妹,解释下上图代表什么意思...纯粹照顾完全的新手。
首先,那一排格子代表内存空间中的一小段,每个格子代表4个字节。右边的十六位数值代表方格的地址。格子中间的“...”代表格子的内容。
图中地址是从下往上增长的。
esp永远指向栈顶。一开始它指向地址为0x0063 fff4的字节。然后向栈压入4个字节。
对80X86来说,指令就是push ...;
数据压入后,esp指向0x0063 fff0。这是新的栈顶。

弹出数据跟上面的过程相反。esp中的值会增加。

...这你妹,我画这干嘛,多此一举...好像画了图也没能说的更明白或者表达更深层次的意思啊。总之就是这样了,esp永远指向栈顶,记住就OK。

关于80X86 32位CPU汇编模型就讲上面这些了。之所以讲这么少,因为这就是最基本的和最本质的内容,讲多了反而把重点搞没了。
总结就是记住3个寄存器。eip, esp, ebp。记住他们的意义就可以了。

2).栈帧与C函数调用

关于这个其实没有什么好讲的。

关于计算机,最重要的三个抽象是什么?答案是虚拟地址空间、进程、文件。

一个进程就是一个运行中的程序,或者被加载到内存中的程序。现代操作系统使进程看上去独占了所有的系统资源,但实际上系统中运行着多个进程。

所以从一个进程的视角看去,它独占了系统中的所有内存资源和CPU资源。对于32位系统虚拟地址空间被抽象为编号0~0xffff ffff的字节序列,它是平坦的,线性的,被系统抽象了的,所以叫它平坦地址或线性地址、虚拟地址。

对于Linux来说,保留高1G为系统使用。0-3G空间被应用程序也就是进程独占。

对于一个被加载了的程序也就是进程,其在内存中的分布为:

共享内存段
自由存储区(堆)
BSS段
数据段
只读数据段
代码段

栈向下增长。

每一个函数调用,都是一个栈帧(stack frame)。
以下代码:
int add(int x, int y)
{
    int z;
    z = x + y;
    return z;
}
int main(int argc, char* argv[])
{
    add(3, 5);
    return 0;
}
那么main函数是一个栈帧,add是一个栈帧。
当程序运行时,main函数栈帧先被建立,这个栈帧在高地址。然后调用add函数。此时add函数栈帧被建立,在低地址。当程序执行流进入add函数时,add函数内的局部变量在add函数栈帧中被建立。然后add返回。当add函数返回,此时add函数栈帧被销毁,同时add函数内的局部变量也被销毁。所以,C编程原则告诉我们:永远不要返回一个指向局部对象的指针。也就是说如下代码是错误的:
int* getNumber(void)
{
    int a = 3;
    return &a;
}

那么运行时的栈是什么样子的呢?它是一个随着运行,不断增长(进入新的函数调用)和缩短(函数返回)的动态影像。

OK,关于C栈帧就说到这里,完毕。

3).函数调用的ASM级解释以及栈图

首先复习两个80X86汇编指令,call和ret.

先来一段汇编代码。很简单,有注释。
请注意。不同的汇编编译器使用不同的文法。MASM、NASM、gcc后端汇编编译器,它们的文法几乎完全不一样。尤其是gcc后端,他妹的那文法那个汗。
这里使用的是MASM.学习汇编的话用MASM还是NASM都没关系,学了之后用什么都一样,因为那只是文法方面的东西。指令助记符一般也不会有太多改变。如果真的写汇编代码的话,我想我倾向于使用NASM.
汇编语句分为指令(instruction)、指示性语句(directive)、和宏(macro).
只有指令是真正的机器代码。指示性语句是编译器处理的东西。宏是一堆指令性语句或指示性语句。
以下代码使用MASM。

.386 ;386系统
.MODEL FLAT ;32位平坦地址模式

Exit PROTO NEAR32 stdcall, dwPara:DWORD ;退出函数原型
                                                ;Exit是函数名,dwPara是函数参数

.STACK 4096 ;保留4096字节栈空间

.DATA ;数据段,定义全局变量
number1 DWORD 11111111h ;定义变量number1,大小4字节
number2 DWORD 22222222h ;定义变量number2, 大小4字节

.CODE ;程序代码
Init PROTO NEAR32 ;定义函数Init
        mov number1, 0 ;假设该指令地址为0x0040 0000

mov number2, 0
        ret ;函数Init返回
Init ENDP ;函数Init结束

_start: ;相当于main函数
        call Init ;调用函数Init,此指令地址为0x0040 000f
         ...... ;该处指令地址为0x0040 0014
       
        INVOKE Exit, 0 ;调用Exit退出

PUBLIC _start ;公开入口点

END ;程序结束

其实代码不用看的...
假设程序被加载入内存,这时esp被初始化,然后esp指向栈顶。设此时栈顶地址为0x0063 00f8.一切为了说明方便哈。总之程序加载后,栈被初始化,也就是esp被初始化,esp会指向内存中的某个地址,并以这个地址作为栈的起始。
eip始终指向执行流,也就是“下一条指令”。

这里说明一下。程序一旦加载,所有的指令、全局变量都被载入内存并有了确切的内存地址(程序加载前,或者说程序没有运行时,只是硬盘上的一个可执行文件对吧。程序运行前有一个系统加载动作,这个加载由操作系统完成)。这个我的另一篇BLOG《程序员的基本概念》里面略提过。清楚加载细节的是操作系统开发者,同时涉及到编译器和链接器。要更明白这个问题请参照《Linker and Loader》。

那么程序加载。栈初始化了。数据区域在内存中开辟出来了,全局变量被给予确切地址(这里是虚拟地址,因为这是一个进程,它的地址只管在虚拟地址空间中给就可以了,虚拟地址到物理地址的映射由操作系统和MMU完成)。代码段(也就是要执行的指令)也被放入内存中并给予确切地址。eip指向代码段的开始,并开始执行程序...

所以eip只管指向某个内存地址,这个内存地址存储着程序员编写的指令,然后CPU把指令取出来执行就是了。所以计算机叫做“顺序存储控制机”。对不起我啰嗦了。

好的。我们假设了,在程序加载后,esp被初始化为0x0063 00f8,并假设了mov number1, 0这个指令的地址在0x0040 0000,根据这个假设的地址和每个指令码的长度(这些指令都放在代码段,而且一个一个指令就是挨着放的),推断出call指令的地址是0x0040 000f,call指令的下一条指令的地址是0x0040 0014(因为这个call指令的长度占用5个字节,0x0040 000f + 5 = 0x0040 0014)。这里不算我对指令长度的计算错误,总之假设我的地址计算是正确的。

OK开始了。程序已经加载。那么开始程序执行。eip首先指向call指令,因为_start开始那里就是call指令。嗯,eip就是一个32位寄存器,这个寄存器里面的值永远是即将执行的指令的内存地址,这时eip里面的值是0x0040 000f。

call指令执行!该指令首先将下一条指令的地址压入栈,也就是说,call指令的第一个动作是将0x0040 0014(call指令的下一条指令地址)压入栈。esp此时变化,其值变为0x0063 00f4。为什么?因为esp被初始化为0x0063 00f8,一个地址4个字节入栈之后,esp = esp - 4。然后call指令转去调用Init过程代码。eip变化为0x0040 0000,为什么?因为Init过程的第一个指令地址就是0x0040 0000.这个过程是由CPU自动完成的,也就是说,call指令,让CPU自动完成这一系列动作。

然后Init过程执行到ret指令。
ret指令干什么?它将栈内数据弹出,并用该数据填充eip。栈内数据是什么?就是0x0040 0014,它就是call指令的下一条指令的地址!同时esp = esp + 4.也就是说,ret指令执行后,eip值变为0x0040 0014, esp的值变回0x0063 00f8.这个过程由CPU自动完成。ret指令让CPU自动完成这一系列动作。

整理:执行call,call指令首先将下一条指令地址入栈,然后跑去执行过程代码;过程代码中执行ret,ret首先从栈中将下一条指令地址弹回eip,这样程序就开始执行call指令后的指令。一句话:eip始终指向下一条指令地址。

以上!就是汇编函数调用和返回的过程。就是一个call和一个ret.eip在这个执行过程中通过栈来保存。

接下来,让我们开始考察C语言的过程调用和返回,也就是C语言函数的参数压栈和参数访问过程。

先看一个汇编调用压参和参数访问过程。

假设有一个add过程,这个过程的工作是将两个整型值(每个整型值4字节)相加,并将相加的和返回eax寄存器。
如果通过把参数压入堆栈来传递参数调用过程,那么调用方(caller)代码如下:
    push var1 ;第一个变量值
    push var2 ;第二个变量值
    call add ;调用add过程
    add esp, 8 ;从栈移除参数

而被调用过程(callee)add的代码如下:
add PROC NEAR32 ;add过程,该过程将两个整型值相加
    push ebp ;保存基栈指针
    mov ebp, esp ;建立栈
    mov eax, [ebp + 8] ;复制第二个参数值(var2)
    mov eax, [ebp + 12] ;加上第一个参数值(var1)
    pop ebp ;恢复ebp寄存器
    ret ;过程返回
add ENDP ;过程结束

我们将根据这段代码建立栈图。

先把调用栈图发上来...
解释再说

栈图2
栈图2



左边是caller(调用者)栈,右边是callee(被调用者)栈(是同一个栈,分别是压参前、call指令执行后的状态。caller和callee的视图)。
图中画的内存地址是向上增长的。

首先,esp是栈顶,直接从caller栈顶看起。也就是,在调用前,esp指向某个内存地址。
在调用函数前将参数压入栈中。
push var1
push var2
这两行代码使esp - 8. 然后压参完毕,图中即为压参完毕esp.
然后调用函数:
call add
嗯,之前复习call指令时说什么了?call指令执行时,首先将返回地址压入栈。
也就是将add esp, 8 这条指令的地址压入栈。
如左图所示。

然后call指令执行过程调用,eip指向add函数内第一条指令的地址:
push ebp ;将ebp保存到栈中,同时esp - 4(说过了80X86的栈是向低地址方向增长的).
此时ebp原值被保存入栈中。参看右图,蓝色部分是ebp原值。
然后:
mov ebp, esp
此时以ebp为基准的栈建立了。此时ebp和esp都指向栈顶(ebp原值被栈保存起来了哦)。
为什么要这么做?
因为esp是随时变动的,只要有压栈和出栈的操作,esp的值就随着压栈和出栈的操作变化(随着push和pop操作变化,甚或,程序员直接改动esp的值)。
而ebp却不会随着push和pop操作变化。程序员在callee中不会修改ebp的值,而是使用ebp作为基准访问参数。

那么接下来就很好理解了,第二个参数的地址是ebp + 8, 第一个参数的地址是ebp + 12.
所以
mov eax, [ebp + 8] ;复制第二个参数值(var2)到eax
mov eax, [ebp + 12] ;加上第一个参数值(var1)
就不难理解了。

在过程把实现代码处理完毕的最后,pop ebp将ebp原值从栈中弹出恢复。
然后ret返回指令将返回地址弹出并赋给eip(请注意,返回地址弹出后,esp + 4, 这时esp正好指向调用者压参完毕的位置),...
回到调用者的地方并继续执行。

那么调用处的add esp, 8 ;从栈移除参数
是干什么用的?注释已经说得很清楚了。
调用者将var1和var2压到栈中,由于调用者的压栈,esp被往下移动了8;那么这个esp的原始位置也就是caller的栈顶应该在过程调用后恢复,add esp, 8就是恢复esp的。

ok。基本上就是如此了!

对于C语言的过程调用,比如,在main函数里面调用add
int main(int argc, char* argv[])
{
    ...
    add(x, y);
    ...
}
实际上,这里add(x, y)(调用者处)被编译器编译成如下汇编代码:
push y
push x
call add
add esp, 8

以上,这就是C过程调用的汇编解释。

接下来给出一般过程的入口代码和出口代码。

不难猜测,所有的过程(被调用函数)都有一样的入口代码和出口代码:

所有的C函数,在被编译器编译成汇编代码之后,
函数开始的几行汇编代码总是这样的,所以我们称这它为入口代码(entry code):
push ebp ;保存基址
mov ebp, esp ;建立ebp偏移基准
sub esp, n ;n个字节的局部变量参数
push ... ;保存过程中会用到的通用寄存器
...
pushf ;保存标识寄存器,也就是保存标志位

而结尾的几行总是这样的,所以称其为出口代码:
popf ;恢复标识寄存器
pop ... ;恢复寄存器
...
mov esp, ebp ;恢复callee esp
pop ebp ;恢复ebp
ret ;返回

4). stdcall和cdcel

既然已经了解了上述内容,那么调用惯例就很容易理解了。
cdcel和stdcall是约定俗成的调用惯例,它们的区别在于由谁来恢复esp。

cdcel是由调用者恢复esp的调用惯例,
也就是说
push var1
push var2
call add
add esp, 8
这是cdcel调用惯例

而stdcall则是由callee恢复esp的调用惯例
stdcall会在callee里面将ret这样写:
ret 8
意思是返回的同时esp + 8.

这两种调用惯例,stdcall的好处是不用每次都在调用过程后写add esp, 8这样就减小了代码量,减小了目标文件的体积。
而stdcall的缺陷更明显,那就是callee有时候无法推断参数的个数和长度,这样的话esp只能由调用者恢复(比如变参数函数,这种函数callee是无法推断参数个数的,也就无法知道应该在ret后面加多少偏移量)。

posted @ 2014-03-05 13:20  foo__hack  阅读(831)  评论(0编辑  收藏  举报