理解GCC'；s alloca（）对齐和似乎错过的优化

考虑以下通过

alloca（）

函数在堆栈上分配内存的玩具示例：

#include <alloca.h>

void foo() {
    volatile int *p = alloca(4);
    *p = 7;
}

老实说，我本来希望有一个更紧凑的汇编代码

---

分配内存的16字节对齐 上述代码中的指令

和q$-16，%rax

导致

rax

包含地址

rsp

和

rsp+15

之间（仅）16字节对齐的地址

这种对齐强制是我不理解的第一件事：为什么

alloca（）

将分配的内存与16字节边界对齐

---

可能错过的优化？

无论如何，我们希望由<代码> alOrCEA（）<代码>分配的内存为16字节对齐。即便如此，在上面的汇编代码中，请记住GCC假设堆栈在执行函数调用时（即，

call foo

）与16字节边界对齐，如果我们在按下

rbp

寄存器之后注意

foo（）

内堆栈的状态：

Size          Stack          RSP mod 16      Description
-----------------------------------------------------------------------------------
        ------------------
        |       .        |
        |       .        | 
        |       .        |            
        ------------------........0          at "call foo" (stack 16-byte aligned)
8 bytes | return address |
        ------------------........8          at foo entry
8 bytes |   saved RBP    |
        ------------------........0  <-----  RSP is 16-byte aligned!!!

寄存器

rbp

中包含的地址是16字节对齐的，因此

rbp-16

也将与16字节边界对齐

更好的是，可以优化新堆栈帧的创建，因为

rsp

未被修改：

foo:
   movl    $7, -8(%rsp)
   ret

---

这只是一个遗漏的优化，还是我遗漏了其他内容？

x86-64 System V ABI要求VLA（C99可变长度数组）是16字节对齐的，对于>=16字节的自动/静态数组也是如此

看起来gcc将

alloca

视为一个VLA，并没有将其持续传播到一个

alloca

，该函数每次调用只运行一次。（或者它在内部使用

alloca

作为VLA。）

如果运行时值大于128字节，则通用

alloca

/VLA不能使用红色区域。GCC还使用RBP生成堆栈帧，而不是保存分配大小并稍后执行添加rsp、rdx的

操作

因此，asm看起来与大小是函数arg或其他运行时变量而不是常量时的情况完全相同。这就是我得出这一结论的原因


此外，
alignof（maxallign_t）==16
，但是
alloca
和
malloc
可以满足以下要求：对于小于16字节的对象，返回可用于任何对象的内存，而不需要16字节对齐。在x86-64 SysV中，没有一种标准类型的对齐要求大于其大小


您是对的，它应该能够将其优化为：

void foo() {
    alignas(16) int dummy[1];
    volatile int *p = dummy;   // alloca(4)
    *p = 7;
}

并将其编译为
movl$7，-8（%rsp）
ret
您的建议

alloca的
alignas（16）
在这里可能是可选的


如果你真的需要GCC来发射更好的代码，当常量传播使得ARG到代码> AlLoga < /Cord>编译时常量时，你可以首先考虑使用VLA。GNU C++支持C++模式下的C99风格VLAS，但ISO C++（MSVC）不支持。
或者可能使用
if（uuu内置常量_p（size））{VLA version}或者{alloca version}
，但是VLAs的作用域意味着您无法从
if
的范围返回VLA，该范围检测到我们正在使用编译时常量
size
内联。因此，您必须复制需要指针的代码。
这是gcc中（部分）遗漏的优化。叮当按预期做

我这样说的部分原因是，如果您知道您将使用gcc，那么您可以使用内置函数（对gcc和其他编译器使用条件编译以获得可移植代码）

是你的朋友；）

下面是一个示例（已更改，因此编译器不会将函数调用减少为单个ret）：

GCC这个（
GCC-g-O3-fno堆栈保护器
）

0000000000000620:
620:55推动rbp
621:48 89 e5 mov rbp，rsp
624:48 83 ec 20子rsp，0x20
628:48 8d 44 24 0f地面[rsp+0xf]
62d:48 83 e0 f0和rax，0xFFFFFFFFFFF0
631:48 89 05 e0 09 20 00 mov QWORD PTR[rip+0x2009e0]，rax#201018
638:C700 07 00 mov德沃德PTR[rax]，0x7
63e:c9离开
63f:c3 ret
0000000000000640 :
640:48 8d 44 24 fc lea rax[rsp-0x4]
645:c7 44 24 fc 07 00 mov DWORD PTR[rsp-0x4]，0x7
64d:48 89 05 c4 09 20 00 mov QWORD PTR[rip+0x2009c4]，rax#201018
654:c3 ret

正如您所看到的，zoo现在看起来像预期的，类似于叮当声代码。
在macOS上运行？macOS ABI需要16字节的堆栈对齐…@Macmade:在调用
之前，该要求适用。没有要求函数始终保持RSP16字节对齐。如果gcc必须调整RSP的任何内容，它将使其16字节对齐，但如果它只能使用红色区域作为局部变量，它将保持RSP不变（除了可能的推送/弹出）。
foo:
   movl    $7, -8(%rsp)
   ret

void foo() {
    alignas(16) int dummy[1];
    volatile int *p = dummy;   // alloca(4)
    *p = 7;
}

#include <alloca.h>

volatile int* p;

void foo() 
{
    p = alloca(4) ;
    *p = 7;
}

void zoo() 
{
    // aligment is 16 bits, not bytes
    p = __builtin_alloca_with_align(4,16) ;
    *p = 7;
}

int main()
{
  foo();
  zoo();
}

0000000000400480 <foo>:
  400480:       48 8d 44 24 f8                          lea    rax,[rsp-0x8]
  400485:       48 89 05 a4 0b 20 00                    mov    QWORD PTR [rip+0x200ba4],rax        # 601030 <p>
  40048c:       c7 44 24 f8 07 00 00 00                 mov    DWORD PTR [rsp-0x8],0x7
  400494:       c3                                      ret    

00000000004004a0 <zoo>:
  4004a0:       48 8d 44 24 fc                          lea    rax,[rsp-0x4]
  4004a5:       48 89 05 84 0b 20 00                    mov    QWORD PTR [rip+0x200b84],rax        # 601030 <p>
  4004ac:       c7 44 24 fc 07 00 00 00                 mov    DWORD PTR [rsp-0x4],0x7
  4004b4:       c3                                      ret    

0000000000000620 <foo>:
 620:   55                                      push   rbp
 621:   48 89 e5                                mov    rbp,rsp
 624:   48 83 ec 20                             sub    rsp,0x20
 628:   48 8d 44 24 0f                          lea    rax,[rsp+0xf]
 62d:   48 83 e0 f0                             and    rax,0xfffffffffffffff0
 631:   48 89 05 e0 09 20 00                    mov    QWORD PTR [rip+0x2009e0],rax        # 201018 <p>
 638:   c7 00 07 00 00 00                       mov    DWORD PTR [rax],0x7
 63e:   c9                                      leave  
 63f:   c3                                      ret    

0000000000000640 <zoo>:
 640:   48 8d 44 24 fc                          lea    rax,[rsp-0x4]
 645:   c7 44 24 fc 07 00 00 00                 mov    DWORD PTR [rsp-0x4],0x7
 64d:   48 89 05 c4 09 20 00                    mov    QWORD PTR [rip+0x2009c4],rax        # 201018 <p>
 654:   c3                                      ret