STM32芯片存储分布及堆栈

江河jh

已于 2024-08-22 21:29:29 修改

阅读量939

点赞数 12

分类专栏：存储文章标签： stm32 嵌入式硬件单片机

于 2024-08-22 20:55:20 首次发布

本文链接：https://blog.csdn.net/m0_74307146/article/details/141434105

版权

存储专栏收录该内容

7 篇文章 0 订阅

订阅专栏

STM32的程序存储器、数据存储器、寄存器和输入输出端口被组织在同一个4GB的线性地址空间内, 地址范围为0x0000 0000至0xFFFF FFFF。

STM32中的堆栈
单片机是一种集成电路芯片，集成CPU、RAM、ROM、多种I/O口和中断系统、定时器/计数器等功能。CPU中包括了各种总线电路，计算电路，逻辑电路，还有各种寄存器。

其中FLASH为ROM类型，储存的数据掉电不易失；RAM中存储的数据掉电易失。

stm32 有通用寄存器 R0‐ R15 以及一些特殊功能寄存器，其中包括了堆栈指针寄存器。
当stm32正常运行程序的时候，来了一个中断，CPU就需要将寄存器中的值压栈到RAM里，然后将数据所在的地址存放在堆栈寄存器中。
等中断处理完成退出时，再将数据出栈到之前的寄存器中，这个在C语言里是自动完成的。

存储器种类

RAM
RAM又称随机存取存储器，存储的内容可通过指令随机读写访问。RAM中的存储的数据在掉电是是会丢失，因而只能在开机运行时存储数据。其中RAM又可以分为两种，一种是Dynamic RAM(DRAM动态随机存储器),另一种是Static RAM(SRAM,静态随机存储器)。

ROM
ROM又称只读存储器，只能从里面读出数据而不能任意写入数据。ROM与RAM相比,具有价格高,容量小的缺点。但由于其具有掉电后数据可保持不变的优点，因此常用也存放一次性写入的程序和数据，比如主版的BIOS程序的芯片就是ROM存储器。

Flash Memory
由于ROM具有不易更改的特性，后面就发展了Flash Memory。Flash Memory不仅具有ROM掉电不丢失数据的特点，又可以在需要的时候对数据进行更改，不过价格比ROM要高。

不同数据的存放位置

在一个STM32程序代码中，从内存高地址到内存低地址，依次分布着栈区、堆区、全局区（静态区）、常量去、代码区，其中全局区中高地址分布着.bss段，低地址分布着.data段。

程序的内存分配

一般程序占用的内存分为以下几个部分：

1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

临时创建的局部变量存放在栈区。
函数调用时，其入口参数存放在栈区。
函数返回时，其返回值存放在栈区。
const定义的局部变量存放在栈区。

2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。它与数据结构中的堆是两回事，分配方式类似于链表。

堆区用于存放程序运行中被动态分布的内存段，可增可减。
可以有malloc等函数实现动态分布内存。
有malloc函数分布的内存，必须用free进行内存释放，否则会造成内存泄漏。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放

全局区有.bss段和.data段组成，可读可写。

bss段

未初始化的全局变量存放在.bss段。
初始化为0的全局变量和初始化为0的静态变量存放在.bss段。
.bss段不占用可执行文件空间，其内容有操作系统初始化。

data段

已经初始化的全局变量存放在.data段。
静态变量存放在.data段。
.data段占用可执行文件空间，其内容有程序初始化。
const定义的全局变量存放在.rodata段。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放

字符串存放在常量区。
常量区的内容不可以被修改。

5、程序代码区—存放函数体的二进制代码。

程序执行代码存放在代码区。
字符串常量也有可能存放在代码区。

//main.cpp
int a = 0; //全局初始化区
int a = 0; //全局初始化区
char *p1; //全局未初始化区
main() {
    int b; //栈
    char s[] = "abc"; //栈
    char *p2; //栈
    char *p3 = "123456"; //123456\0在常量区，p3在栈上。
    static int c = 0; //全局（静态）初始化区
    p1 = (char *)malloc(10);
    p2 = (char *)malloc(20);
    //分配得来得10和20字节的区域就在堆区。
    strcpy(p1, "123456"); //123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}

由前面的分析我们知道，代码区和常量区的内容是不允许被修改的，ROM（STM32就是Flash Memory）也是不允许被修改的，所以

代码区和常量区的内容编译后存储在ROM中。

栈、堆、静态区、全局区（.bss段、.data段）都是存放在RAM中。

#include <stdio.h>
 
static unsigned int val1 = 1; //val1存放在.data段
 
unsigned int val2 = 1; //初始化的全局变量存放在.data段
 
unsigned int val3 ; //未初始化的全局变量存放在.bss段
 
const unsigned int val4 = 1;  //val4存放在.rodata（只读数据段）
 
 
unsigned char Demo(unsigned int num) // num 存放在栈区
{
	char var = "123456";    // var存放在栈区，"123456"存放在常量区
	
	unsigned int num1 = 1 ; // num1存放在栈区
	
	static unsigned int num2 = 0; // num2存放在.data段
 
    const unsigned int num3 = 7;  //num3存放在栈区
 
	void *p;
	
	p = malloc(8); //p存放在堆区
	
	free(p);
 
    return 1;
}
 
void main()
{
	unsigned int num = 0 ;
	num = Demo(num); //Demo()函数的返回值存放在栈区。
}

下图为各个区域的分配

① 默认分配的ROM区域是0x8000000开始，大小是0x80000的一片区域，那么这篇区域是只读区域，不可修改，也就是存放的代码区和常量区

② 默认分配的RAM区域是0x20000000开始，大小是0x10000的一片区域，这篇区域是可读写区域，存放的是静态区、栈区和堆区。

一般而言，程序内变量在堆栈上的分配，栈是由高地址到低地址，堆是由低地址到高地址。

在STM32下，栈区的地址存储是向下增长，堆区的地址存储却是向上增长。

以STM32F103系列为例，最多有512KB的FLASH空间以及最多64KB的RAM空间，另外还包含一个512字节的用于标准USB和CAN通信的SRAM。如下图所示：

一、FLASH分段

FLASH主要是存放代码和只读数据的，细分图如下：

如上图所示，Flash又可以细分为文本段、只读数据段、数据复制段。

其中文本段包含代码和代码中的常量部分，只读数据区通常存放程序中以const关键字修饰的数据，数据复制段存放的则是程序中初始化不为0的全局变量的数据，在每次单片机复位后要对这些变量重新赋值。

二、RAM分段

RAM主要用来存储数据，如下是STM32的RAM分区：

data段：存放初始化非0的全局变量；
bss段：存放未初始化或初始化为0的全局变量；
Heap（堆）段：由程序员通过malloc/free申请和释放；
Stack（栈）段：存放局部变量和函数的入口地址；

其中栈的方向是由栈顶自上而下的，堆的方向则是自下而上的，如果RAM空间有限而且一个程序中局部变量较多或申请的堆空间过大，便会造成堆和栈冲突，并造成系统崩溃（自己暂时写的程序较小，暂时没有遇到过类似问题）。

栈，也叫堆栈，是一种先进后出，插入和删除操作都在栈顶操作的线性表。栈的作用通常是保存函数返回地址及保存局部变量。

每个函数在运行时都有自己的栈空间，局部变量越多，占空间占用越大，函数间调用越深，栈空间也越大。（所以尽量避免定义较大的局部变量和数组）

CPU将打断前的程序运行到的地址、寄存器的值保存到栈中，即保护现场；当打断执行完以后，又从栈中读取之前保存的值，即恢复现场。（RTOS任务切换的原理，保留现场之后切换PC指针指向的位置实现任务的切换）。

Keil中的Build Output窗口

C 语言上分为栈、堆、bss、data、code段；
MDK 下分为：Code、RO-data、RW-data、ZI-data 这几个段。

Code=5764：：即代码域，这通常指的是程序的机器代码大小，

它会被存储在Flash中。Flash是非易失性存储器，用于存储程序在设备断电后不会丢失的指令和数据。在大多数嵌入式系统中，程序代码（即机器指令）是预先编译好并存储在Flash中的。

RO-data=672：只读数据（Read-Only Data）通常也存储在Flash中。

这些数据被存储在 ROM 区。它包含了程序中定义的常量值，如字符串字面量和常量变量，例如 C 语言中 const 关键字定义的变量就是典型的 RO-data。由于这些数据在程序运行时不会被修改，所以它们被存储在Flash中以节省SRAM空间。

RW-data=64：可读写数据（Read-Write Data）。

通常包含了程序中定义的初始化过的全局变量和静态变量。在程序启动时，这些数据通常需要从Flash中的某个位置复制到SRAM中，因为在程序运行时，这些变量可能会被修改。因此，RW-data的初始值存储在Flash中，而运行时的工作副本则存储在SRAM中。

ZI-data=4056：零初始化数据（Zero-Initialized Data）通常也存储在SRAM中。

这部分内存区域在程序启动时会被初始化为零。它用于存储未显式初始化的全局变量和静态变量。由于这些变量在程序开始时没有明确的初始值，所以它们在SRAM中被分配空间，并在启动时自动清零。它与 RW-data 的区别是程序刚运行时这些数据初始值全都为 0，而后续运行过程与 RW-data 的性质一样，它们也常驻在 RAM 区，因而应用程序可以更改其内容。

编译后，我们可以看到存在Code、RO-data、RW-data、ZI-data四个代码段大小

其中Code是代码占用大小，RO-data是只读常量、RW-data是已初始化的可读可写变量，ZI-data是未初始化的可读可写变量。

有些时候，我们需要知道RAM和ROM的使用情况如何，那么我们就可以使用下面的公式计算。

RAM = RW-data + ZI-data
Flash=Code + RO Data + RW Data

这个是 MDK 编译之后能够得到的每个段的大小，也就能得到占用相应的FLASH和RAM的大小，但是还有两个数据段也会占用RAM，但是是在程序运行的时候，才会占用，那就是堆和栈。

在stm32的启动文件.s文件里面，就有堆栈的设置，其实这个堆栈的内存占用就是在上面RAM分配给RW-data+ZI-data之后的地址开始分配的。

堆是编译器调用动态内存分配的内存区域；

栈是程序运行的时候局部变量的地方，栈内存中存放着函数的参数值、局部变量等。所以局部变量用数组太大了都有可能造成栈溢出。

堆栈的大小在编译器编译之后是不知道的，只有运行的时候才知道，所以需要注意不要造成堆栈溢出，会出现 hardfault 问题。

关于堆(stack)和栈(heap)详细比较

申请方式

栈：
由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

堆：
需要程序员自己申请，并指明大小，在c中malloc函数，如p1 = (char *)malloc(10)，在C++中用new运算符。

申请和系统的响应

栈：
只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：
首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

申请大小的限制

栈：
在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：
堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

申请效率的比较

栈：
由系统自动分配，速度较快。但程序员是无法控制的。

堆：
是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

堆和栈中的存储内容

栈：
在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：
一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

通俗解释
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

总结起来

RAM : 堆,栈,静态区(全局区),可读写数据,零初始化数据

ROM : 代码和只读数据和可读写数据（各变量的初始值，flash里面的不支持写，保证每次复位后变量的初始值不变，需要复制到sram中去写，也就是RW_data.）

Code和RO-data通常存储在Flash中，而RW-data和ZI-data则与SRAM相关。

RW-data的初始值存储在Flash中，但在运行时，它的工作副本位于SRAM中。

ZI-data仅存在于SRAM中，用于存储未初始化的变量。

这样的内存布局有助于优化嵌入式系统的性能，同时确保程序能够正确执行。

SRAM其本身其实是不会存储数据的，这些都是在运行状态时，从flash中复制加载过去的，但编译器会提前更具你的SRAM大小判断是否存在内存溢出 .

实验

#include "delay.h"
#include "key.h"
#include "sys.h"
#include "usart.h"
#include <stdlib.h>
int k1 = 1;
int k2;
static int k3 = 2;
static int k4;


 int main(void)
 { 
  static int m1=2, m2;
  int i = 1;
  char *p;
  char str[10] = "hello";
  char *var1 = "123456";
  char *var2 = "abcdef";
  int *p1=malloc(4);
  int *p2=malloc(4); 
 	u16 t;  
	u16 len;	
	u16 times=0;
	free(p1);
  free(p2);
	delay_init();	    	 //ÑÓÊ±º¯Êý³õÊ¼»¯	  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //ÉèÖÃNVICÖÐ¶Ï·Ö×é2:2Î»ÇÀÕ¼ÓÅÏÈ¼¶£¬2Î»ÏìÓ¦ÓÅÏÈ¼¶
	uart_init(115200);	 //´®¿Ú³õÊ¼»¯Îª115200
	KEY_Init();          //³õÊ¼»¯Óë°´¼üÁ¬½ÓµÄÓ²¼þ½Ó¿Ú
	
 	while(1)
	{
			for(t=0;t<len;t++)
			{ 
				while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//µÈ´ý·¢ËÍ½áÊø
			}
			USART_RX_STA=0;
			times++;
			if(times%500==0)
			{
	      printf("Õ»Çø-±äÁ¿µØÖ·\r\n");
				printf("              i=%p\r\n", &i);
				printf("              p=%p\r\n", &p);
				printf("             str=%p\r\n", str);
        printf("\n¶ÑÇø-¶¯Ì¬ÉêÇëµØÖ·\r\n");
        printf("                 %p\r\n", p1);
        printf("                 %p\r\n", p2);
        printf("\r\n.bss¶Î");
        printf("\nÈ«¾ÖÍâ²¿ÎÞ³õÖµ k2£º%p\r\n", &k2);
        printf("¾²Ì¬Íâ²¿ÎÞ³õÖµ k4£º%p\r\n", &k4);
        printf("¾²Ì¬ÄÚ²¿ÎÞ³õÖµ m2£º%p\r\n", &m2);
        printf("\r\n.data¶Î");
        printf("\nÈ«¾ÖÍâ²¿ÓÐ³õÖµ k1£º%p\r\n", &k1);
        printf("¾²Ì¬Íâ²¿ÓÐ³õÖµ k3£º%p\r\n", &k3);
        printf("¾²Ì¬ÄÚ²¿ÓÐ³õÖµ m1£º%p\r\n", &m1);
        printf("\r\n³£Á¿Çø\n");
        printf("ÎÄ×Ö³£Á¿µØÖ·     £º%p\r\n",var1);
        printf("ÎÄ×Ö³£Á¿µØÖ·     £º%p\r\n",var2);
        printf("\r\n´úÂëÇø\n");
        printf("³ÌÐòÇøµØÖ·       £º%p\n",&main);
			}
			delay_ms(10);   
		}
	}