c++ - gcc x86 Windows 堆栈对齐

Question

我在编写编译器的过程中纯粹是为了学习经验。我目前正在通过编译简单的 C++ 代码来学习堆栈帧，然后研究 gcc 4.9.2 为 Windows x86 生成的输出 asm。

我的简单c++代码是

#include <iostream>

using namespace std;

int globalVar;

void testStackStuff(void);
void testPassingOneInt32(int v);
void forceStackFrameCreation(int v);

int main()
{
  globalVar = 0;

  testStackStuff();

  std::cout << globalVar << std::endl;
}

void testStackStuff(void)
{
  testPassingOneInt32(666);
}

void testPassingOneInt32(int v)
{
  globalVar = globalVar + v;

  forceStackFrameCreation(v);
}

void forceStackFrameCreation(int v)
{
  globalVar = globalVar + v;
}

好的，当使用 -mpreferred-stack-boundary=4 编译时，我期望看到一个堆栈对齐到 16 字节(技术上它对齐到 16 字节但有额外的 16 字节未使用堆栈空间)。 gcc 生成的 main 的序言是:

22                      .loc 1 12 0
23                      .cfi_startproc
24 0000 8D4C2404        lea ecx, [esp+4]
25                      .cfi_def_cfa 1, 0
26 0004 83E4F0          and esp, -16
27 0007 FF71FC          push    DWORD PTR [ecx-4]
28 000a 55              push    ebp
29                      .cfi_escape 0x10,0x5,0x2,0x75,0
30 000b 89E5            mov ebp, esp
31 000d 51              push    ecx
32                      .cfi_escape 0xf,0x3,0x75,0x7c,0x6
33 000e 83EC14          sub esp, 20
34                      .loc 1 12 0
35 0011 E8000000        call    ___main
35      00
36                      .loc 1 13 0
37 0016 C7050000        mov DWORD PTR _globalVar, 0
38                      .loc 1 15 0
39 0020 E8330000        call    __Z14testStackStuffv

第 26 行向下舍入到最近的 16 字节边界。

第 27、28 和 31 行将总共 12 个字节压入堆栈，然后

第 33 行从 esp 中减去另外 20 个字节，总共 32 个字节!

为什么？

第 39 行然后调用 testStackStuff。

注意 - 此调用推送返回地址(4 字节)。

现在，让我们看一下 testStackStuff 的序言，请记住堆栈现在距离下一个 16 字节边界更近 4 个字节。

67 0058 55              push    ebp
68                      .cfi_def_cfa_offset 8
69                      .cfi_offset 5, -8
70 0059 89E5            mov ebp, esp
71                      .cfi_def_cfa_register 5
72 005b 83EC18          sub esp, 24
73                      .loc 1 22 0
74 005e C704249A        mov DWORD PTR [esp], 666

第 67 行将另外 4 个字节压入(现在向边界压入 8 个字节)。

第 72 行减去另外 24 个字节(总共 32 个字节)。

此时堆栈在 16 字节边界上正确对齐。但为什么是 2 的倍数？

如果我将编译器标志更改为 -mpreferred-stack-boundary=5 我希望堆栈对齐到 32 字节，但 gcc 似乎再次生成对齐到 64 字节的堆栈帧，是我预期的两倍。

主要序言

23                      .cfi_startproc
24 0000 8D4C2404        lea ecx, [esp+4]
25                      .cfi_def_cfa 1, 0
26 0004 83E4E0          and esp, -32
27 0007 FF71FC          push    DWORD PTR [ecx-4]
28 000a 55              push    ebp
29                      .cfi_escape 0x10,0x5,0x2,0x75,0
30 000b 89E5            mov ebp, esp
31 000d 51              push    ecx
32                      .cfi_escape 0xf,0x3,0x75,0x7c,0x6
33 000e 83EC34          sub esp, 52
34                      .loc 1 12 0
35 0011 E8000000        call    ___main
35      00
36                      .loc 1 13 0
37 0016 C7050000        mov DWORD PTR _globalVar, 0
37      00000000 
37      0000
38                      .loc 1 15 0
39 0020 E8330000        call    __Z14testStackStuffv

第 26 行将 esp 舍入到最近的 32 字节边界

第 27、28 和 31 行将总共 12 个字节压入堆栈，然后

第 33 行从 esp 中减去另外 52 个字节，总共得到 64 个字节!

testStackStuff 的序幕是

66                      .cfi_startproc
67 0058 55              push    ebp
68                      .cfi_def_cfa_offset 8
69                      .cfi_offset 5, -8
70 0059 89E5            mov ebp, esp
71                      .cfi_def_cfa_register 5
72 005b 83EC38          sub esp, 56
73                      .loc 1 22 0

(堆栈上的 4 个字节来自)调用 __Z14testStackStuffv

(堆栈上的 4 个字节来自)push ebp

(堆栈上的 56 个字节来自)sub esp,56

总共 64 个字节。

有人知道为什么 gcc 会创建这个额外的堆栈空间，还是我忽略了一些明显的东西？

感谢您提供的任何帮助。

Answer 1

为了解开这个谜团，您需要查看 gcc 的文档以找出它使用的Application Binary Interface (ABI) 的确切风格，然后找到规范ABI 并阅读它。如果您“在编写编译器的过程中纯粹是为了学习经验”，那么您肯定需要它。

简而言之，从广义上讲，正在发生的事情是 ABI 要求当前函数保留这个额外空间，以便将参数传递给当前函数调用的函数。保留多少空间的决定主要取决于函数打算执行的参数传递量，但它比这更细微，ABI 是对其进行详细解释的文档

在堆栈框架的旧样式中，我们会 PUSH参数入栈，然后调用函数。

在新风格的堆栈框架中，EBP 不再使用，(不知道为什么它被保留并从 ESP 复制，)参数被放置在堆栈中相对于 ESP 的特定偏移量处，然后调用该函数。 mov DWORD PTR [esp], 666 事实证明了这一点用于将 666 参数传递给调用 testPassingOneInt32(666); .