C++:编译器如何知道为每个堆栈帧分配多少内存？

Question

在第一个答案here ，下面提到了C++中的栈内存:

When a function is called, a block is reserved on the top of the stack for local variables and some bookkeeping data.

这在顶层是完全合理的，并且让我很好奇编译器在给定 this question 的上下文中分配内存时有多聪明。 : 由于大括号本身不是 C 中的堆栈框架(我假设这也适用于 C++)，我想检查编译器是否根据单个函数中的变量范围优化保留内存。

在下文中，我假设在函数调用之前堆栈看起来像这样:

--------
|main()|
-------- <- stack pointer: space above it is used for current scope
|      |
|      |
|      |
|      |
--------

然后在调用函数 f() 之后执行以下操作:

--------
|main()|
-------- <- old stack pointer (osp)
|  f() |
-------- <- stack pointer, variables will now be placed between here and osp upon reaching their declarations
|      |
|      |
|      |
|      |
--------

例如，给定这个函数

void f() {
  int x = 0;
  int y = 5;
  int z = x + y;
}

据推测，这只会分配 3*sizeof(int) + 一些额外的簿记开销。

但是，这个函数呢:

void g() {
  for (int i = 0; i < 100000; i++) {
    int x = 0;
  }
  {
    MyObject myObject[1000];
  }
  {
    MyObject myObject[1000];
  }
}

忽略编译器优化可能会省略上面的很多东西，因为它们实际上什么都不做，我对第二个示例中的以下内容感到好奇:

• 对于 for 循环:堆栈空间是否足够大以容纳所有 100000 个整数？
• 最重要的是，堆栈空间将包含 1000*sizeof(MyObject) 还是 2000*sizeof(MyObject)？

一般来说:在调用某个函数之前，编译器在确定新堆栈框架需要多少内存时是否考虑了变量范围？如果这是特定于编译器的，一些著名的编译器是如何做到的？

Answer 1

编译器将根据需要分配空间(通常是为函数开头的所有项目分配空间)，但不会为循环中的每次迭代分配空间。

例如，Clang 产生的，如 LLVM-IR

define void @_Z1gv() #0 {
  %i = alloca i32, align 4
  %x = alloca i32, align 4
  %myObject = alloca [1000 x %class.MyObject], align 16
  %myObject1 = alloca [1000 x %class.MyObject], align 16
  store i32 0, i32* %i, align 4
  br label %1

; <label>:1:                                      ; preds = %5, %0
  %2 = load i32, i32* %i, align 4
  %3 = icmp slt i32 %2, 100000
  br i1 %3, label %4, label %8

; <label>:4:                                      ; preds = %1
  store i32 0, i32* %x, align 4
  br label %5

; <label>:5:                                      ; preds = %4
  %6 = load i32, i32* %i, align 4
  %7 = add nsw i32 %6, 1
  store i32 %7, i32* %i, align 4
  br label %1

; <label>:8:                                      ; preds = %1
  ret void
}

这是结果:

class MyObject
{
public:
    int x, y;
};

void g() {
  for (int i = 0; i < 100000; i++) 
  {
    int x = 0; 
  } 
  {
    MyObject myObject[1000]; 
  } 
  {
    MyObject myObject[1000]; 
  } 
} 

因此，如您所见，x 仅分配了一次，而不是 100000 次。因为在任何给定时间，这些变量中只有一个会存在。

(编译器可以为 x 和第二个 myObject[1000] 重用 myObject[1000] 的空间 - 并且可能会这样做所以对于优化构建，但在那种情况下它也会完全删除这些变量，因为它们没有被使用，所以它不会显示得很好)