函数调用栈

最新推荐文章于 2025-05-13 13:38:43 发布
最新推荐文章于 2025-05-13 13:38:43 发布
阅读量2.1k 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Go 文章标签： c语言 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/twelve_coder/article/details/109243617

函数调用栈

什么是函数调用栈

函数是每一门编程语言中，不可缺少的部分。函数本质是一片成块的内存指令。而函数调用，除了基本的程序指令跳转外，还需要保存函数相关的上下文，也就是函数的参数，本地变量，返回参数，返回地址等。保存函数上下文的就是我们常说的函数栈。函数相互调用的栈结构，就是函数调用栈。

函数调用栈用在何处

  1. 函数调用栈是函数调用必不可少的组成部分。
  2. 我们常说的协程，底层的实现原理，都是基于函数调用栈的。协程切换，就是不同的栈帧切换，同时保存相关的上下文，当然这里也有寄存器值的保存。

C语言实现

#include <stdio.h>

int sum(int a, int b, int c) {
    int sum_loc1 = 7;
    int sum_loc2 = 8;
    int sum_loc3 = 9;
    
    return sum_loc1 + sum_loc2 + sum_loc3 + a + b + c;
}

int main(int argc, const char *argv[]) {
    int loc1 = 1;
    int loc2 = 2;
    int loc3 = 3;
    int ret = sum(4,5,6);
    printf("ret:%d\n", ret);
}
  • C语言对应的x86_64汇编代码
0000000000400530 <sum>:
  400530:	55                   	push   %rbp               # rbp 入栈
  400531:	48 89 e5             	mov    %rsp,%rbp          # rbp = rsp
  400534:	89 7d ec             	mov    %edi,-0x14(%rbp)   # 第一个参数入栈
  400537:	89 75 e8             	mov    %esi,-0x18(%rbp)   # 第二个参数入栈
  40053a:	89 55 e4             	mov    %edx,-0x1c(%rbp)   # 第三个参数入栈
  40053d:	c7 45 fc 07 00 00 00 	movl   $0x7,-0x4(%rbp)    # 本地变量1：7
  400544:	c7 45 f8 08 00 00 00 	movl   $0x8,-0x8(%rbp)    # 本地变量2：8 
  40054b:	c7 45 f4 09 00 00 00 	movl   $0x9,-0xc(%rbp)    # 本地变量3：9
  400552:	8b 45 f8             	mov    -0x8(%rbp),%eax
  400555:	8b 55 fc             	mov    -0x4(%rbp),%edx
  400558:	01 c2                	add    %eax,%edx          # 8 + 7
  40055a:	8b 45 f4             	mov    -0xc(%rbp),%eax
  40055d:	01 c2                	add    %eax,%edx          # 9 + 15 = 24
  40055f:	8b 45 ec             	mov    -0x14(%rbp),%eax   # 4 + 24 = 28
  400562:	01 c2                	add    %eax,%edx
  400564:	8b 45 e8             	mov    -0x18(%rbp),%eax   # 5 + 28 = 33
  400567:	01 c2                	add    %eax,%edx
  400569:	8b 45 e4             	mov    -0x1c(%rbp),%eax   # 6 + 33 = 39
  40056c:	01 d0                	add    %edx,%eax          # eax 作为返回值存储寄存器
  40056e:	5d                   	pop    %rbp               # 弹出rbp
  40056f:	c3                   	retq   

0000000000400570 <main>:
  400570:	55                   	push   %rbp                # rbp 压栈
  400571:	48 89 e5             	mov    %rsp,%rbp           # rbp = rsp
  400574:	48 83 ec 20          	sub    $0x20,%rsp          # rsp = 32 ; 字节
  400578:	89 7d ec             	mov    %edi,-0x14(%rbp)    #  
  40057b:	48 89 75 e0          	mov    %rsi,-0x20(%rbp)    #
  40057f:	c7 45 fc 01 00 00 00 	movl   $0x1,-0x4(%rbp)     # 本地变量从右到左入栈
  400586:	c7 45 f8 02 00 00 00 	movl   $0x2,-0x8(%rbp)     # 
  40058d:	c7 45 f4 03 00 00 00 	movl   $0x3,-0xc(%rbp)     #
  400594:	ba 06 00 00 00       	mov    $0x6,%edx           # 第三个参数
  400599:	be 05 00 00 00       	mov    $0x5,%esi           # 第二个参数
  40059e:	bf 04 00 00 00       	mov    $0x4,%edi           # 第一个参数
  4005a3:	e8 88 ff ff ff       	callq  400530 <sum>        # 调用sum指令
  4005a8:	89 45 f0             	mov    %eax,-0x10(%rbp)    # 返回值放入预先的栈空间
  4005ab:	8b 45 f0             	mov    -0x10(%rbp),%eax
  4005ae:	89 c6                	mov    %eax,%esi           # 放入printf第二个参数
  4005b0:	bf 60 06 40 00       	mov    $0x400660,%edi
  4005b5:	b8 00 00 00 00       	mov    $0x0,%eax
  4005ba:	e8 51 fe ff ff       	callq  400410 <printf@plt>
  4005bf:	c9                   	leaveq 
  4005c0:	c3                   	retq   
  4005c1:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4005c8:	00 00 00 
  4005cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)


# call :
# 1. 将call下一条指令入栈；也就是ip入栈 
# 2. 将sum指令入ip
  • 对应的C语言栈帧

在这里插入图片描述

1. 本地变量从左到右依次入栈，返回值保存的变量是第四个本地变量
2. 函数参数由被调用者`callee`负责维护，从左到右依次入栈
3. 最后返回地址入栈
4. `rbp`入栈

Go语言实现

package main

import (
	"fmt"
)

func sum(a, b, c int) (ret1, ret2 int) {
    loc1 := 1
    loc2 := 2
    loc3 := 3
    return a + b + loca1, c + loc2 + loc3
}

func main() {
    l1 := 4
    l2 := 5
    l3 := 6
    r1,r2 := sum(7,8,9)
    fmt.Printf("r1:%d, r2%d\n", r1, r2)
}

func sum(a, b, c int) (ret1, ret2 int) {
  0x49aa80		4883ec30		SUBQ $0x30, SP		     # 栈扩展 48字节
  0x49aa84		48896c2428		MOVQ BP, 0x28(SP)	     # bp 入栈
  0x49aa89		488d6c2428		LEAQ 0x28(SP), BP	     # 重新设置bp的值
  0x49aa8e		48c744245000000000	MOVQ $0x0, 0x50(SP)	 #
  0x49aa97		48c744245800000000	MOVQ $0x0, 0x58(SP)	
	loc1 := 1
  0x49aaa0		48c744241001000000	MOVQ $0x1, 0x10(SP)	 # 本地变量1
	loc2 := 2
  0x49aaa9		48c744240802000000	MOVQ $0x2, 0x8(SP)	
	loc3 := 3
  0x49aab2		48c7042403000000	MOVQ $0x3, 0(SP)	
	return a + b + loc1, c + loc2 + loc3
  0x49aaba		488b442438		MOVQ 0x38(SP), AX	     # caller保存参数
  0x49aabf		4803442440		ADDQ 0x40(SP), AX	     # 
  0x49aac4		4803442410		ADDQ 0x10(SP), AX	     # AX = loc1 + (a+b) 
  0x49aac9		4889442420		MOVQ AX, 0x20(SP)	     # r1 第一个返回参数
  0x49aace		488b442448		MOVQ 0x48(SP), AX	
  0x49aad3		4803442408		ADDQ 0x8(SP), AX	
  0x49aad8		48030424		ADDQ 0(SP), AX		
  0x49aadc		4889442418		MOVQ AX, 0x18(SP)	     # r2 第二个返回参数
  0x49aae1		488b442420		MOVQ 0x20(SP), AX	
  0x49aae6		4889442450		MOVQ AX, 0x50(SP)	
  0x49aaeb		488b442418		MOVQ 0x18(SP), AX	
  0x49aaf0		4889442458		MOVQ AX, 0x58(SP)	
  0x49aaf5		488b6c2428		MOVQ 0x28(SP), BP	
  0x49aafa		4883c430		ADDQ $0x30, SP		
  0x49aafe		c3			RET
  
  
  
func main() {
  0x49ab00		64488b0c25f8ffffff	MOVQ FS:0xfffffff8, CX	
  0x49ab09		488d842448ffffff	LEAQ 0xffffff48(SP), AX	
  0x49ab11		483b4110		CMPQ 0x10(CX), AX	
  0x49ab15		0f8619030000		JBE 0x49ae34		
  0x49ab1b		4881ec38010000		SUBQ $0x138, SP		
  0x49ab22		4889ac2430010000	MOVQ BP, 0x130(SP)	
  0x49ab2a		488dac2430010000	LEAQ 0x130(SP), BP	
	l1 := 4
  0x49ab32		48c744246004000000	MOVQ $0x4, 0x60(SP)	   # 本地变量1
	l2 := 5
  0x49ab3b		48c744245805000000	MOVQ $0x5, 0x58(SP)	   # 本地变量2
	l3 := 6
  0x49ab44		48c744245006000000	MOVQ $0x6, 0x50(SP)	   # 本地变量3
	r1, r2 := sum(7, 8, 9)
  0x49ab4d		48c7042407000000	MOVQ $0x7, 0(SP)	   # 参数
  0x49ab55		48c744240808000000	MOVQ $0x8, 0x8(SP)	   # 参数2
  0x49ab5e		48c744241009000000	MOVQ $0x9, 0x10(SP)	   # 参数3
  0x49ab67		e814ffffff		CALL main.sum(SB)	
  0x49ab6c		488b442418		MOVQ 0x18(SP), AX	
  0x49ab71		4889442470		MOVQ AX, 0x70(SP)	       # r2返回值拷贝
  0x49ab76		488b442420		MOVQ 0x20(SP), AX	
  0x49ab7b		4889442468		MOVQ AX, 0x68(SP)	       # r2返回值拷贝
  0x49ab80		488b442470		MOVQ 0x70(SP), AX	
  0x49ab85		4889442448		MOVQ AX, 0x48(SP)	
  0x49ab8a		488b442468		MOVQ 0x68(SP), AX	
  0x49ab8f		4889442440		MOVQ AX, 0x40(SP)

在这里插入图片描述

总结

C语言和Go语言栈帧，最大的不同就是：

  • 函数参数保存方式，位置不同

    • C使用寄存器传递函数参数，函数参数保存在callee栈帧中
    • Go直接使用栈传递参数，函数参数保存在caller`栈帧中

  • 函数参数排列顺序不同

    • C函数参数从左到右入栈排列
    • Go函数参数从右到左入栈排列

  • 函数返回值处理不同

    • C通过寄存器ax将返回值传给caller, caller当作本地变量
    • Go：caller拷贝callee栈帧中的返回值，写入本栈，返回值从右向左入栈
C语言：函数调用堆栈
新华编程特战队
12-08 262
调用堆栈是由操作系统在 RAM 内存中维护的动态数据结构。C 语言中函数调用堆栈的主要任务是管理函数调用以及它们如何相互传递参数。为每个任务和每个线程维护一个调用堆栈。它也称为执行堆栈或计算机堆栈。更常见的是，它被简单地称为堆栈。现在，让我们看看函数调用实际上是如何在堆栈中组织的： 假设我们有两个函数 f1（） 和 f2（） 以及 main（）。return;f2();return;f1();当一个函数调用另一个函数时，一个条目被推送到堆栈。此条目称为激活记录。
C语言函数调用栈(一)
weixin_34240657的博客
05-27 3052
       程序的执行过程可看作连续的函数调用。当一个函数执行完毕时，程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现，每个用户态进程对应一个调用栈结构(call stack)。编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。      不同处理器和编译器的堆栈布局、函数调用方法都可能...
【C语言入门】函数调用栈
最新发布
Mr_-G，一名勤奋底层软件开发工程师的博客
05-13 715
函数调用栈是现代程序设计中用于管理函数执行上下文的关键机制。它通过“后进先出”（LIFO）的原则，解决了函数调用中的三个核心问题：返回地址的保存、参数的传递以及局部变量的存储。每个函数调用都会在栈中生成一个独立的栈帧，记录函数的执行信息。栈帧的结构由编译器根据目标平台的调用约定确定，通常包括返回地址、调用者的基址指针、局部变量和临时数据等。函数调用栈的管理依赖于关键寄存器，如栈指针（SP）和基址指针（BP）。栈溢出是常见的栈故障，通常由无限递归或大局部变量引起。
C 语言 函数调用栈
freeking101的博客
10-24 938
From：https://www.cnblogs.com/clover-toeic/p/3755401.html https://www.cnblogs.com/clover-toeic/p/3756668.html 程序的执行过程可看作连续的函数调用。当一个函数执行完毕时，程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现...
浅谈在linux kernel中打印函数调用的堆栈的方法
09-15
在Linux内核开发和调试过程中，理解函数调用堆栈是非常关键的，它能帮助开发者追踪问题的根源，尤其是在处理内核崩溃或者异常时。本文将深入探讨如何在Linux内核中打印函数调用的堆栈。 首先，Linux内核提供了一个...
解析JavaScript函数调用栈：理解执行上下文与调用堆栈
闪电⚡之王的博客简介
07-14 801
函数调用栈，也称为调用堆栈（call stack），是一种用于管理函数调用关系的数据结构。它遵循"后进先出"（Last-In-First-Out，LIFO）的原则，用于追踪函数的执行顺序以及函数之间的嵌套关系。在JavaScript中，每当函数被调用时，会创建一个称为执行上下文（execution context）的对象，其中包含函数的参数、局部变量以及函数的返回地址。这些执行上下文对象按照调用顺序被依次推入函数调用栈，当函数执行完成后，相应的执行上下文对象会从栈顶弹出，将控制权交给上一个调用的函数。
JavaScript实现显示函数调用堆栈的方法
10-22
JavaScript函数调用堆栈是程序执行过程中一种重要的信息，它记录了函数调用的顺序和层次关系，有助于开发者理解程序执行流程，特别是在进行错误调试和性能分析时。在现代浏览器中，通常可以通过console对象的trace...
函数调用过程中函数栈详解
热门推荐
u012218309的博客
08-14 3万+
当进程被加载到内存时，会被分成很多段 代码段：保存程序文本，指令指针EIP就是指向代码段，可读可执行不可写，如果发生写操作则会提示segmentation fault 数据段：保存初始化的全局变量和静态变量，可读可写不可执行 BSS：未初始化的全局变量和静态变量 堆(Heap)：动态分配内存，向地址增大的方向增长，可读可写可执行 栈(Stack)：存放局部变量，函数参数，当前状...
函数调用过程中栈到底是怎么压入和弹出的？
happygogf的专栏
09-16 2243
http://www.zhihu.com/question/22444939 一个程序在运行过程中，一个函数会调用另一个函数（比如递归），那么函数在进入的时候都会往栈里压点什么东西，函数退出时会弹出点什么东西，内层的函数是如何返回的，返回给外层函数的谁，返回到哪里，内层函数是怎么知道返回地址的？
函数调用栈（Call Stack）
白马负金羁
06-30 681
虚拟内存空间中的函数调栈主要用于保存函数的参数，返回值，返回地址，本地变量等。一切的函数调用都要将不同的数据、地址压入或者弹出栈。因此，为了更好地理解函数的调用，我们需要来考察一下函数调栈是怎么工作的
函数调用--函数栈
夏日向日葵的专栏
08-31 1239
转载自函数调用--函数栈 函数调用大家都不陌生，调用者向被调用者传递一些参数，然后执行被调用者的代码，最后被调用者向调用者返回结果。还有大家比较熟悉的一句话，就是函数调用是在栈上发生的，那么在计算机内部到底是如何实现的呢？   对于程序，编译器会对其分配一段内存，在逻辑上可以分为代码段，数据段，堆，栈： 代码段：保存程序文本，指令指针EIP就是指向代码段，可读可执行不可写数据段
函数调用堆栈
ZzZzZeEnNgG的博客
10-27 428
一个函数的运行在栈上开辟内存。 在函数调用时，第一个进栈的是主函数调用语句的下一条可执行语句的地址，然后是函数的各个参数。在大多编译器中，参数是由右往左入栈的，然后再是函数中的局部变量。 下面给一个实例：int sum(int a,int b) { int tmp = 0; tmp = a+b; return tmp; }int main() { int a = 1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值