x86_64 程序集中的调用约定差异

Question

所以我有一个带有 3 个参数 ASM_Method(void*, void*, int) 和 init_method(float, int*) 的汇编程序。感兴趣的是前者的 void 指针。

当我从 C++ 文件调用方法时，参数为：

float src[64];
float dest[64];
int radius[3];

init_method(1.5, radius);
ASM_Method(src, dest, 64);

这个调用过程的反汇编：

mov         r8d,100h  
lea         rdx,[rbp+0A0h]  
lea         rcx,[rbp-60h]  
call        ASM_Method 

初始化与否，程序运行良好。但是，当我这样做时：

float* src = new float[64];
float* dest = new float[64];
int radius[3];

init_method(1.5, radius);
ASM_Method(src, dest, 64);

调用时，RCX 设置的值不是正确的地址，但 RDX 是正确的。结果程序崩溃了。

这个调用过程的反汇编：

mov         r8d,100h  
mov         rdx,rbx  
mov         rcx,rdi  
call        ASM_Method

除非我将 src 初始化为某些值，否则 RCX 在调用时会更改为无效地址（在本例中为 1）。

ASM_Method 的汇编代码：

mov rax, rdx
add rax, r8
shr r8, 4
inc r8
xor r9, r9
movdqu xmm1, [rax]

MainLoop:
movdqu xmm0, [rcx + r9]
movdqu [rdx + r9], xmm0
add r9, 16
dec r8
jnz MainLoop

movdqu [rax], xmm1

ret

init_method 的汇编代码：

mulss xmm0, xmm0
mov ecx, 4
cvtsi2ss xmm1, ecx
mulss xmm0, xmm1

shr ecx, 2
cvtsi2ss xmm2, ecx
addss xmm2, xmm0
sqrtss xmm2, xmm2

stmxcsr roundFlags
or roundFlags, 2000h
ldmxcsr roundFlags

cvtss2si ecx, xmm2

stmxcsr roundFlags
and roundFlags, 0DFFFh
ldmxcsr roundFlags

mov eax, ecx
dec eax
bt ecx, 0
cmovnc ecx, eax

mov eax, 3
cvtsi2ss xmm1, eax
mulss xmm0, xmm1

cvtsi2ss xmm3, ecx
movss xmm2, xmm3
movss xmm4, xmm3

mulss xmm2, xmm2
mulss xmm2, xmm1

mov eax, 12
cvtsi2ss xmm1, eax
mulss xmm3, xmm1

mov eax, -4
cvtsi2ss xmm1, eax
mulss xmm4, xmm1
addss xmm4, xmm1

mov eax, 9
cvtsi2ss xmm1, eax

subss xmm0, xmm2
addss xmm3, xmm1
subss xmm0, xmm3
divss xmm0, xmm4

cvtss2si eax, xmm0

mov esi, ecx
add esi, 2

mov edi, ecx
cmp eax, 0
cmovle edi, esi
shr edi, 1
mov dword ptr [edx], edi

mov edi, ecx
cmp eax, 1
cmovle edi, esi
shr edi, 1
mov dword ptr [edx + 4], edi

mov edi, ecx
cmp eax, 2
cmovle edi, esi
shr edi, 1
mov dword ptr [edx + 8], edi

ret

发生了什么事？

Answer 1

我 [仍然！] 喜欢案例 2 的 完整 反汇编。但是，我会猜测一下。

(1) 编译器用一个值[正确的]填充rdi。它是src的地址[可能来自new和/或malloc]。

在 MS ABI 中，rdi 被视为“非易失性”。它必须由被调用者

保存

(2) 案例 2 然后调用init_method。但是，init_method不保留rdi [因为它必须]。它为自己的目的使用它（例如edi）。因此，在返回时，rdi 已删除！

(3) 当程序从init_method 返回时，编译器预计 rdi 将具有与步骤(1) 之后相同的值。 （即）编译器不知道init_method 损坏了rdi，因此它使用它的值来设置rcx [ASM_Method 的第一个参数]。这应该是 src 值，但实际上 whatever 值 init_method 将其设置为（即垃圾值，相对而言）

---

更新：

不同平台的 ABI 是不同的 [通常，只是编译器]。 gcc 和 clang 与 MS 有不同的调用约定（即 MS 是奇怪的鸭子或通常的嫌疑人）。例如，对于gcc/clang，rdi 持有第一个参数并且是 volatile

这是应该突出显示大多数 ABI 的 wiki 链接：https://en.wikipedia.org/wiki/X86_calling_conventions

---

更新 #2：

但是为什么在调用之前一个引用堆栈（即float src[64]）而另一个引用寄存器（new float[64]）？

因为编译器优化。为了解释，我们将“关闭”优化一下。

所有函数作用域变量在函数的堆栈帧中有一个“保留槽”。所有这些“槽”在堆栈帧中都有一个固定的偏移量，编译器知道[由][计算]。如果函数有一个堆栈帧[一些叶函数可以忽略它]，那么所有变量都有它们的槽，无论是否使用优化。保持这个想法......

当您有一个固定大小的数组（如案例 1）时，该数组的整个空间（即数据）都在框架内。因此，给定数组的地址是帧指针 + 数组的偏移量。因此，lea rcx,[rbp + offset_of_src]

标量变量也有槽。这包括诸如“指向数组的指针”之类的东西，这就是我们在案例 2 中所拥有的。

[记住，优化暂时关闭]案例 2 中缺少的部分代码类似于 [simplified]：

// allocate src
call malloc
mov [ebp + offset_of_src],rax

// allocate dest
call malloc
mov [ebp + offset_of_dest],rax

// push arguments for init_method and call it
call init_method

// call ASM_Method
mov r8d,64
mov edx,[ebp + offset_of_dest]
mov ecx,[ebp + offset_of_src]
call ASM_Method

注意，这里，我们不想“推”指针变量的地址，我们想“推”指针变量的内容。

现在，让我们重新打开优化器。仅仅因为函数变量有在堆栈帧上的一个槽并不意味着生成的代码有义务使用它。对于案例 2 中的简单函数，优化器意识到它可以使用非易失性寄存器来存储 src 和 dest 值，并且可以消除它们的堆栈访问/存储。

因此，经过优化，案例 2 看起来像：

// allocate src
call malloc
mov rdi,rax

// allocate dest
call malloc
mov rsi,rax

// push arguments for init_method and call it
call init_method

// call ASM_Method
mov r8d,64
mov edx,rsi
mov ecx,rdi
call ASM_Method

编译器选择的特定非易失性是任意的。在本例中，它们恰好是 rsi 和 rdi，但还有其他可供选择。

编译器/优化器在选择这些寄存器和其他寄存器来保存数据值方面非常聪明。它可以查看给定函数何时不再需要寄存器中的 值，并且可以重新分配它以保存另一个 [不相关的] 值（如果它选择）。

好的，还记得“保持那个想法”吗？是时候呼气了。通常，一旦为变量分配了寄存器分配，编译器就会尝试不理会它，直到不再需要它为止。但是，有时，没有足够的寄存器来同时保存所有活动变量。

例如，如果一个函数有 [比如说] 四个嵌套的 for 循环并使用 20 个不同的变量，那么就没有足够的寄存器可以使用。因此，编译器可能必须生成代码，将寄存器中的值“转储”回相应变量的堆栈帧槽。这是“寄存器溢出”。

这就是为什么堆栈帧中总是有一个用于标量的槽，即使它从未使用过[由于优化了寄存器的值]。它使编译过程更简单，并且偏移量相同。

此外，我们还讨论了 callee 保存的寄存器。但是，caller 保存的寄存器呢？虽然大多数函数在进入时推送非易失性并在退出时弹出它们（即它们为他们的调用者保留非易失性）。

一个给定的函数（例如A）可以使用一个volatile寄存器来为一个变量（例如）sludge保存一些东西（例如r10）。如果它调用另一个函数（例如B），B 可能会丢弃A 的值。

所以，如果A 希望保留r10 中的值across 调用B，A 必须保存它，调用B，然后恢复它：

mov [rbp + offset_of_sludge],r10
call B
mov r10,[rbp + offset_of_sludge]

所以，有一个可用的堆栈帧插槽很方便。

有时，函数有太多变量，以至于为其中一些生成的代码看起来像未优化的版本：

mov rax,[rbp + offset_of_foo]
add rax,rdx
sub rax,rdi
mov [rbp + offset_of_foo],rax

因为foo 访问/使用频率太低，不值得进行非易失性寄存器分配