c++ - GCC 或 Clang 能否针对调用堆栈内存占用进行优化？

Question

我注意到有时编译器会在调用堆栈中保留垃圾数据。调用栈由函数栈帧组成，是一次函数调用的激活记录。理想情况下，函数的堆栈帧应该只包含必要的数据，包括溢出的被调用者保存的寄存器、必须在嵌套函数调用中保留的局部变量、返回地址等。

考虑这样一种情况，函数 foo() 调用其他几个函数。在这些嵌套函数调用中，foo() 的激活记录大小可能会发生变化。下面是一个例子:

extern long f(long x);
extern void bar(long x);
extern void tail(void);

void foo(long x) {
    long fx = f(x); // x must be preserved across the f(x) call
                    // because x is later used again.

    bar(x + fx);    // No need to preserve anything. x and fx will
                    // no longer be used again.

    tail();         // Just to prevent tail call optimization on bar(...).
}

但是，Clang(版本 14.0.4)编译的代码并未优化其栈帧使用，如下所示。 GCC(版本 9.4.0)类似。为两者启用了优化 -O2。

foo:
    push   %rbx           // preserve %rbx
    mov    %rdi,%rbx      // %rbx <- %rdi         (%rbx preserves argument x)
    call   f              // %rax <- f(%rdi)
    add    %rax,%rbx      // %rbx <- %rax + %rbx
    mov    %rbx,%rdi      // %rdi <- %rbx         (from now on, %rbx is garbage)
                                                  (because x will never be used again)
    call   bar            // bar(%rdi)
    pop    %rbx           // restore %rbx         (this should occur earlier)
    jmp    tail           // tail()

理想情况下，当 foo() 中的参数 x 不再有用时，我们应该尽快丢弃它，这样堆栈帧内存占用量保持不变尽可能小。

foo:
    push   %rbx           // preserve %rbx
    mov    %rdi,%rbx      // %rbx <- %rdi
    call   f              // %rax <- f(%rdi)
    add    %rax,%rbx      // %rbx <- %rax + %rbx
    mov    %rbx,%rdi      // %rdi <- %rbx
    pop    %rbx           // restore %rbx         (pop out 8 bytes from stack)
                                                  (before calling bar!)
    call   bar            // bar(%rdi)
    jmp    tail           // tail()

所以这是我的问题:是否有任何编译器选项可以让我们拥有尽可能紧凑的堆栈框架？

在上面显示的情况下，编译器肯定会错过优化机会。然而，一般来说，保持堆栈框架尽可能紧凑可能会引入额外的指令来操作堆栈指针，甚至在堆栈框架内复制数据，这会在调用堆栈内存占用和运行时性能之间做出权衡。

在 RAM 非常有限的嵌入式系统中，具有较小的调用堆栈内存占用空间很有值(value)。在 PC 上，更小的内存占用可以带来更好的缓存局部性，从而可能加快执行速度。

我知道 GCC 中的 -fstack-reuse 选项。默认值为 all。将其更改为其他值只会使堆栈内存占用变得更糟。

更新 1:

Jonathan 表示担心 x 是一个参数，其分配由 foo() 的调用者管理。如果 x 改为在堆栈上传递，那么情况可能会有所不同。

所以我更新了一个更好的例子，它需要在嵌套函数调用中保留一个中间值。

extern long f(long x);
extern void bar(long x);
extern void tail(void);

void foo(long x) {
    long fx = f(x);

    bar(fx);          // fx must be preserved across this call
                      // because it will be used again later

    long ffx = f(fx); // fx used again here
                      // no need to preserve anything from now on
                      // ideally the stack frame should be
                      // set to 0 before calling f()
    bar(ffx);
    tail();
}

以及 Clang 的汇编代码(类似于 GCC)

foo:
    push   %rbx      // preserve %rbx
    call   f         // %rax <- f(%rdi)
    mov    %rax,%rbx // %rbx <- %rax      (fx is preserved in %rbx)
    mov    %rax,%rdi // %rdi <- %rax
    call   bar       // bar(%rdi)
    mov    %rbx,%rdi // %rdi <- %rbx      (use fx again here)
                     //                   (ideally should pop here)
    call   f         // %rax <- f(%rdi)                        ^
    mov    %rax,%rdi // %rdi <- %rax                           |
    call   bar       // bar(%rdi)                              |
    pop    %rbx      // restore %rbx      ---------------------+
    jmp    tail

更新 2:

不幸的是，-fconserve-stack、-fno-defer-pop 和 -foptimize-sibling-calls 对示例没有帮助以上。

Answer 1

GCC 有许多 optimization options影响堆栈使用的函数，其中包括 -fno-defer-pop、-foptimize-sibling-calls，以及几个影响内联的函数。最有可能执行您询问的特定优化类型的是 -fconserve-stack，但我不能说该选项是否真的会引发您正在寻找的特定优化。

我没有找到针对 Clang 的 -fconserve-stack 文档，但这并不一定意味着它不存在。我通常觉得 Clang 的文档相当平庸。