C语言运行时栈

最新推荐文章于 2022-11-05 15:55:08 发布
最新推荐文章于 2022-11-05 15:55:08 发布
阅读量614 收藏
点赞数
分类专栏： 深入理解计算机系统笔记 文章标签： C语言 汇编 调用栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36028037/article/details/103060240
版权

1.调用函数的过程

C语言中调用一个没有参数的空函数的过程为：保存%rbp的值；nop；恢复%rbp的值。

   #include <stdio.h>                                                              
                                                                                   
   void nop();                                                                     
                                                                                   
   int main()                                                                      
   {                                                                               
       nop();                                                                      
   }                                                                               
                                                                                   
  void nop()                                                                      
  {                                                                               
                                                                                  
  }

以上空代码，汇编的结果为：

0000000000000000 <main>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	b8 00 00 00 00       	mov    $0x0,%eax
   9:	e8 00 00 00 00       	callq  e <main+0xe>
   e:	b8 00 00 00 00       	mov    $0x0,%eax
  13:	5d                   	pop    %rbp
  14:	c3                   	retq   

0000000000000015 <nop>:
  15:	55                   	push   %rbp
  16:	48 89 e5             	mov    %rsp,%rbp
  19:	90                   	nop
  1a:	5d                   	pop    %rbp
  1b:	c3                   	retq

可以看到，调用nop函数时先保存了%rbp的值，将栈指针的值赋值给%rbp，nop，取出保存的值，退出；

当nop函数中有参数时：

   #include <stdio.h>                                                              
                                                                                   
   void nop(int a);                                                                     
                                                                                   
   int main()                                                                      
   {                                                                               
       nop(1);                                                                                                                                                                                
   }                                                                               
                                                                                   
   void nop(int a)                                                                 
   {                                                                               
      a++;                                                                          
   }

汇编的结果为:

0000000000000000 <main>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	bf 01 00 00 00       	mov    $0x1,%edi
   9:	b8 00 00 00 00       	mov    $0x0,%eax
   e:	e8 00 00 00 00       	callq  13 <main+0x13>
  13:	b8 00 00 00 00       	mov    $0x0,%eax
  18:	5d                   	pop    %rbp
  19:	c3                   	retq   

000000000000001a <nop>:
  1a:	55                   	push   %rbp
  1b:	48 89 e5             	mov    %rsp,%rbp
  1e:	89 7d fc             	mov    %edi,-0x4(%rbp)
  21:	83 45 fc 01          	addl   $0x1,-0x4(%rbp)
  25:	90                   	nop
  26:	5d                   	pop    %rbp
  27:	c3                   	retq

可以看到,参数通过参数寄存器%edi传递到nop函数中，并将参数保存到了栈指针 -4的空间，调用时也从这里调用，从这里我们可以看到增加参数的时候，参数保存的地址是减小的。

x86共有6个参数寄存器，也就是说，前6个参数通过寄存器传递，之后的参数直接push到栈里：


   #include <stdio.h>                                                              
                                                                                   
   void nop(int a, int b, int c, int d, int e, int f, int g, int h);               
                                                                                   
   int main()                                                                      
   {                                                                               
       nop(1, 2, 3, 4, 5, 6, 7, 8);                                                                                                                                                           
   }                                                                               
                                                                                   
  void nop(int a, int b, int c, int d, int e, int f, int g, int h)                
  {                                                                               
      a++;
      g++;
      h++;                                                                          
  }

汇编结果：

0000000000000000 <main>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	6a 08                	pushq  $0x8
   6:	6a 07                	pushq  $0x7
   8:	41 b9 06 00 00 00    	mov    $0x6,%r9d
   e:	41 b8 05 00 00 00    	mov    $0x5,%r8d
  14:	b9 04 00 00 00       	mov    $0x4,%ecx
  19:	ba 03 00 00 00       	mov    $0x3,%edx
  1e:	be 02 00 00 00       	mov    $0x2,%esi
  23:	bf 01 00 00 00       	mov    $0x1,%edi
  28:	e8 00 00 00 00       	callq  2d <main+0x2d>
  2d:	48 83 c4 10          	add    $0x10,%rsp
  31:	b8 00 00 00 00       	mov    $0x0,%eax
  36:	c9                   	leaveq 
  37:	c3                   	retq   

0000000000000038 <nop>:
  38:	55                   	push   %rbp
  39:	48 89 e5             	mov    %rsp,%rbp
  3c:	89 7d fc             	mov    %edi,-0x4(%rbp)
  3f:	89 75 f8             	mov    %esi,-0x8(%rbp)
  42:	89 55 f4             	mov    %edx,-0xc(%rbp)
  45:	89 4d f0             	mov    %ecx,-0x10(%rbp)
  48:	44 89 45 ec          	mov    %r8d,-0x14(%rbp)
  4c:	44 89 4d e8          	mov    %r9d,-0x18(%rbp)
  50:	83 45 fc 01          	addl   $0x1,-0x4(%rbp)
  54:	83 45 10 01          	addl   $0x1,0x10(%rbp)
  58:	83 45 18 01          	addl   $0x1,0x18(%rbp)
  5c:	90                   	nop
  5d:	5d                   	pop    %rbp
  5e:	c3                   	retq

可以看到前6个参数通过寄存器传递，7，8俩个参数直接push到栈里，通过调用俩个参数可以发现，先压入栈中的参数7、8在高地址，且参数8的地址比参数7更高。参数的栈排布为：

栈地址参数
188（h）
107 (g)
-41 (a)
-82 (b)
-c3 (c)
-104 (d)
-145 (e)
-186 (f)

局部变量也保存在栈中：

   #include <stdio.h>                                                              
                                                                                   
   void nop(int a, int b, int c, int d, int e, int f, int g, int h);               
                                                                                   
   int main()                                                                      
   {                                                                               
       nop(1, 2, 3, 4, 5, 6, 7, 8);                                                
   }                                                                               
                                                                                   
  void nop(int a, int b, int c, int d, int e, int f, int g, int h)                
  {                                                                               
      int var0 = 0;                                                               
      int var1 = 1;                                                               
      int var2 = 2;                                                               
      int var3 = 3;                                                               
      int var4 = 4;                                                                                                                                                                          
  }

汇编结果：

0000000000000000 <main>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	6a 08                	pushq  $0x8
   6:	6a 07                	pushq  $0x7
   8:	41 b9 06 00 00 00    	mov    $0x6,%r9d
   e:	41 b8 05 00 00 00    	mov    $0x5,%r8d
  14:	b9 04 00 00 00       	mov    $0x4,%ecx
  19:	ba 03 00 00 00       	mov    $0x3,%edx
  1e:	be 02 00 00 00       	mov    $0x2,%esi
  23:	bf 01 00 00 00       	mov    $0x1,%edi
  28:	e8 00 00 00 00       	callq  2d <main+0x2d>
  2d:	48 83 c4 10          	add    $0x10,%rsp
  31:	b8 00 00 00 00       	mov    $0x0,%eax
  36:	c9                   	leaveq 
  37:	c3                   	retq   

0000000000000038 <nop>:
  38:	55                   	push   %rbp
  39:	48 89 e5             	mov    %rsp,%rbp
  3c:	89 7d dc             	mov    %edi,-0x24(%rbp)
  3f:	89 75 d8             	mov    %esi,-0x28(%rbp)
  42:	89 55 d4             	mov    %edx,-0x2c(%rbp)
  45:	89 4d d0             	mov    %ecx,-0x30(%rbp)
  48:	44 89 45 cc          	mov    %r8d,-0x34(%rbp)
  4c:	44 89 4d c8          	mov    %r9d,-0x38(%rbp)
  50:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%rbp)
  57:	c7 45 f0 01 00 00 00 	movl   $0x1,-0x10(%rbp)
  5e:	c7 45 f4 02 00 00 00 	movl   $0x2,-0xc(%rbp)
  65:	c7 45 f8 03 00 00 00 	movl   $0x3,-0x8(%rbp)
  6c:	c7 45 fc 04 00 00 00 	movl   $0x4,-0x4(%rbp)
  73:	90                   	nop
  74:	5d                   	pop    %rbp
  75:	c3                   	retq

可以看出，局部变量越多，参数越多，最终会导致栈的地址越来越小，即栈是向低地值增长的。进入函数后调用栈的情况为：

高地址push到栈中的参数
……局部变量
低地值通过寄存器传递的参数

2. 运行时栈

经过以上的内容已经了解到了函数调用时发生了什么，结合进程整个程序的栈帧就可以得出运行时的栈帧以及堆在程序中的变化：

#include <stdio.h>                                                                                                                                                                             
#include <stdlib.h>                                                                
                                                                                   
void nop();                                                                        
                                                                                   
int main()                                                                         
{                                                                                  
    int arg = 0;                                                                   
    char *pointer = (char *)malloc(1);                                             
    printf("arg addr in main %p\n", &arg);                                         
    printf("pointer in main %p\n", pointer);                                       
    nop();                                                                         
    free(pointer);                                                                 
}                                                                                  
                                                                                   
void nop()                                                                         
{                                                                                  
    int arg = 0;                                                                   
    char *pointer = (char *)malloc(1);                                             
    printf("arg addr in nop %p\n", &arg);                                          
    printf("pointer in nop %p\n", pointer);                                       
    free(pointer);                                                                 
}

运行结果：

arg addr in main 0x7ffe491e420c
pointer in main 0x55b3d8bfa010
arg addr in nop 0x7ffe491e41dc
pointer in nop 0x55b3d8bfa440

可以看到：

低地值main pointer
……nop pointer
……未使用的空间
……nop arg
高地址main arg

由此，栈的由高地址向低地值减少，堆由低地址向高地址增加，且如果先在nop函数中malloc并且不释放然后在main中malloc，nop会获得一个更小的地址，但是栈的地址不会根据执行顺序改变，因为栈的空间在编译的时候已经分配好了。

Zoro_97
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言—栈帧详解
Hello_Sue的博客
03-11 3629
栈帧详解我们知道，栈帧又称过程活动记录，主要用于记录函数调用过程中的一些局部变量和中间数据。下面，我们用一个简单的程序的汇编过程来分析程序在内存中的存储情况。主函数的汇编过程：首先，我们都知道每一个栈帧都有其自己的栈底指针ebp和栈顶指针esp。每一个函数的每一次运行都需要在栈区中开辟出一个栈帧，可是一个CPU中的栈帧不可能无限的增加，所以，当有新的栈帧出现时，原先的栈帧的ebp和esp就被新开辟...
3.7.1 运行时栈
xiaohaopei的博客
09-04 1660
C语言过程调用机制的一个关键特性（大多数其他语言也是如此）在于使用了栈数据结构提供的后进先出的内存管理原则。在过程P调用过程Q的例子中，可以看到当Q在执行时，P以及所有在向上追溯到P的调用链中的过程，都是暂时被挂起的。当Q运行时，他只需要为局部变量分配新的存储空间，或者设置到另一个过程的调用。另一方面，当Q返回时，任何它所分配的布局变量存储空间都可以被释放。因此，程序可以用栈来管理它的过程所需要的...
C语言参数传递所使用的寄存器
天马行空
02-09 7770
探索下C语言的函数是如何传递参数的，寄存器？栈？，何时使用寄存器，使用哪些寄存器，什么时候使用栈来传递参数。这是容易疑惑的地方。 用gcc编译C程序，看看C语言是如何传递参数的。同时用到了edb调试器。使用的操作系统是linux 64位。 思路是编写一个简单的函数，具有个数不同的参数。函数没有具体的意义，纯粹是为了探索C语言的函数是如何传递参数的。 函数有1个参数 // a.c // gc...
深入了解运行时栈（C语言）
cainiaochufa2021的博客
03-23 9094
运行时栈的介绍
Java字节码执行引擎——运行时栈帧结构
LCB2018的博客
11-05 573
虚拟机的执行引擎不是直接建立在处理器、硬件、指令集和操作系统层面的，而是由自己实 现的，因此可以自行制定指令集与执行引擎的结构体系，并能够执行哪些不被硬件直接支持 的指令集格式。 在不同的虚拟机实现里面，执行引擎在执行 Java 代码的时候可能会有解释执行和编译执行 （通过即时编译器产生本地代码）两种选择，也可能两者兼备。但从外观上看起来，所有的 Java 虚拟机都是一样的：输入的是字节码文件，处理过程是字节码解析的等效过程，输出 的是执行过程。
计算机组成原理--计算机指令
轻飘飞扬
12-16 4085
编译到汇编，代码从如何变成机器码 看下面的C代码示例： #include <stdio.h> int main() { int a = 1; int b = 2; a = a + b; return 0 ; } 通过编译和汇编后生成机器码 [root@localhost ~]# gcc -g -c test.c [root@localhost ~]# ...
C语言函数调用栈(三)
02-21
示例代码如下：该程序每个函数都嵌入汇编代码，以获取各函数运行时刻EBP和ESP寄存器的值。每个函数都打印出EBP寄存器所指向内存地址处的值，以及位于其后的函数返回地址。图7给出程序的编译和运行结果。图7StackReg...
C语言函数调用栈(一)
02-02
当一个函数执行完毕时，程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现，每个用户态进程对应一个调用栈结构(callstack)。编译器使用堆栈传递函数参数、保存返回地址、临时...
C语言数据结构用栈实现表达式求值
10-26
C语言数据结构用栈实现表达式求值，全部工程代码。实现visual2010下运行
C语言与堆栈的理解
weixin_42031299的博客
04-04 3785
C语言和堆栈的联系： C语言和栈：必须要先给C语言分配一个可用的栈空间，C语言才能运行，因为C语言里的临时变量都是放在栈空间里的，没有栈C语言是无法运行的。 C语言和堆：堆空间就是我们申请的内存空间，用malloc函数申请的。C语言中当想要使用内存时就可以向堆区申请，但是使用时要注意及时释放不用的内存，以免造成内存泄漏。 堆和栈的理解：完全不同的两个概念 栈：栈是一种数据结构（先进先出），栈空间由系统管理，不需要申请和释放，C语言里的临时变量会自动放到栈里，压栈和弹栈都不需要程序员操心。 堆：堆是一种特殊的
2018年计算机考研真题及参考答案（王道）
02-26
2018年计算机考研真题及参考答案（王道）
C语言——栈
sqjddb的博客
08-10 1万+
栈的定义 栈（stack）又名堆栈，是一种限定仅在表尾进行插入和删除操作的线性表 这一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 向一个栈插入新元素又称作进栈、入栈或压栈，使之成为新的栈顶元素 从一个栈删除元素又称作出栈或退栈。 C语言实现栈 分析： 可以使用数组或者链表实现，但数组在尾上插入数据的代价比较小。完整程序如下： 头文件 #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #i
寄存器和运行时栈
七妹的博客
11-29 3179
文章目录一、寄存器二、运行时栈 一、寄存器 在LoongArch体系中，有32个通用寄存器，除了0号寄存器始终为0外，其他31个寄存器物理上没有区别。但系统人为添加了一些约定，给了它们特定的名字和使用方式。 对以上通用寄存器详细说明： $r0寄存器中存放的值永远是零，且不能改变，这个寄存器的用途主要是方便编码。 $r3寄存器存放运行时栈的栈顶地址，会一直变化。 通用寄存器有8个用于整型参数传递，寄存器名字依次是$a0～$a7(编号依次是$r4～$r11)，$a0和$a1也用于存放返回结果值；浮点寄存器也
华为网络设备CPU和内存占用率检查命令方法
随心分享
11-15 8155
描述：华为网络设备CPU和内存占用率检查命令方法 方法： display cpu display memory
过程调用与运行时栈
一只老风铃
10-01 484
过程是程序的一种抽象，以一组参数和返回值实现对一个功能的封装，过程包含的形式有：函数、方法、处理函数等 过程调用必须解决的三大机器级别问题： 控制转移：过程P调用过程Q，进入过程Q时，程序计数器设置为Q的代码起始地址，在Q执行完成返回时，需要把程序计数器设置为P调用Q位置的下一条指令地址。 参数传递：P必须为Q提供若干个参数，Q可以向Q返回一个值 内存分配与释放：被调用过程Q可能会为局部变量分配空间，而在返回前，又需要释放这些局部空间。 【运行时栈】 栈数据结构为后进先出，这与函数调..
函数运行时堆栈
ffsiwei的博客
04-18 1233
每个函数在运行时都要使用运行时堆栈（栈帧），用于存储局部变量和返回地址，下面我就以简单的求和函数来分析一下堆栈到底怎样完成的： 下面为函数的代码：#include <stdio.h> #include <stdlib.h> int add(int x, int y) { int r = 0; r = x + y; return r; } int main() { i
Java —— 运行时栈帧结构
热门推荐
凶残的程序员
01-21 2万+
代码编译的结果从本地机器码转变为字节码，是存储格式发展的一小步，却是编程语言发展的一大步。 概述栈帧（Stack Frame）是用于支持虚拟机进行方法调用和方法执行的数据结构。它是虚拟机运行时数据区中的虚拟机栈的栈元素。栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。
运行时栈帧结构
Tiffany学习的博客
01-06 198
栈帧是用于支持虚拟机进行方法调用和方法执行的数据结构 栈帧存储了方法的局部变量表，操作数栈，动态连接，方法返回地址等信息，每一个方法从调用开始直至执行完成的过程都对应着一个栈帧从入栈到出栈的过程 局部变量： 是一组变量值存储空间，用于存储方法参数和方法内部定义的局部变量 最小单位：变量槽 第二点：在初始化阶段程序员没有为类变量进行赋值也没有关系，类变量仍然具有一个确定的初始值，但局部变量...
写一个可以运行的c语言栈程序
最新发布
05-29
好的，这里提供一个可以运行的c语言栈程序，使用数组实现： ```c #include #include #define MAX_SIZE 100 // 定义栈的最大长度 typedef struct { int data[MAX_SIZE]; int top; // 栈顶指针 } Stack; Stack...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值