实例分析C程序运行时的内存结构

先验知识

  1. 静态变量存储在静态存储区，局部变量存储在动态存储区（栈），代码存放在代码区
  2. 寄存器，EBP指向栈底，ESP指向栈顶，EIP指向正在执行指令的下一条指令，三个寄存器中保存的都是地址，32位系统，地址为4个字节即dword
  3. 所有写在函数定义里面的语句都编译成指令（驱动CPU）

实验代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include <stdio.h>

int fun(int a, int b);

int m = 10;

int main()

{

    int i = 4;

    int j = 5;

    m = fun(i, j);

}

int fun(int a, int b)

{

    int c = 0;

    c = a + b;

    return c;

}

这段代码包含两个函数，因此可以测试函数调用，此外还包含了静态变量、局部变量、返回值等

实验测试

测试工具：VC6.0

源代码及对应的汇编如下

寄存器及内存状态如下

EBP栈顶初始值为0018FF84h，ESP初始为0018FF48h

ESP和EBP在栈中的作用

在每个函数最开始的地方有两条语句


1

2

push ebp

mov  ebp,esp

在函数返回前也有两条语句


1

2

mov esp,ebp

pop ebp

每运行一个函数就新开一段栈空间，所谓的开栈空间就是移动ebp栈底，在移动ebp之前，通过push ebp保存上一级函数的栈底，然后用ebp指向现在函数栈的栈顶，即为当前函数开辟了栈；接着给局部变量进行地址分配以及保存现场等，esp不断向低地址移动，当函数调用结束时，esp指回当前函数的栈顶(mov esp,ebp)，然后上一级函数的栈顶地址出栈保存在ebp中（pop ebp）。因此，每一个函数的栈顶上面都保存着上一级函数的栈顶地址，用于当前函数结束时能够返回上一级函数的栈，通过ebp和esp以及压栈出栈操作对栈进行维护。

逐条分析

main函数对应的汇编代码如下


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

7:    int main()

8:    {

00401020   push        ebp                        // ebp初始为0018FF84h压栈，压栈后esp = 0018FF48h - 4 = 0018FF44h

00401021   mov         ebp,esp                    // ebp保存栈顶0，ebp=esp=0018FF44h

00401023   sub         esp,48h                    // esp -= 48h开辟了一段栈空间，留待后面保存局部变量，此时esp=0018FF44h-48h=0018FEFCh

00401026   push        ebx                       

00401027   push        esi

00401028   push        edi                        // ebx、esi和edi压栈，esp = 0018FEFCh - 4*3 = 0018FEF0h

00401029   lea         edi,[ebp-48h]              // lea指令将ebp-48h作为偏移地址保存在edi中，edi=0018FEFCh，即栈中ebx的上面

0040102C   mov         ecx,12h                   

00401031   mov         eax,0CCCCCCCCh

00401036   rep stos    dword ptr [edi]            // 将eax重复保存在以edi开始的栈空间里，重复次数为ecx次，向高地址方向，共覆盖12h*4=48h个地址，即栈中保存ebx的地址以上到ebp指向的地址这一段全部填充为cch

9:        int i = 4;

00401038   mov         dword ptr [ebp-4],4        // 保存变量i

10:       int j = 5;

0040103F   mov         dword ptr [ebp-8],5        // 保存变量j

11:       m = fun(i, j);

00401046   mov         eax,dword ptr [ebp-8]      // 将j保存在eax中

00401049   push        eax                        // eax压栈, esp=0018FEF0h-4=0018FEECh

0040104A   mov         ecx,dword ptr [ebp-4]      // 将i保存在ecx中

0040104D   push        ecx                        // ecx压栈，esp=0018FEECh-4=0018FEE8h

0040104E   call        @ILT+0(_fun) (00401005)    // 以上实际上是为形参分配内存，顺序从右到左，此步进行函数跳转

00401053   add         esp,8                      // 形参的地址回收,esp=0018FEE8h+8=0018FEF0h

00401056   mov         [_m (00424a30)],eax        // 返回值存放在静态变量m中

12:       return 0;

0040105B   xor         eax,eax                    // 返回值置为0

13:   }

0040105D   pop         edi

0040105E   pop         esi

0040105F   pop         ebx

00401060   add         esp,48h

00401063   cmp         ebp,esp

00401065   call        __chkesp (004010d0)

0040106A   mov         esp,ebp

0040106C   pop         ebp

0040106D   ret

fun函数的汇编代码理解


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

15:   int fun(int a, int b)

16:   {

00401090   push        ebp

00401091   mov         ebp,esp

00401093   sub         esp,44h

00401096   push        ebx

00401097   push        esi

00401098   push        edi

00401099   lea         edi,[ebp-44h]

0040109C   mov         ecx,11h

004010A1   mov         eax,0CCCCCCCCh

004010A6   rep stos    dword ptr [edi]            // 以上理解同main函数，ebp压栈时保存的地址是0018FF44h，即main函数栈开始开始的地方，然后ebp指向当前函数栈开始的地方

17:       int c = 0;

004010A8   mov         dword ptr [ebp-4],0        // 为c分配地址，并赋值

18:       c = a + b;

004010AF   mov         eax,dword ptr [ebp+8]      // 获得第一个参数

004010B2   add         eax,dword ptr [ebp+0Ch]    // 与第二个参数求和

004010B5   mov         dword ptr [ebp-4],eax      // 结果保存在c中

19:       return c;

004010B8   mov         eax,dword ptr [ebp-4]      // 返回值存放在eax

20:   }

004010BB   pop         edi                        // 现场恢复

004010BC   pop         esi

004010BD   pop         ebx

004010BE   mov         esp,ebp                    // 当前函数栈空间回收，以后可重新分配，esp=0018FEE8h

004010C0   pop         ebp                        // ebp恢复为0018FF44h

004010C1   ret                                    // 返回，等待执行函数调用的下一条指令

调用fun函数时的内存情况

局部变量i和j保存在48h空间的开始位置（高地址），即栈底附近，如下图

在调用fun函数之前，将形参从右至左依次压栈，如下图

call fun函数时执行跳转

参考

实验代码来自国科大杨力祥老师的开源编译器源码分析课程

时间： 2024-11-04 19:50:21

实例分析C程序运行时的内存结构的相关文章

用MAT分析JAVA程序运行时的内存使用情况

Java出现OutOfMemoryError或者发现Java应用程序占用的内存很异常,那么我们一般采用下面的步骤分析:A. 把Java应用程序使用的heap dump下来B. 使用Java heap分析工具,找出内存占用超出预期的嫌疑对象C. 根据情况,分析嫌疑对象和其他对象的引用关系.D. 分析程序的源代码,找出嫌疑对象数量过多的原因.以下面的代码为例: public class TObject { int[] arr = new int[20000]; } public class Test

JVM运行时的内存结构

我们都知道,JVM的垃圾收集机制能够帮开发者自动管理内存,了解JVM运行时的内存结构是理解垃圾收集机制的前提.本文主要简单介绍JVM运行时的内存结构. [JVM运行时内存中不同的数据区域] 一.PC寄存器 做过嵌入式开发或者底层编程的朋友应该都知道PC寄存器的作用,它就相当于在程序流中的游标,指示线程当前的运行位置.但是要注意,如果虚拟机执行的是本地native方法,则PC寄存器为undefined状态. 一个线程持有一个独立的PC寄存器. 二.java栈 每一个JVM线程都会拥有一个java栈

程序运行时的内存分配情况

以下内容来自<C++编程实战宝典> 变量和函数占用的内存是系统在程序运行时为程序分配的,但并不是所有的变量和函数都被分配在同一块内存区域中.对于一个C++程序来说,系统一般采用3种方式为程序分配内存,下面将分别介绍这3种方式. (1)从静态存储区域分配 这部分内存在程序编译的时候就已经分配好,并且这块内存在程序的整个运行期间都存在.例如在函数外定义的全局变量,以及在创建时使用static修饰符的变量.在该区域存储的内容一般是全局变量,其中存储在数据段中的全局变量通常已经被初始化. (2)在栈上

c++程序运行时的内存分配《转》

C++中,内存分为5个区:堆.栈.自由存储区.全局/静态存储区和常量存储区. 1.栈:是由编译器在需要时自动分配,不需要时自动清除的变量存储区.通常存放局部变量.函数参数等. 2.堆:是由new分配的内存块,由程序员释放(编译器不管),一般一个new与一个delete对应,一个new[]与一个delete[]对应.如果程序员没有释放掉,资源将由操作系统在程序结束后自动回收 . 自由存储区:是由malloc等分配的内存块,和堆十分相似,用free来释放.(注意:堆和自由存储区其实不过是同一块区域,

[Java]程序运行时的内存分配

本文出处:<Thinking in JAVA> 寄存器这是最快的存储区,因为它位于不同于其他存储区的地方--处理器内部.但是寄存器的数量极其有限,所以寄存器根据需求进行分配.你不能直接控制,也不能在程序中感觉到寄存器存在的任何迹象(另一方面,C和C++允许你向编译器建议寄存器的分配方式). 堆栈位于通用RAM(随机访问存储器)中,但通过堆栈指针可以从处理器那里获得直接支持.堆栈指针若向下移动,则分配新的内存:若向上移动,则释放那些内存.这是一种快速有效的分配存储方法,仅次于寄存器.创建程序时,

程序编译后运行时的内存分配

原文地址不详,我的转载的来源:http://blog.sina.com.cn/s/blog_5420e0000101a0w1.html 一.编译时与运行时的内存情况 1.编译时不分配内存 编译时是不分配内存的.此时只是根据声明时的类型进行占位,到以后程序执行时分配内存才会正确.所以声明是给编译器看的,聪明的编译器能根据声明帮你识别错误. 2.运行时必分配内存 运行时程序是必须调到"内存"的.因为CPU(其中有多个寄存器)只与内存打交道的.程序在进入实际内存之前要首先分配物理内存. 3.

程序运行时三种内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的. 静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求. 栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未

获取java程序运行时内存信息

由于最近想自己动手测试一下String和StringBuffer的效率问题,需要获取程序运行时的内存占中信息,于是上网查了一下,根据查到的资料写了个程序,发现结果有问题,才发现查到的资料是错误的.所以在这里跟大家分享一下获取内存占用的正确方法 错误的方法 //程序开始时:(先调用一下垃圾回收,但是不一定立即执行) Runtime.getRuntime().gc(); long initm=Runtime.getRuntime().freeMemory(); //程序结束时: Runtime.ge

Linux下程序运行时内存状态及相应查看工具

最近在解决一个编译问题时,一直在考虑一个问题,那就是Linux下可执行程序运行时内存是什么状态,是按照什么方式分配内存并运行的.查看了一下资料,就此总结一下,众所周知,linux下内存管理是通过虚存管理的,在分配内存是并非在物理内存开辟了一段空间,而是在使用时才分配的,而且是通过段页式管理.以上比较废话,开始看看程序运行时内存会是什么状态. 在linux下内存分配是以页为单位的,而页是通过段管理,各个段之间是独立的,方便管理.linux程序运行时,可以分为以下几个内存段: 一.BSS段 (bss