为什么 __stdcall 调用约定在 x64 中被忽略？

Question

我知道__cdecl和之间的区别__stdcall是什么，但我不太确定为什么__stdcall在 x64 构建中被编译器忽略。

以下代码中的函数

int __stdcall stdcallFunc(int a, int b, int c, int d, int e, int f, int g)
{
    return a + b + c + d + e + f + g;
}

int __cdecl cdeclFunc(int a, int b, int c, int d, int e, int f, int g)
{
    return a + b + c + d + e + f + g;
}

int main()
{
    stdcallFunc(1, 2, 3, 4, 5, 6, 7);
    cdeclFunc(1, 2, 3, 4, 5, 6, 7);

    return 0;
}

有足够的参数来超过可用的 CPU 寄存器。因此，某些参数必须通过堆栈传递。我不精通汇编，但我注意到 x86 和 x64 汇编之间的一些差异。

x64

main    PROC
$LN3:
        sub     rsp, 72                             ; 00000048H
        mov     DWORD PTR [rsp+48], 7
        mov     DWORD PTR [rsp+40], 6
        mov     DWORD PTR [rsp+32], 5
        mov     r9d, 4
        mov     r8d, 3
        mov     edx, 2
        mov     ecx, 1
        call    ?stdcallFunc@@YAHHHHHHHH@Z          ; stdcallFunc
        mov     DWORD PTR [rsp+48], 7
        mov     DWORD PTR [rsp+40], 6
        mov     DWORD PTR [rsp+32], 5
        mov     r9d, 4
        mov     r8d, 3
        mov     edx, 2
        mov     ecx, 1
        call    ?cdeclFunc@@YAHHHHHHHH@Z                ; cdeclFunc
        xor     eax, eax
        add     rsp, 72                             ; 00000048H
        ret     0
main    ENDP

x86

_main   PROC
        push    ebp
        mov     ebp, esp
        push    7
        push    6
        push    5
        push    4
        push    3
        push    2
        push    1
        call    ?stdcallFunc@@YGHHHHHHHH@Z          ; stdcallFunc
        push    7
        push    6
        push    5
        push    4
        push    3
        push    2
        push    1
        call    ?cdeclFunc@@YAHHHHHHHH@Z                ; cdeclFunc
        add     esp, 28                             ; 0000001cH
        xor     eax, eax
        pop     ebp
        ret     0
_main   ENDP

1. 正如预期的那样，前 4 个参数通过 x64 中的寄存器传递。
2. 其余参数以与 x86 中相同的顺序放入堆栈。
3. 与 x86 相反，在 x64 中我们不使用push指令。相反，我们在开始时保留足够的堆栈空间main并使用mov指令将参数添加到堆栈中。
4. 在 x64 中，在两个calls之后都没有发生堆栈清理，但在main.

这让我想到了我的问题：

1. 为什么 x64 使用mov而不是push? 我认为它只是更有效，并且在 x86 中不可用。
2. 为什么call在 x64 中的指令之后没有堆栈清理？
3. Microsoft__stdcall在 x64 程序集中选择忽略的原因是什么？从文档：

   在 ARM 和 x64 处理器上，编译器接受并忽略 __stdcall

这是示例代码和程序集。

Answer 1

1. 为什么 x64 使用mov而不是push? 我认为它只是更有效，并且在 x86 中不可用。

这不是原因。这两条指令也存在于 x86 汇编语言中。

您的编译器不push为 x64 代码发出指令的原因可能是因为无论如何它必须直接调整堆栈指针，以便为被调用函数创建 32 字节的“影子空间”。有关“阴影空间”的更多信息，请参阅此链接（由@NateEldredge 提供）。

用push指令分配 32 字节的“影子空间”将需要 4 条 64 位push指令，但只有一条sub指令。这就是为什么它更喜欢使用sub指令。由于它sub无论如何都使用该指令来创建 32 字节的影子空间，因此将sub指令的操作数从 32 更改为 72没有任何惩罚，这会在堆栈上分配 72 字节的内存，这足以同时传递 3 个参数堆栈（其他 4 个在 CPU 寄存器中传递）。

我不明白为什么它在堆栈上分配 72 个字节，因为根据我的计算，它只需要 56 个字节（32 个字节的“阴影空间”和 24 个字节用于传递的 3 个参数堆栈）。可能，编译器为局部变量或异常处理保留了这些额外的 16 个字节，当编译器优化处于活动状态时，这些字节可能会被优化掉。

2. 为什么在 x64 中调用指令后没有堆栈清理？

在调用指令之后有堆栈清理。这是什么线

add rsp, 72

做。

但是，出于某种原因（可能是性能提高），x64 编译器仅在调用函数结束时执行清理，而不是在每次函数调用之后执行。这意味着对于 x64 编译器，所有函数调用为其参数共享相同的堆栈空间，而对于 x86 编译器，堆栈空间在每次函数调用时分配和清理。

3. Microsoft 在 x64 程序集中选择忽略 __stdcall 的原因是什么？

关键字_stdcall和_cdecl指定 32 位调用约定。这就是它们与 64 位程序（即 x64）无关的原因。在 x64 上，只有标准调用约定和扩展__vectorcall调用约定。