编译器和操作系统如何在程序中分配变量或数据的内存

Question

想要了解有关如何准确分配变量内存的一些事情。

在 C 编程中，考虑分配在堆栈部分的“自动”变量的上下文，我有以下问题：

编译器是否为变量生成逻辑地址？ 如果是，那么如何？ 编译器不需要操作系统权限来生成或分配这样的地址吗？ 如果不是，那么编译器在代码段中是否有某种指示或指令，要求操作系统在运行可执行文件时分配内存？

现在考虑堆分配变量的上下文，

所有程序的堆大小是否相同？ 如果不是，那么可执行文件是否包含标头或告诉操作系统动态分配需要多少堆空间的内容？

如果有人提供答案或分享任何相关内容/链接来解释这一点，我将不胜感激。

Answer 1

堆栈（大多数实现使用堆栈来自动存储持续时间对象）和静态存储持续时间对象内存在程序加载和启动期间分配。

编译器是否为变量生成逻辑地址？ 如果是，那么如何？

我不知道什么是“逻辑地址” ，但编译器确实“计算”了对自动存储持续时间对象的引用。 如何？ 编译器只需知道自动存储持续时间对象位于堆栈指针地址多远（偏移量）。

通常这同样适用于静态持续时间对象和代码，编译器仅计算其部分的偏移量。

所有程序的堆大小是否相同？

它是实现定义的。

Answer 2

操作系统中通常使用的一种方法是，当程序启动时，有一个软件（或集合）用于加载该程序。 程序加载器读取可执行文件并为程序设置内存。

可执行文件的一部分说明应该为其分配什么大小的堆栈。 大多数情况下，这是在链接程序时默认设置的。 （macOS 为 8 MiB，Linux 为 2 MiB，Windows 为 1 MiB。）但是，可以通过要求链接器设置不同的大小来更改它。

程序加载器调用操作系统例程来请求映射虚拟内存。 它为堆栈和程序的其他部分执行此操作，例如代码段（主要包含程序可执行指令的内存部分）以及已初始化和未初始化的数据。 当它启动程序时，它通过将该地址放入指定的寄存器（或类似方式）告诉程序堆栈从哪里开始。

处理器寄存器之一用作堆栈指针； 它指向为当前堆栈顶部的堆栈分配的内存中的地址。 当编译器安排为对象使用堆栈空间时，它会生成调整堆栈指针的指令。 对象的地址是相对于堆栈指针计算的。 如果函数需要 128 字节的数据，编译器会生成一条指令，从堆栈指针中减去 128。 （这可能在多个步骤中发生，例如对堆栈指针进行一些更改的“调用”和“推送”指令以及完成更改的附加“减法”指令。）然后是此堆栈帧中所有对象的地址计算为与堆栈指针值的偏移量。 例如，通过获取堆栈指针并加上 40，我们计算出已分配的对象的地址比堆栈顶部高 40 个字节。

（这里的方向用语有些混乱，因为堆栈通常从高地址增长到低地址。程序加载器可能会从地址 123000000 _{16<\/sub>到 124000000 16<\/sub>分配一些内存。堆栈指针将从 124000000 16<\/sub>开始. 减去 128 将得到 123FFFF80 16<\/sub> 。 那么 123FFFFA8 16<\/sub>是一个地址空间中比 123FFFF80 16<\/sub> “高” 40 个字节的地址，但“栈顶”低于该地址。这是因为术语“栈顶” ”指的是物理堆叠事物的模型，最新的事物在最上面。）}

所谓的“堆”并不是所有程序的大小都一样。 在典型实现中，内存管理例程调用系统例程以在需要时请求更多虚拟内存。

请注意，“堆”是通用数据结构<\/a>的正确词。 堆可用于组织可用内存以外的东西，并且内存管理例程使用堆以外的数据结构来跟踪可用内存。 当提到通过内存管理例程分配的内存时，您可以将其称为“动态分配的内存”。 它也可以缩写为“分配的内存”，但在某些情况下可能会造成混淆，因为所有为某些用途保留的内存都是分配的内存。

Answer 3

先介绍一下背景<\/strong>

在 C 编程中，获取在堆栈部分分配的“自动”变量的上下文......

要理解我的回答，您首先需要知道堆栈是如何工作的。

假设您编写以下函数：

不幸的是，您不使用 C 作为编程语言，而是使用一种既不支持局部变量也不支持返回值的编程语言。  （这是大多数 CPU 在内部工作的方式。）
您可以从全局变量中的函数返回一个值：
如果您使用全局变量而不是本地变量，您的程序现在可能看起来如下：
不幸的是，三个函数之一（例如function3()<\/code> ）可能会调用myFunction()<\/code> （因此该函数被递归调用）并且在调用function3()<\/code>时变量a<\/code>被覆盖。
为了解决这个问题，您可以为局部变量（ myvars[]<\/code> ）和一个名为mypos<\/code>的变量定义一个数组。 在示例中，使用了myvars[]<\/code>中的元素0...mypos<\/code> ； 元素(mypos+1)...(MAX_LOCALS-1)<\/code>是免费的：
通过将mypos<\/code>的值从 10 更改为 11（作为示例），您的程序表明元素mypos[11]<\/code>现在正在使用中，并且被调用的函数应将其数据存储在元素mypos[x]<\/code>中，其中x>=12<\/code> .
这正是堆栈的工作方式。
通常，“变量” mypos<\/code>不是变量，而是一个名为“堆栈指针”的 CPU 寄存器。  （但是，有一些历史上的 CPU 使用了普通变量！）
实际答案<\/strong>

                                  
          

                                   
           
编译器是否为变量生成逻辑地址？
           
           

                                   
           
在上面的示例中，如果有 3 个局部变量，编译器将执行mypos+=3<\/code> 。 假设它们被命名为a<\/code> 、 b<\/code>和c<\/code> 。
           

                                   
           
编译器只需将a<\/code> myvars[mypos-2]<\/code> ，将b<\/code>替换为myvars[mypos-1]<\/code> ，将c<\/code>替换为myvars[mypos]<\/code> 。
           

                                   
           
在大多数 CPU 上，堆栈指针（在示例中名为mypos<\/code> ）不是数组的索引，而是已经是一个指针（类似于int * mypos;<\/code> ），因此编译器会将 a 替换a<\/code> *(mypos-2)<\/code>而不是myvars[mypos-2]<\/code>在示例中。
           

                                   
           
对于全局变量，编译器只计算所有全局变量所需的字节数。 在最简单<\/strong>的情况下，它会选择一个相同大小的内存范围（例如0x10000...0x10123<\/code> ）并将变量放在那里。
           

                                   
           
 
            
编译器不需要操作系统权限来生成或分配这样的地址吗？
            
            
 
            
不。
            
 
            
 “堆栈”（在示例中为数组myvars[]<\/code> ）已由操作系统提供，并且堆栈指针（示例中为mypos<\/code> ）也在程序启动之前由操作系统设置为正确的值。
            
 
            
您的程序知道可以使用带有x>mypos<\/code>的元素myvars[x]<\/code> 。
            
 
            
对于全局变量，有关全局变量使用范围的信息（例如0x10000...0x10123<\/code> ）存储在可执行文件中。 操作系统必须确保程序可以使用此内存范围。  （例如，通过相应地配置MMU<\/a> 。）
            
 
            
如果这是不可能的，操作系统将简单地拒绝启动程序并显示错误消息。
            
 
            
 
             
 ...在运行可执行文件时要求操作系统分配内存？
             
             
 
             
对于堆栈上的变量：
             
 
             
可能存在执行此操作的操作系统。
             
 
             
但是，在大多数情况下，如果需要太多堆栈，程序将简单地因“堆栈溢出”而崩溃。 在示例中，这意味着：如果访问带有x>=MAX_LOCALS<\/code>的元素myvars[x]<\/code> ，程序将崩溃。
             
 
             
 
              
现在考虑堆分配变量的上下文......
              
              
 
              
请首先注意全局变量不存储在堆上。
              
 
              
堆用于使用malloc()<\/code>和类似函数（例如 C++ 中的new<\/code>函数）分配的数据。
              
 
              
在许多操作系统下， malloc()<\/code>调用一个操作系统函数——因此实际上是操作系统在堆上分配内存。
              
 
              
 ...如果没有足够的空间，操作系统（和malloc()<\/code> ）将返回NULL<\/code> 。
              
              
 
             
 
            
 
           
                                  
          

Answer 4

编译器是否为变量生成逻辑地址？ 如果是，那么如何？

<\/blockquote>

是的，但它们与函数入口时的堆栈指针有关（通常保存为常量基指针<\/em>，存储在 cpu 寄存器中）这是因为函数可以递归，并且您可以对函数进行两次调用该变量的不同实例（并且与基指针的不同副本相关），编译器将偏移量分配给变量的基指针，但基指针可以不同，具体取决于函数入口时的堆栈内容。

编译器不需要操作系统权限来生成或分配这样的地址吗？

不，编译器只是以操作系统管理进程内存所需的格式和形式生成可执行文件。 当程序启动时，通常会给它三个（或更多）内存段：

• 文本段。 一个通常只读（或只执行）的段，不给程序写访问权限。 这通常是因为文本段在同时使用相同可执行文件的所有程序之间共享。 程序可以要求对文本进行独占读写访问（以允许程序修改自己的可执行代码），但这种情况很少发生。 这通常是指定给编译器的，编译器会在文本段中写入一个特殊标志来通知内核这个要求。<\/li>
• 数据段。 一个读写段，可以通过系统 cal ( sbrk(2)<\/code> ) 增长这用于全局变量和堆（而在现代系统中，堆被分配到通过调用mmap(2)<\/code>获取的新段中mmap(2)<\/code>系统调用。有时这个段被分成两部分。一个对常量只读的数据段（这样程序会收到一个信号，以防你试图改变一个常量的值）和一个读写段，可以自由使用由程序。这是存储全局变量的地方。<\/li>
• 堆栈段。 一个读写段，分配给进程用作堆栈段。 随着流程开始使用它，它具有向一个方向增长的能力。 当进程访问段开始下一个内存页的数据时，它会生成一个页面错误陷阱，导致将新页面附加到段，因此它的工作对进程是透明的。 这就是我们所说的记忆。<\/li>
• 该进程可以明确要求内核获取一个新段（假设它需要将某个文件映射到内存，或者如果它必须加载共享的可执行文件\/库），并且在某些系统上，只读变量（声明为const<\/code> ）显式存储在文本段或称为.rodata<\/code>的特定段中，该段要求系统提供只读的特殊数据段。 编译器通常不对这种资源本身进行编码，它通常在正在编译的程序中进行编码。<\/li><\/ul>

  完整的内存受限于系统强加的限制，所以如果你试图超过它们（大约 8Mb 的堆栈空间，默认情况下，并且取决于操作系统），你将收到系统的信号并且你的程序中止。

  如您所见，进程内存归进程所有，它可以进行任何允许的用途。 堆栈内存是读\/写的，并按需分配，您最多可以使用 8Mb，但没有规定检查您对它的使用情况。

  如果不是，那么编译器在代码段中是否有某种指示或指令，要求操作系统在运行可执行文件时分配内存？

  系统将通过它在可执行文件上的大小来知道进程文本段的大小。 数据段分为两部分，通常基于以下假设：全局初始化变量是什么，默认为零的变量是什么（出于安全原因，内核分配给进程的内存被初始化为零）所以总和添加已初始化\/数据和未初始化数据部分，以了解要分配给数据段的内存量。 堆栈段最初只分配一页内存，但随着进程开始运行并填充堆栈，它会随着进程在堆栈段的所谓下一页<\/em>上产生页面错误而增长。 如您所见，编译器无需在代码中嵌入任何指令来请求更多内存。 一切都是从可执行文件中读取的。

  编译器作为普通程序运行......它只生成所有这些信息并将其写入文件（可执行文件）中，以便内核知道运行程序所需的资源。 但是编译器与内核的通信只是要求它打开文件，在文件上写入，从源代码中读取并努力完成任务。 :)