Ubuntu、stm32下的程序内存分配问题

最新推荐文章于 2024-05-21 12:27:01 发布

mosifan

最新推荐文章于 2024-05-21 12:27:01 发布

阅读量471

点赞数

文章标签： ubuntu stm32

本文链接：https://blog.csdn.net/mosifan/article/details/122041586

版权

文章目录

一、C程序的内存分配
二、STM32中的堆栈
三、Ubuntu，stm32开发板编程，输出信息进行验证
- 1、Ubuntu上运行
- 2、STM32(Keil)中进行验证
四、总结

一、C程序的内存分配

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

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

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

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

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

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

正常的程序在内存中通常分为程序段、数据段、堆栈三部分。
程序段里放着程序的机器码、只读数据，这个段通常是只读，对它的写操作是非法的。
数据段放的是程序中的静态数据。
堆栈是内存中的一个连续的块。一个叫堆栈指针的寄存器（SP）指向堆栈的栈顶。堆栈的底部是一个固定地址。堆栈有一个特点就是，后进先出。也就是说，后放入的数据第一个取出。它支持两个操作，PUSH和POP。PUSH是将数据放到栈的顶端，POP是将栈顶的数据取出。动态数据存放在堆栈中。

存储区图解：
在这里插入图片描述

二、STM32中的堆栈

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

通过下面的思维导图对这部分内容进行详细的介绍：
在这里插入图片描述
下面对这些区存放在哪种介质上进行讨论。

首先，我们需要明白RAM和ROM、Flash Memory的物理特性

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要高。

不同数据的存放位置
由前面的分析我们知道，代码区和常量区的内容是不允许被修改的，ROM（STM32就是Flash Memory）也是不允许被修改的，所以代码区和常量区的内容编译后存储在ROM中。

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

Keil中的Build Output窗口
C 语言上分为栈、堆、bss、data、code段；
MDK 下分为：Code、RO-data、RW-data、ZI-data 这几个段。

任意在Keil中编译一个文件

在这里插入图片描述
编译后，我们可以看到存在Code、RO-data、RW-data、ZI-data四个代码段大小
其中Code是代码占用大小，RO-data是只读常量、RW-data是已初始化的可读可写变量，ZI-data是未初始化的可读可写变量。

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

RAM = RW-data + ZI-data
ROM = Code + RO-data + RW-data
Flash=Code + RO Data + RW Data
这个是 MDK 编译之后能够得到的每个段的大小，也就能得到占用相应的FLASH和RAM的大小，但是还有两个数据段也会占用RAM，但是是在程序运行的时候，才会占用，那就是堆和栈。
在stm32的启动文件.s文件里面，就有堆栈的设置，其实这个堆栈的内存占用就是在上面RAM分配给RW-data+ZI-data之后的地址开始分配的。

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

栈是程序运行的时候局部变量的地方，所以局部变量用数组太大了都有可能造成栈溢出。

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

三、Ubuntu，stm32开发板编程，输出信息进行验证

代码：

#include <stdio.h>
#include <stdlib.h>
//定义全局变量
int init_global_a = 1;
int uninit_global_a;
static int inits_global_b = 2;
static int uninits_global_b;
void output(int a)
{
	printf("hello");
	printf("%d",a);
	printf("\n");
}

int main( )
{   
	//定义局部变量
	int a=2;
	static int inits_local_c=2, uninits_local_c;
    int init_local_d = 1;
    output(a);
    char *p;
    char str[10] = "lyy";
    //定义常量字符串
    char *var1 = "1234567890";
    char *var2 = "qwertyuiop";
    //动态分配
    int *p1=malloc(4);
    int *p2=malloc(4);
    //释放
    free(p1);
    free(p2);
    printf("栈区-变量地址\n");
    printf("                a：%p\n", &a);
    printf("                init_local_d：%p\n", &init_local_d);
    printf("                p：%p\n", &p);
    printf("              str：%p\n", str);
    printf("\n堆区-动态申请地址\n");
    printf("                   %p\n", p1);
    printf("                   %p\n", p2);
    printf("\n全局区-全局变量和静态变量\n");
    printf("\n.bss段\n");
    printf("全局外部无初值 uninit_global_a：%p\n", &uninit_global_a);
    printf("静态外部无初值 uninits_global_b：%p\n", &uninits_global_b);
    printf("静态内部无初值 uninits_local_c：%p\n", &uninits_local_c);
    printf("\n.data段\n");
    printf("全局外部有初值 init_global_a：%p\n", &init_global_a);
    printf("静态外部有初值 inits_global_b：%p\n", &inits_global_b);
    printf("静态内部有初值 inits_local_c：%p\n", &inits_local_c);
    printf("\n文字常量区\n");
    printf("文字常量地址     ：%p\n",var1);
    printf("文字常量地址     ：%p\n",var2);
    printf("\n代码区\n");
    printf("程序区地址       ：%p\n",&main);
    printf("函数地址         ：%p\n",&output);
    return 0;
}

1、Ubuntu上运行

进入Ubuntu后，打开终端
将上面的代码放入nano文本编辑器中，进行编译
在这里插入图片描述
编译运行后结果如下：

可以看出：Ubuntu在栈区和堆区的地址值都是从上到下逐渐增大的。

2、STM32(Keil)中进行验证

选择芯片 STM32F103C8T6
配置RCC
在这里插入图片描述

配置 SYS
在这里插入图片描述
配置串口 USART1

命名工程文件并设置，生成代码文件，并在 keil5 中打开。

代码添加
由于要使用 printf、 scanf 等C语言标准函数库输入输出函数，我们要进行一些配置：
点击Options for Target，勾选use MicroLIB，点击OK即可
在这里插入图片描述

① 默认分配的ROM区域是0x8000000开始，大小是0x80000的一片区域，那么这篇区域是只读区域，不可修改，也就是存放的代码区和常量区
② 默认分配的RAM区域是0x20000000开始，大小是0x10000的一片区域，这篇区域是可读写区域，存放的是静态区、栈区和堆区。

在这里插入图片描述
usart.c文件的添加
重定向printf函数代码

// 重定向函数
int fputc(int ch,FILE *f)
{
    uint8_t temp[1]={ch};
    HAL_UART_Transmit(&huart1,temp,1,2);        //UartHandle是串口的句柄
}

注意:定义重定向printf函数记得加stdio.h头文件
在这里插入图片描述
因为在编译过程中再次出现重复定义的问题，所以此处修改了函数名，如果出现同样错误可参考编译中出现的问题
main.c代码的添加
添加头文件和定义全局变量

在这里插入图片描述
添加的代码如下：

#include <stdio.h>
#include <stdlib.h>
//定义全局变量
int init_global_a = 1;
int uninit_global_a;
static int inits_global_b = 2;
static int uninits_global_b;
void output(int a)
{
	printf("hello");
	printf("%d",a);
	printf("\n");
}

将while语句修改为以下代码：

//定义局部变量
	int a=2;
	static int inits_local_c=2, uninits_local_c;
    int init_local_d = 1;
    output(a);
    char *p;
    char str[10] = "lyy";
    //定义常量字符串
    char *var1 = "1234567890";
    char *var2 = "qwertyuiop";
    //动态分配
    int *p1=malloc(4);
    int *p2=malloc(4);
    //释放
    free(p1);
    free(p2);
    printf("栈区-变量地址\n");
    printf("                a：%p\n", &a);
    printf("                init_local_d：%p\n", &init_local_d);
    printf("                p：%p\n", &p);
    printf("              str：%p\n", str);
    printf("\n堆区-动态申请地址\n");
    printf("                   %p\n", p1);
    printf("                   %p\n", p2);
    printf("\n全局区-全局变量和静态变量\n");
    printf("\n.bss段\n");
    printf("全局外部无初值 uninit_global_a：%p\n", &uninit_global_a);
    printf("静态外部无初值 uninits_global_b：%p\n", &uninits_global_b);
    printf("静态内部无初值 uninits_local_c：%p\n", &uninits_local_c);
    printf("\n.data段\n");
    printf("全局外部有初值 init_global_a：%p\n", &init_global_a);
    printf("静态外部有初值 inits_global_b：%p\n", &inits_global_b);
    printf("静态内部有初值 inits_local_c：%p\n", &inits_local_c);
    printf("\n文字常量区\n");
    printf("文字常量地址     ：%p\n",var1);
    printf("文字常量地址     ：%p\n",var2);
    printf("\n代码区\n");
    printf("程序区地址       ：%p\n",&main);
    printf("函数地址         ：%p\n",&output);

编译并烧录
在这里插入图片描述
烧录成功后，打开串口调试助手，发送数据。

可以看出：stm32的栈区的地址值是从上到下逐渐减小的，而堆区则是从上到下增长的。

四、总结

一般而言，程序内变量在堆栈上的分配，栈是由高地址到低地址，堆是由低地址到高地址。在Ubuntu下，栈区的地址存储是向上增长，堆区的地址存储也是向上增长；在STM32下，栈区的地址存储是向下增长，堆区的地址存储却是向上增长。但实际栈的地址增长方向并不一定，针对具体的函数要具体问题具体分析。

参考：
https://blog.csdn.net/qq_43279579/article/details/110308101

https://blog.csdn.net/liwei16611/article/details/88545248
https://blog.csdn.net/u011784994/article/details/53157614

mosifan

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Ubuntu、stm32下的程序内存分配问题

文章目录一、C程序的内存分配二、STM32中的堆栈三、Ubuntu，stm32开发板编程，输出信息进行验证1、Ubuntu上运行2、STM32(Keil)中进行验证四、总结一、C程序的内存分配一般程序占用的内存分为以下几个部分：1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。它与数据结构中的堆是两回事，分配方式类似于链表。3、全局区（静态区
复制链接

扫一扫