C语言是如何进行函数调用的，换句话说C语言进行函数调用时都发生了些什么

先写一段简单的C语言程序(不传参)

#include <iostream>
int test(){
    int a=0;
    return 0;
}
int main()
{
    test();
}

这里我们简单的调用了一个函数test,我们对其进行反汇编，查看汇编代码,我用的编译器是gcc,使用clang会有不同的结果但都是大同小异

test():
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR -4[rbp], 0
        mov     eax, 0
        pop     rbp
        ret
main:
        push    rbp
        mov     rbp, rsp
        call    test()
        mov     eax, 0
        pop     rbp
        ret

首先我们知道，rbp是栈的基指针，rsp是栈的顶部的指针。人话说rsp、rbp这两个指针夹着栈。
在调用的时候执行了一条指令

push rbp

也就是把rbp入栈，就是先要把rbp的值暂时存起来，以后要用到。接着是

mov rbp, rsp

将rsp赋值给rbp,也就是将rbp指针移动至rsp。这样做是为了给test函数开辟一个属于他自己的栈。
我会搞一个动画、可能会直观一些

首先说明32位、64位下的函数传参有一些不同

传参的情况下(64位)

int test(int b,int c,int d,int e,int f, int g,int h,int i){
    b=1;
    c=2;
    d=3;
    e=4;
    f=5;
    g=6;
    h=7;
    i=8;
}
int main()
{
    int b=0;   
    test(1,2,3,4,5,6,7,8);
}

汇编如下

test:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR -4[rbp], edi
        mov     DWORD PTR -8[rbp], esi
        mov     DWORD PTR -12[rbp], edx
        mov     DWORD PTR -16[rbp], ecx
        mov     DWORD PTR -20[rbp], r8d
        mov     DWORD PTR -24[rbp], r9d
        mov     DWORD PTR -4[rbp], 1
        mov     DWORD PTR -8[rbp], 2
        mov     DWORD PTR -12[rbp], 3
        mov     DWORD PTR -16[rbp], 4
        mov     DWORD PTR -20[rbp], 5
        mov     DWORD PTR -24[rbp], 6
        mov     DWORD PTR 16[rbp], 7
        mov     DWORD PTR 24[rbp], 8
        nop
        pop     rbp
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR -4[rbp], 0
        push    8
        push    7
        mov     r9d, 6
        mov     r8d, 5
        mov     ecx, 4
        mov     edx, 3
        mov     esi, 2
        mov     edi, 1
        call    test
        add     rsp, 16
        mov     eax, 0
        leave
        ret

可以看到传参的顺序是从右到左的，至于为什么要这样传参是因为栈的性质，先进后出第一个参数最后入栈，那么取出的时候是第一个取出的，这样设计的话就可以支持可变参数了。
然后在看这一段

        mov     r9d, 6
        mov     r8d, 5
        mov     ecx, 4
        mov     edx, 3
        mov     esi, 2
        mov     edi, 1

这是主调函数(就是调用其他函数的那个函数)把参数放到了寄存器里，是这样的，在64位C程序中函数调用优先使用寄存器(快)64位CPU的寄存器很多的可以看到顺序

• edi(rdi)
• esi(rsi)
• edx(rdx)
• ecx(rcx)
• r8d
• r9d
  如果参数更多的话，使用栈传参。
  但是即使他用了寄存器传参他也一定会放到栈里的，这个操作是在test函数里实现的

test:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR -4[rbp], edi
        mov     DWORD PTR -8[rbp], esi
        mov     DWORD PTR -12[rbp], edx
        mov     DWORD PTR -16[rbp], ecx
        mov     DWORD PTR -20[rbp], r8d
        mov     DWORD PTR -24[rbp], r9d

这一段。到这里你一定会感到疑惑，为什么

        mov     DWORD PTR 16[rbp], 7
        mov     DWORD PTR 24[rbp], 8

这两行和其他两行不一样的说
都是int 前面的占4个字节，这两个占8个字节，并且前面的是减，后面的是加。
然后还是从16开始的，好奇怪!

思考

• rbp寄存器的大小.
• pc寄存器大小.
• 再想想为什么函数调用后能回到调用它的地方.

如果想通了这两件事，问题就迎刃而解了，如果没想明白，下一篇文章将会解答
至于为什么下面是占据8个字节全因为push指令，他一次会压入8个字节(64位cpu)，所以就要配合人家
然后为什么上面是4个字节，因为我这个编译器下int占据4个字节。有可能其他编译器64位程序中int 占据8个字节

传参的情况下(32位)

未完待续。。。

@sunrisepeak 有道理，完善了

在上一篇文章中我说错了一件事,其实没有pc寄存器,pc全称是program counter (程序计数器),他是一个抽象的概念,在x86/x64下是ip的数值(也不是很准确,在以后的文章中我们不必纠结这些事情都管他叫做PC)

• rbp 寄存器大小
• pc 寄存器大小

在函数调用的时候会在栈中记录下函数调用后下一个指令的地址(pc),还会记录栈基址(rbp),这些数据记录在哪里?肯定就是内存里啦!我们再仔细看一眼汇编代码

//C
int testfunc(){
    int a=0;
}

int testfunc2()
{
    testfunc();
}

//asm
testfunc:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR -4[rbp], 0
        nop
        pop     rbp
        ret
testfunc2:
        push    rbp
        mov     rbp, rsp
        mov     eax, 0
        call    testfunc
        nop
        pop     rbp
        ret

看汇编代码我们是不是看不哪里压栈了,这时候就要介绍一下call指令的执行过程

• 首先call指令会将PC入栈
• 然后会有一个jmp跳转到要执行的地址
  说起来可能很抽象,下面用一张图来说明他的过程
  
  这张图片应该就可以很清晰地描绘call指令都干了些啥了吧!
  由此可见,在函数调用的过程中程序的返回地址存在栈栈中,也就是栈上的数据会影响程序的运行过程.试想如果我们修改了栈上特定位置的数值,并修改成特定的数值,那么我们就可以让程序走到意想不到的地方(栈溢出).

32位(x86情况下)

先上代码

int f=0;
int c=0;

int testfunc(){
    int a=0;
    f=1;
    return c;
}

int testfunc2()
{
    testfunc();
}

f:
        .zero   4
c:
        .zero   4
testfunc:
        push    ebp
        mov     ebp, esp
        sub     esp, 16
        call    __x86.get_pc_thunk.ax
        add     eax, OFFSET FLAT:_GLOBAL_OFFSET_TABLE_
        mov     DWORD PTR -4[ebp], 0
        mov     DWORD PTR f@GOTOFF[eax], 1
        mov     eax, DWORD PTR c@GOTOFF[eax]
        leave
        ret
testfunc2:
        push    ebp
        mov     ebp, esp
        call    __x86.get_pc_thunk.ax
        add     eax, OFFSET FLAT:_GLOBAL_OFFSET_TABLE_
        call    testfunc
        nop
        pop     ebp
        ret
__x86.get_pc_thunk.ax:
        mov     eax, DWORD PTR [esp]
        ret

我们发现多了一个这个函数 __x86.get_pc_thunk.ax 这个是干什么的呢?我们来分析一下
在testfunc2中有这样一条指令

call    __x86.get_pc_thunk.ax

首先call指令会将PC寄存器入栈,然后在 __x86.get_pc_thunk.ax 函数中进行了

  eax, DWORD PTR [esp]

这个操作,esp是栈指针指向的是栈顶部也就是刚刚push的数据也就是PC寄存器的数值了,所以说这个函数是获取下一条指令的地址的,原因是因为x86架构下没有获取PC寄存器的指令只能用这种方式获取了.

PS:为什么要这么做

因为有一个功能叫做PIE(地址随机化)这个可以有效增加栈溢出导致REC风险
接着来看

add     eax, OFFSET FLAT:_GLOBAL_OFFSET_TABLE_

这个 FLAT:GLOBAL_OFFSET_TABLE 是全局静态变量表所对应add指令的偏移量,这个是在编译时期确定的,所以这个代码的意思是找到全局静态变量表的地址并储存到eax寄存器中,为了方便我在下文分析函数调用的时候会关闭pie得到相对简单的汇编代码

int testfunc(int g){
    g=8;
}

int testfunc2()
{
    testfunc(2);
}

testfunc:
        push    ebp
        mov     ebp, esp
        mov     DWORD PTR [ebp+8], 8
        nop
        pop     ebp
        ret
testfunc2:
        push    ebp
        mov     ebp, esp
        push    2
        call    testfunc
        add     esp, 4
        nop
        leave
        ret

可以看到在x86下只有栈传参没有寄存器传参,其余的和x64下的是相同的

PS:如果你想复现的话记得加入-m32 --no-pie这两个编译参数 一个是目标平台是32位的,一个是不使用pie