凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

双口ram存储器_C程序如何存储在RAM存储器中

作者：凡人多烦事01 | 2024-03-26 03:47:56

踩

c __at (ram_addr)

双口ram存储器

当您运行任何C程序时，其可执行映像都会以有组织的方式加载到计算机的RAM中，这称为C程序的进程地址空间或内存布局。在这里，我试图分两部分向您展示同一件事。

/！\：最初发布于www.vishalchovatiya.com 。

在第1部分（即“概述”）中，我们将看到逐段概述；在第2部分（即“示例”）中，我们将看到C程序如何存储在RAM存储器中？举个例子。

第1部分：概述

C程序的内存布局以下列方式组织：

文字区隔
数据段
堆段
堆栈段

注意：不仅仅是这4个部分，还有很多，但是这4个部分是了解C程序在机器级别上工作的核心。


HIGHER  ADDRESS                                                                                                        
   +------------------------+                                                                             
   |  Unmapped or reserved  | Command-line argument & Environment variables                                                                          
   |------------------------|------------------------                                                                          
   |     Stack segment      | |                                                                                                
   |           |            | | Stack frame                                                                                    
   |           v            | v                                                                                                
   |                        |                                                                                                  
   |           ^            | ^                                                                                                
   |           |            | | Dynamic memory                                                                                 
   |     Heap segment       | |                                                                                                
   |------------------------|------------------------                                                                          
   |   Uninitialized data   |                                                                                                  
   |------------------------| Data segment                                                                                     
   |    Initialized data    |                                                                                                  
   |------------------------|------------------------                                                                          
   |                        |                                                                                                  
   |      Text segment      | Executable code                                                                                  
   |                        |                                                                                                  
   +------------------------+                                                                                                  
         LOWER  ADDRESS

文字区隔

文本段包含C程序的可执行指令，也称为代码段。
这包括构成程序的所有函数（ main()也是），包括用户定义的函数和系统函数。
文本段是可共享的，因此对于不同的正在执行的程序，例如文本编辑器，shell等，仅需要一个副本在内存中。
通常，文本段是只读的，以防止程序意外修改其指令。

数据段

本部分有两个小节

1.初始化数据

它包含用非零值初始化的静态和全局数据。
该段可以进一步分为只读区域和读写区域。
例如，由char string[ ] = "hello world"定义的全局字符串以及在main （即global）之外的int count=1类的语句将存储在初始化的读写区域中。
像const int A=3这样的全局语句；使变量A只读，并存储在初始化的只读区域中。

2.未初始化的数据（BSS段）

未初始化的数据段也称为BSS（“由符号开始的块”）段。其中包含所有初始化为零或在源代码中没有显式初始化的全局变量和静态变量。
例如，声明为int A的全局变量将存储在未初始化的数据段中。诸如static int X=0类的语句也将存储在此段中，因为它初始化为零。
如果不初始化全局变量，则默认值为零。该刷新内存内容通常由程序加载器完成（即/lib/ld-linux.so.2 ）。

堆段

堆段是动态分配内存（由malloc() ， calloc() ， realloc()和C ++的new分配）驻留的区域。
当我们通过动态分配技术（即运行时内存分配）分配内存时，程序会从OS获取空间，并且进程地址空间也会增加。
我们可以释放动态分配的内存空间（通过使用free()或delete ）。释放的内存返回到堆，但不必返回到操作系统（根本不必返回），因此无序malloc / free最终会导致堆碎片。您可以在此处了解有关malloc的更多信息。
当我们使用动态分配来获取内存空间时，我们必须使用其地址来跟踪分配的内存。

堆栈段

堆栈段是存储本地变量的区域。说局部变量意味着在C程序的每个函数（包括main()中声明的所有那些变量。我在这里写了一篇关于函数堆栈框架的详细文章。
当我们调用任何函数时，将创建堆栈框架，当函数返回时，堆栈框架将被破坏/倒回，包括该特定函数的所有局部变量。
堆栈框架包含一些数据，例如返回地址，传递给它的参数，局部变量以及被调用函数所需的任何其他信息。
堆栈指针（SP）是CPU的特殊功能寄存器，通过对堆栈的下一个或上一个地址进行调整后的堆栈指针，可以通过对堆栈的每次压入和弹出操作来跟踪堆栈。
堆栈和堆的增长方向完全取决于编译器，ABI，操作系统和硬件。

第2部分：示例

我们已经举了一个简单的例子，如标题以及其内存布局所示。正如我们在上一部分（即概述）中所讨论的，程序的可执行映像如何划分为不同的段并存储在内存（RAM）中。现在，我们通过使用上面提供的示例代码来理解这些块。

装载机

加载程序不是段，而是一种程序解释器，它从二进制文件中读取不同的段并以适当的方式将其复制到RAM中。
有一个二进制实用程序命令，通过它可以以二进制形式查看加载程序的不同段和路径，如下所示：


$ readelf --segments ./a.out 
Elf file type is EXEC (Executable file)
Entry point 0x8048300
There are 9 program headers, starting at offset 52
Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR           0x000034 0x08048034 0x08048034 0x00120 0x00120 R E 0x4
  INTERP         0x000154 0x08048154 0x08048154 0x00013 0x00013 R   0x1
      [Requesting program interpreter: /lib/ld-linux.so.2]
  LOAD           0x000000 0x08048000 0x08048000 0x00608 0x00608 R E 0x1000
  LOAD           0x000f08 0x08049f08 0x08049f08 0x00118 0x00124 RW  0x1000
  DYNAMIC        0x000f14 0x08049f14 0x08049f14 0x000e8 0x000e8 RW  0x4
  NOTE           0x000168 0x08048168 0x08048168 0x00020 0x00020 R   0x4
  GNU_EH_FRAME   0x0004c4 0x080484c4 0x080484c4 0x00044 0x00044 R   0x4
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x10
  GNU_RELRO      0x000f08 0x08049f08 0x08049f08 0x000f8 0x000f8 R   0x1
 Section to Segment mapping:
  Segment Sections...
   00     
   01     .interp 
   02     .interp .note.ABI-tag .hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .plt.got .text .fini .rodata .eh_frame_hdr .eh_frame 
   03     .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss 
   04     .dynamic 
   05     .note.ABI-tag 
   06     .eh_frame_hdr 
   07     
   08     .init_array .fini_array .jcr .dynamic .got

正如我之前提到的，您不仅可以在上面看到4个段，而且还有很多段通常取决于编译器和ABI 。
在上面可以看到.data ， .bss ， .text等段。但是堆栈段未显示为在运行时创建的，而是由OS（精确地是loader和kernel）决定的。
程序头中的INTERP定义了加载器的名称和路径，该加载器将通过读取这些段将当前的二进制映像加载到RAM中。这是/lib/ld-linux.so.2.
您可以在此处阅读有关二进制文件格式ELF的更多信息。

文字区隔

编译C代码时，您将获得可执行映像（可以是.bin ， .exe ， .hex ， .out或任何扩展名等任何形式）。该可执行文件包含Binutils命令$ objdump -d <binary_name>看到的文本段，如下所示：


.....
080483f1 <main>:
 80483f1:  8d 4c 24 04            lea    0x4(%esp),%ecx
 80483f5:  83 e4 f0               and    $0xfffffff0,%esp
 80483f8:  ff 71 fc               pushl  -0x4(%ecx)
.....

这是可执行的指令，以只读段的形式存储在文本段中，并在需要时由进程共享。 CPU使用程序计数器和执行时在堆栈中创建的堆栈帧读取这些指令。程序计数器指向要执行的指令的地址，该地址位于文本段中。

数据段

初始化数据段

const int x = 1 ; 存储在只读区域中。因此，您不能意外修改它。
而字符串char str[] = "Hi!"; ＆ static int var = 0; 存储在读写区域中，因为我们没有使用像const这样的关键字，它使变量为只读。

未初始化的数据段

在我们的程序中， int i声明为global的int i会进入该存储区域，因为默认情况下它没有初始化或初始化为零。

堆段

当您编译程序时，您分配的内存空间即所有本地，静态和全局变量在编译时都是固定的。但是，当代码在运行时需要内存时，它将通过调用malloc() ， calloc()等函数来接近OS。
当OS提供动态内存进行处理时，它会缩小堆栈限制指针，该指针最初指向未初始化的数据段开始（技术术语为“程序中断”，请在此处阅读）。
结果，堆段增加了。这就是为什么堆和堆栈段之间没有界限的原因。箭头指示其方向的增长。
在示例代码中，我们使用malloc()函数分配1字节动态内存，并将其地址存储在指针ptr以跟踪该内存或对其进行访问。
这个ptr是main的局部变量，因此它位于main的堆栈框架中，但是它指向的内存在我用*ptr显示的堆中。

堆栈段

任何程序的通常起点（不是不同的入口点）是main() ，它也是一个函数，因此，在执行时会为其创建堆栈框架。尽管在这里我已经讨论了main之前调用的许多函数。
正如您在图像中看到的那样， main()堆栈框架是在函数func()嵌套之前创建的。
由于func( )执行覆盖其局部变量a，并且其堆栈帧将被破坏（在这里倒带是一个精确的词）， main()函数也是如此。
这就是堆栈增长和收缩的方式。

直观的常见问题解答

问：如何确定堆栈的生长方向？

答：简单...！通过比较两个不同函数的局部变量的地址。


int *main_ptr = NULL ;
int *func_ptr = NULL ;
void func ()  { int a; func_ptr = &a; }
int main ()
 {
    int a; main_ptr = &a;
    func();
    (main_ptr > func_ptr) ? printf ( "DOWN\n" ) : printf ( "UP\n" );
    return 0 ;
}

问：如何故意破坏堆栈？

答：损坏存储在堆栈帧中的SFR值。


void func ()
 {
    int a;
    memset (&a, 0 , 100 ); // Corrupt SFR values stored in stack frame
}
int main ()
 {
    func();
    return 0 ;
}

问：如何增加堆栈框架大小？

答： alloca（）是答案。 GOOGLE一下，或看看这个。

翻译自: https://hackernoon.com/q-how-you-can-increase-stack-frame-size-a-alloca-is-the-answer-google-about-it-or-see-this-r828332ch

双口ram存储器

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/314473