{
  "schemaVersion": "0.11.0",
  "canonical": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/",
  "atlas": "https://www.pystone.net/?node=cpp-function-call-stack-mechanism#knowledge-atlas",
  "markdown": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism.md",
  "context": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism.context.json",
  "knowledgeVersion": "224c990773de.5fa8af6e39fa",
  "build": {
    "siteCommit": "224c990773de166d23a886306577dd90379529ce",
    "notesCommit": "5fa8af6e39fa3891d1b9b4832bfa6c4e0ecaaf0a",
    "builtAt": "1970-01-01T00:00:00.000Z",
    "version": "224c990773de.5fa8af6e39fa"
  },
  "id": "note:cpp-function-call-stack-mechanism",
  "slug": "cpp-function-call-stack-mechanism",
  "title": "函数调用 压栈的工作原理",
  "type": "note",
  "visibility": "public",
  "idStability": "rename-stable",
  "author": {
    "name": "Perrin Yong",
    "profile": "https://www.pystone.net/profile/"
  },
  "publisher": {
    "name": "Perrin Yong",
    "profile": "https://www.pystone.net/profile/"
  },
  "aliases": [],
  "summary": "函数调用 压栈的工作原理",
  "contentRole": "unspecified",
  "isMoc": false,
  "mocRecognition": "none",
  "generated": false,
  "attribution": "unspecified",
  "domain": "10-计算机、信息技术与工程",
  "tags": [],
  "mocs": [],
  "contentHash": "7b07bb593ae9b44845d96db7c6837e78176d3453989ecafecd46775eb8ed937c",
  "assets": [
    {
      "reference": "assets/0012 - 函数调用 压栈的工作原理__resource-001-ac61d4983c84.png",
      "url": "/media/5e740e82cc3c8ed8352e.png",
      "mediaType": "image/png",
      "contentHash": "5e740e82cc3c8ed8352e6bb6bc28d9a17ab975e535d01f5e687daf8c38209425",
      "byteLength": 44670,
      "width": 569,
      "height": 438
    }
  ],
  "headings": [
    {
      "depth": 1,
      "text": "函数调用 压栈的工作原理",
      "anchor": "函数调用-压栈的工作原理",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8-%E5%8E%8B%E6%A0%88%E7%9A%84%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86"
    },
    {
      "depth": 2,
      "text": "内存的使用简介",
      "anchor": "内存的使用简介",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E5%86%85%E5%AD%98%E7%9A%84%E4%BD%BF%E7%94%A8%E7%AE%80%E4%BB%8B"
    },
    {
      "depth": 3,
      "text": "寄存器与函数栈帧",
      "anchor": "寄存器与函数栈帧",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E5%AF%84%E5%AD%98%E5%99%A8%E4%B8%8E%E5%87%BD%E6%95%B0%E6%A0%88%E5%B8%A7"
    },
    {
      "depth": 3,
      "text": "函数调用与返回步骤",
      "anchor": "函数调用与返回步骤",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8%E4%B8%8E%E8%BF%94%E5%9B%9E%E6%AD%A5%E9%AA%A4"
    },
    {
      "depth": 4,
      "text": "调用：",
      "anchor": "调用",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E8%B0%83%E7%94%A8"
    },
    {
      "depth": 4,
      "text": "返回：",
      "anchor": "返回",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E8%BF%94%E5%9B%9E"
    },
    {
      "depth": 3,
      "text": "函数调用约定与相关指令",
      "anchor": "函数调用约定与相关指令",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8%E7%BA%A6%E5%AE%9A%E4%B8%8E%E7%9B%B8%E5%85%B3%E6%8C%87%E4%BB%A4"
    },
    {
      "depth": 4,
      "text": "stdcall",
      "anchor": "stdcall",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#stdcall"
    },
    {
      "depth": 4,
      "text": "cdecl",
      "anchor": "cdecl",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#cdecl"
    },
    {
      "depth": 4,
      "text": "fastcall",
      "anchor": "fastcall",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#fastcall"
    },
    {
      "depth": 4,
      "text": "thiscall",
      "anchor": "thiscall",
      "citation": "https://www.pystone.net/notes/cpp-function-call-stack-mechanism/#thiscall"
    }
  ],
  "claims": [],
  "outgoing": [],
  "incoming": [
    {
      "id": "note:programming-languages-and-runtimes",
      "title": "编程语言与运行时",
      "url": "https://www.pystone.net/notes/programming-languages-and-runtimes/",
      "atlas": "https://www.pystone.net/?node=programming-languages-and-runtimes#knowledge-atlas",
      "label": "编程语言与运行时",
      "origin": "explicit",
      "humanReviewed": true,
      "context": "C++中的“函数调用 压栈的工作原理”导航项",
      "citation": "https://www.pystone.net/notes/programming-languages-and-runtimes/#c"
    }
  ],
  "contentMarkdown": "# 函数调用 压栈的工作原理\n\n# 函数调用 压栈的工作原理\n\n> 创建时间：2020/3/15 17:16\n\n参考：https://blog.csdn.net/u011555996/article/details/70211315\nhttps://blog.csdn.net/qq_34771252/article/details/90547751\n\n> **PE文件** (Portable Executable),可移植的可执行的文件,是微软Windows操作系统上的程序文件（可能是间接被执行，如DLL）\n>  eg. EXE、DLL、OCX、SYS、COM\n\n## 内存的使用简介\n\n在Windows平台下，高级语言写出的程序经过编译链接，最终会变成PE文件。当PE文件被装载运行后，就成了所谓的进程。\nPE文件代码段中包含的二进制级别的机器代码会被装入内存的 **代码区(.text)** ，处理器将到内存的这个区域一条一条地取出指令和操作数，并送入运算逻辑单元进行运算；如果代码中请求开辟 **动态内存** ，则会在内存的 **堆区** 分配一块大小合适的区域返回给代码区的代码使用；当函数调用发生时， **函数的调用关系等信息** 会动态地保存在内存的 **栈区** ，以供处理器在执行完被调用函数的代码时，返回母函数。\n\n> **关于出栈问题：**\n>  pop操作栈顶元素，SS:SP指向1000EH新的栈顶，原栈顶1000CH的数据依然存在，但是它在栈中不存在了，当再次push等入栈指令后，SS：SP移1000CH，并在里面写入新的数据，将其覆盖。\n\n内存的栈区实际上指的就是 **系统栈** 。系统栈由系统自动维护，它用于实现高级语言中函数的调用。对于类似C语言这样的高级语言，系统栈的PUSH、POP等堆栈平衡细节是透明的。一般说来，只有在使用汇编语言开发程序的时候，才需要和它直接打交道。\n\n### 寄存器与函数栈帧\n\n每一个函数独占自己的栈帧空间。当前 **正在运行的函数** 的 **栈帧** 总是在 **栈顶** 。\nWin32系统提供两个特殊的 **寄存器** 用于 **标识** 位于 **系统栈顶端的栈帧** 。\n\n  1. **ESP** ： **栈指针寄存器** (extended stack pointer)，其内存放着一个指针，该指针永远指向系统栈 **最上面一个栈帧的栈顶** 。\n  2. **EBP** ： **基址指针寄存器** (extended base pointer)，其内存放着一个指针，该指针永远指向系统栈 **最上面一个栈帧的底部** 。\n\n**函数栈帧** ：ESP和EBP之间的内存空间为当前栈帧,EBP标识了当前栈帧的底部，ESP标识了当前栈帧的顶部。\n在函数栈帧中，一般 **包含** 以下几类重要信息：\n(1) **局部变量** ：为函数局部变量开辟的内存空间。\n(2) **栈帧状态值** ：保存 **前栈帧的顶部和底部** (实际上只保存前栈帧的底部，前栈帧的顶部可以通过栈帧平衡计算得到)，用于在 **本栈被弹出** 后恢 **复出上一个栈帧** 。\n(3) **函数返回地址** ：保存当前函数调用前的“断点”信息，也就是函数调用前的指令位置，以便在函数返回时能够恢复到函数被调用前的代码区中继续执行指令。\n\n> 函数栈帧的大小并不固定，一般与其对应函数的局部变量多少有关。函数 **运行过程中** ，其 **栈帧大小** 也是 **在不停变化** 的。\n\n  3. **EIP** ： **指令寄存器** (extended instruction pointer)，其内存放着一个指针，该指针永远指向下一条等待执行的指令地址。\n\n> 其他 ：\n>  EAX：累加(Accumulator)寄存器，常用于函数返回值\n>  EBX：基址(Base)寄存器，以它为基址访问内存\n>  ECX：计数器(Counter)寄存器，常用作字符串和循环操作中的计数器\n>  EDX：数据(Data)寄存器，常用于乘除法和I/O指针\n>  ESI：源变址寄存器\n>  DSI：目的变址寄存器\n>  ESP：栈(Stack)指针寄存器，指向栈顶部\n>  EBP：基址指针寄存器，指向当前栈底部\n>  EIP：指令寄存器，指向下一条指令的地址\n\n### 函数调用与返回步骤\n\n更具体的过程见：https://www.cnblogs.com/UnknowCodeMaker/p/11002225.html\n\n#### 调用：\n\n  1. 参数入栈：将参数从右向左依次压入系统栈中。\n  2. 返回地址入栈：将当前代码区调用指令的下一条指令地址压入栈中，供函数返回时继续执行。\n  3. 代码区跳转：处理器从当前代码区跳转到被调用函数的入口处。\n  4. 栈帧调整：具体包括：\n    1. 保存当前栈帧状态值，已备后面恢复本栈帧时使用(EBP入栈)。\n    2. 将当前栈帧切换到新栈帧(将ESP值装入EBP，更新栈帧底部)。\n    3. 给新栈帧分配空间(把ESP减去所需空间的大小，抬高栈顶)。\n    4. 对于_stdcall调用约定，函数调用时用到的指令序列大致如下：\n\n> push 参数3 ;假设该函数有3个参数，将从右向做依次入栈\n>  push 参数2\n>  push 参数1\n>  call 函数地址 ;call指令将同时完成两项工作：a)向栈中压入当前指令地址的下一个指令地址，即保存返回地址。 b)跳转到所调用函数的入口处。\n>  push ebp ;保存旧栈帧的底部\n>  mov ebp,esp ;设置新栈帧的底部 (栈帧切换)\n>  sub esp,xxx ;设置新栈帧的顶部 (抬高栈顶，为新栈帧开辟空间)\n\n#### 返回：\n\n  1. 保存返回值，通常将函数的返回值保存在寄存器EAX中。\n  2. 弹出当前帧，恢复上一个栈帧。具体包括：\n    1. 在堆栈平衡的基础上，给ESP加上栈帧的大小，降低栈顶，回收当前栈帧的空间。\n    2. 将当前栈帧底部保存的前栈帧EBP值弹入EBP寄存器，恢复出上一个栈帧。\n    3. 将函数返回地址弹给EIP寄存器。\n    4. 跳转：按照函数返回地址跳回母函数中继续执行。\n\n> add esp,xxx ;降低栈顶，回收当前的栈帧\n>  pop ebp ;将上一个栈帧底部位置恢复到ebp\n>  retn ;a)弹出当前栈顶元素，即弹出栈帧中的返回地址，至此，栈帧恢复到上一个栈帧工作完成。b)让处理器跳转到弹出的返回地址，恢复调用前代码区\n\n### 函数调用约定与相关指令\n\n![](assets/0012 - 函数调用 压栈的工作原理__resource-001-ac61d4983c84.png)\n\n详见:https://blog.csdn.net/qq_34771252/article/details/90547751\n**函数调用约定** ：不同的操作系统、不同的语言、不同的编译器在实现函数调用时的原理虽然基本相同，但具体的调用约定还是有差别的。这包括 **参数传递方式** ， **参数入栈顺序是从右向左还是从左向右** ， **函数返回时恢复堆栈平衡的操作在子函数中进行还是在母函数中进行** 。\n\n常见的调用约定有：stdcall，cdecl，fastcall，thiscall，naked call\n\n#### __stdcall\n\n> 很多时候称为 **pascal调用约定** ，Microsoft C++系列的C/C++编译器中，常常用PASCAL宏来声明这个调用约定，类似的宏还有WINAPI和CALLBACK。\n\n声明格式：\n\n```cpp\nstring str1 = "test";\nstring str2 = "test";\n\n```\n\n  * 参数从右向左压入堆栈\n  * 函数自身修改堆栈\n  * 函数名自动加前导的下划线，后面紧跟一个@符号，其后紧跟着参数的尺寸\n\npush 2 第二个参数入栈\npush 1 第一个参数入栈\ncall function 调用参数，注意此时自动把cs:eip入栈\n而对于函数自身，则可以翻译为：\npush ebp 保存ebp寄存器，该寄存器将用来保存堆栈的栈顶指针，可以在函数退出时恢复mov ebp,esp 保存堆栈指针mov eax,[ebp + 8H] 堆栈中ebp指向位置之前依次保存有ebp,cs:eip,a,b,ebp +8指向a\nadd eax,[ebp + 0CH] 堆栈中ebp + 12处保存了b\nmov esp,ebp 恢复esp\npop ebp\nret 8\n而在编译时，这个函数的名字被翻译成_function@8\n\n#### __cdecl\n\n**C调用约定** ，是 **C语言缺省** 的调用约定\n\n```cpp\nstring str1 = "test";\nstring str2 = "test";\n\n```\n\n  * 参数首先由右向左压入堆栈\n  * 函数本身不清理堆栈，调用者负责清理堆栈\n\n#### __fastcall\n\n函数的第一个和第二个DWORD参数（或者尺寸更小的）通过ecx和edx传递，其他参数通过从右向左的顺序压栈被调用函数清理堆栈函数名修改规则同stdcall\n\n```cpp\nstring str1 = "test";\nstring str2 = "test";\n\n```\n\n#### thiscall\n\n唯一一个不能明确指明的函数修饰，因为thiscall不是关键字\n它是C++类成员函数缺省的调用约定。由于成员函数调用还有一个this指针，因此必须特殊处理\n\n  * 参数从右向左入栈\n  * 如果参数个数确定，this指针通过ecx传递给被调用者；\n  * 如果参数个数不确定，this指针在所有参数压栈后被压入堆栈。对参数个数不定的，调用者清理堆栈，否则函数自己清理堆栈\n"
}