了解 GCC 的 alloca() 对齐和看似错过的优化
Understanding GCC's alloca() alignment and seemingly missed optimization
考虑以下玩具示例，它通过 alloca() 函数在堆栈上分配内存：
#include <alloca.h>
void foo() {
volatile int *p = alloca(4);
*p = 7;
}
使用带有 -O3 的 gcc 8.2 编译上述函数会产生以下汇编代码：
foo:
pushq %rbp
movq %rsp, %rbp
subq , %rsp
leaq 15(%rsp), %rax
andq $-16, %rax
movl , (%rax)
leave
ret
老实说，我本来希望有一个更紧凑的汇编代码。
分配内存的 16 字节对齐
上面代码中的指令andq $-16, %rax导致rax包含地址[=19之间的（仅）16字节对齐地址=] 和 rsp + 15（包括两者）。
这种对齐强制是我不明白的第一件事：为什么 alloca() 将分配的内存对齐到 16 字节边界？
可能错过了优化？
无论如何，让我们考虑一下我们希望alloca()分配的内存是16字节对齐的。即便如此，在上面的汇编代码中，请记住 GCC 假定堆栈在执行函数调用时对齐到 16 字节边界（即 call foo），如果我们注意foo() 内堆栈的状态就在 推送 rbp 寄存器之后：
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!!!
我认为利用red zone（即不需要修改rsp）和rsp这一事实已经包含 16 字节对齐地址，可以使用以下代码代替：
foo:
pushq %rbp
movq %rsp, %rbp
movl , -16(%rbp)
leave
ret
寄存器 rbp 中包含的地址是 16 字节对齐的，因此 rbp - 16 也将对齐到 16 字节边界。
更好的是，可以优化新堆栈框架的创建，因为 rsp 没有被修改：
foo:
movl , -8(%rsp)
ret
这只是错过了优化还是我在这里错过了其他东西？
x86-64 System V ABI 要求 VLA（C99 可变长度数组）为 16 字节对齐，对于 >= 16 字节的自动/静态数组也是如此。
看起来 gcc 正在将 alloca 视为 VLA，并且无法将常量传播到每个函数调用仅运行一次的 alloca 中。 （或者它在内部使用 alloca 作为 VLA。）
通用alloca / VLA 不能使用红色区域，以防运行时值大于 128 字节。 GCC 还使用 RBP 创建堆栈帧，而不是保存分配大小并稍后执行 add rsp, rdx。
因此，如果大小是函数 arg 或其他运行时变量而不是常量，那么 asm 看起来就像它的样子。 这就是我得出这个结论的原因。
也是alignof(maxalign_t) == 16，但是alloca和malloc可以满足return内存可用于任何对象的要求，对于小于16字节的对象没有16字节对齐. None 标准类型的对齐要求 比它们在 x86-64 SysV 中的大小更宽。
你说的对，应该可以优化成这样：
void foo() {
alignas(16) int dummy[1];
volatile int *p = dummy; // alloca(4)
*p = 7;
}
并将其编译为 movl , -8(%rsp) ； ret 你建议了。
对于 alloca，alignas(16) 在这里可能是可选的。
如果你真的需要gcc在常量传播使arg成为alloca编译时常量时发出更好的代码，你可以简单地考虑首先使用 VLA。 GNU C++ 在 C++ 模式下支持 C99 风格的 VLA，但 ISO C++（和 MSVC）不支持。
或者可能使用 if(__builtin_constant_p(size)) { VLA version } else { alloca version }，但是 VLA 的范围意味着你不能 return 来自 if 范围的 VLA 检测到我们正在内联编译时常量 size。所以你必须复制需要指针的代码。
这是（部分）错过了 gcc 中的优化。 Clang 按预期执行。
我说的部分是因为如果你知道你将使用 gcc，你可以使用内置函数（对 gcc 和其他编译器使用条件编译以获得可移植代码）。
__builtin_alloca_with_align是你的朋友;)
这是一个示例（已更改，因此编译器不会将函数调用减少为单个 ret）：
#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();
}
反汇编代码（含objdump -d -w --insn-width=12 -M intel）
Clang 将生成以下代码 (clang -O3 test.c) - 两个函数看起来很相似
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
GCC 这个 (gcc -g -O3 -fno-stack-protector)
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
如您所见，zoo 现在看起来像预期的那样，类似于 clang 代码。
考虑以下玩具示例，它通过 alloca() 函数在堆栈上分配内存：
#include <alloca.h>
void foo() {
volatile int *p = alloca(4);
*p = 7;
}
使用带有 -O3 的 gcc 8.2 编译上述函数会产生以下汇编代码：
foo:
pushq %rbp
movq %rsp, %rbp
subq , %rsp
leaq 15(%rsp), %rax
andq $-16, %rax
movl , (%rax)
leave
ret
老实说，我本来希望有一个更紧凑的汇编代码。
分配内存的 16 字节对齐
上面代码中的指令andq $-16, %rax导致rax包含地址[=19之间的（仅）16字节对齐地址=] 和 rsp + 15（包括两者）。
这种对齐强制是我不明白的第一件事：为什么 alloca() 将分配的内存对齐到 16 字节边界？
可能错过了优化？
无论如何，让我们考虑一下我们希望alloca()分配的内存是16字节对齐的。即便如此，在上面的汇编代码中，请记住 GCC 假定堆栈在执行函数调用时对齐到 16 字节边界（即 call foo），如果我们注意foo() 内堆栈的状态就在 推送 rbp 寄存器之后：
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!!!
我认为利用red zone（即不需要修改rsp）和rsp这一事实已经包含 16 字节对齐地址，可以使用以下代码代替：
foo:
pushq %rbp
movq %rsp, %rbp
movl , -16(%rbp)
leave
ret
寄存器 rbp 中包含的地址是 16 字节对齐的，因此 rbp - 16 也将对齐到 16 字节边界。
更好的是，可以优化新堆栈框架的创建，因为 rsp 没有被修改：
foo:
movl , -8(%rsp)
ret
这只是错过了优化还是我在这里错过了其他东西？
x86-64 System V ABI 要求 VLA（C99 可变长度数组）为 16 字节对齐，对于 >= 16 字节的自动/静态数组也是如此。
看起来 gcc 正在将 alloca 视为 VLA，并且无法将常量传播到每个函数调用仅运行一次的 alloca 中。 （或者它在内部使用 alloca 作为 VLA。）
通用alloca / VLA 不能使用红色区域，以防运行时值大于 128 字节。 GCC 还使用 RBP 创建堆栈帧，而不是保存分配大小并稍后执行 add rsp, rdx。
因此，如果大小是函数 arg 或其他运行时变量而不是常量，那么 asm 看起来就像它的样子。 这就是我得出这个结论的原因。
也是alignof(maxalign_t) == 16，但是alloca和malloc可以满足return内存可用于任何对象的要求，对于小于16字节的对象没有16字节对齐. None 标准类型的对齐要求 比它们在 x86-64 SysV 中的大小更宽。
你说的对，应该可以优化成这样：
void foo() {
alignas(16) int dummy[1];
volatile int *p = dummy; // alloca(4)
*p = 7;
}
并将其编译为 movl , -8(%rsp) ； ret 你建议了。
对于 alloca，alignas(16) 在这里可能是可选的。
如果你真的需要gcc在常量传播使arg成为alloca编译时常量时发出更好的代码，你可以简单地考虑首先使用 VLA。 GNU C++ 在 C++ 模式下支持 C99 风格的 VLA，但 ISO C++（和 MSVC）不支持。
或者可能使用 if(__builtin_constant_p(size)) { VLA version } else { alloca version }，但是 VLA 的范围意味着你不能 return 来自 if 范围的 VLA 检测到我们正在内联编译时常量 size。所以你必须复制需要指针的代码。
这是（部分）错过了 gcc 中的优化。 Clang 按预期执行。
我说的部分是因为如果你知道你将使用 gcc，你可以使用内置函数（对 gcc 和其他编译器使用条件编译以获得可移植代码）。
__builtin_alloca_with_align是你的朋友;)
这是一个示例（已更改，因此编译器不会将函数调用减少为单个 ret）：
#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();
}
反汇编代码（含objdump -d -w --insn-width=12 -M intel）
Clang 将生成以下代码 (clang -O3 test.c) - 两个函数看起来很相似
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
GCC 这个 (gcc -g -O3 -fno-stack-protector)
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
如您所见，zoo 现在看起来像预期的那样，类似于 clang 代码。