为什么要将相同的值复制到他已经拥有的rax？

Question

可有人向我解释为什么我们在移动值rax,以rdi在主函数中@0x6f5,然后在值复制rdi到的堆栈 get_v,然后转移回rax @0x6c8？也许它是x86-64的惯例,但我不理解它的逻辑.

 main:
   0x00000000000006da <+0>:     push   rbp
   0x00000000000006db <+1>:     mov    rbp,rsp
   0x00000000000006de <+4>:     sub    rsp,0x10
   0x00000000000006e2 <+8>:     mov    rax,QWORD PTR fs:0x28
   0x00000000000006eb <+17>:    mov    QWORD PTR [rbp-0x8],rax
   0x00000000000006ef <+21>:    xor    eax,eax
   0x00000000000006f1 <+23>:    lea    rax,[rbp-0xc]
 =>0x00000000000006f5 <+27>:    mov    rdi,rax
   0x00000000000006f8 <+30>:    call   0x6c0 <get_v>
   0x00000000000006fd <+35>:    mov    eax,0x0
   0x0000000000000702 <+40>:    mov    rdx,QWORD PTR [rbp-0x8]
   0x0000000000000706 <+44>:    xor    rdx,QWORD PTR fs:0x28
   0x000000000000070f <+53>:    je     0x716 <main+60>
   0x0000000000000711 <+55>:    call   0x580
   0x0000000000000716 <+60>:    leave  
   0x0000000000000717 <+61>:    ret    

 get_v
   0x00000000000006c0 <+0>:     push   rbp
   0x00000000000006c1 <+1>:     mov    rbp,rsp
   0x00000000000006c4 <+4>:     mov    QWORD PTR [rbp-0x8],rdi
 =>0x00000000000006c8 <+8>:     mov    rax,QWORD PTR [rbp-0x8]
   0x00000000000006cc <+12>:    mov    DWORD PTR [rax],0x2
   0x00000000000006d2 <+18>:    mov    rax,QWORD PTR [rbp-0x8]
   0x00000000000006d6 <+22>:    mov    eax,DWORD PTR [rax]
   0x00000000000006d8 <+24>:    pop    rbp
   0x00000000000006d9 <+25>:    ret    

Answer 1

这是未经优化的代码.这里有很多指令是多余的,并且没什么意义,所以我不确定为什么你已经修复了特定的指示.考虑紧接其前面的说明:

xor    eax,eax
lea    rax,[rbp-0xc]

首先,RAX清除(在64位寄存器的低32位操作的指令隐式清除高位,因此xor reg32, reg32等效并略微优于xor reg64, reg64),然后RAX加载一个值.绝对没有理由先清除RAX,所以第一条指令可能完全被忽略了.

在这段代码中:

lea    rax,[rbp-0xc]
mov    rdi,rax

RAX加载,然后将其值复制到RDI.这是有道理的,如果你需要在这两个相同的数值RAX和RDI,但你不知道.该值只需要RDI为函数调用做准备.(System V AMD64调用约定传递RDI寄存器中的第一个整数参数.)所以这可能只是:

lea   rdi, [rbp-0xc]

但是,这是未经优化的代码.编译器优先考虑快速代码生成以及通过生成高效代码(生成时间更长并且更难调试)在单个(高级语言)语句上设置断点的能力.

堆栈中的周期性溢出重载get_v是未经优化的代码的另一个症状:

mov    QWORD PTR [rbp-0x8],rdi
mov    rax,QWORD PTR [rbp-0x8]

这些都不是必需的.这一切都只是繁忙的工作,一个未经优化的代码的常见电话卡.在优化的构建或手写程序集中,它可以简单地写为寄存器到寄存器的移动,例如:

mov    rax, rdi

您将看到GCC 始终遵循您在未优化的构建中观察到的模式.考虑这个功能:

void SetParam(int& a)
{
    a = 0x2;
}

使用-O0(优化禁用),GCC会发出以下信息:

SetParam(int&):
    push    rbp
    mov     rbp, rsp
    mov     QWORD PTR [rbp-8], rdi
    mov     rax, QWORD PTR [rbp-8]
    mov     DWORD PTR [rax], 2
    nop
    pop     rbp
    ret

看起来熟悉？

现在启用优化,我们得到更明智的:

SetParam(int&):
    mov     DWORD PTR [rdi], 2
    ret

这里,商店直接进入RDI寄存器中传递的地址.不需要设置或拆除堆叠框架.实际上,完全绕过了堆栈.代码不仅更简单易懂,而且速度更快.

这是一个教训:当您尝试分析编译器的对象代码输出时,始终启用优化.研究未经优化的构建在很大程度上是浪费时间,除非您实际上对编译器如何生成未优化的代码感兴趣(例如,因为您正在编写或反向编译编译器本身).否则,您关心的是优化代码,因为它更容易理解,更真实.

你的整个get_v功能可以很简单:

mov   DWORD PTR [rdi], 0x2
mov   eax, DWORD PTR [rdi]
ret

没有理由使用堆栈,来回移动值.没有理由从地址重新加载数据RBP-8,因为我们已经加载了该值RDI.

但实际上,我们可以做得更好,因为我们将常量移动到存储在RDI以下位置的地址中:

mov   DWORD PTR [rdi], 0x2
mov   eax, 0x2
ret

事实上,这正是GCC根据我的想象生成的get_v功能:

int get_v(int& a)
{
    a = 0x2;
    return a;
}

未经优化:

get_v(int&):
    push    rbp
    mov     rbp, rsp
    mov     QWORD PTR [rbp-8], rdi
    mov     rax, QWORD PTR [rbp-8]
    mov     DWORD PTR [rax], 2
    mov     rax, QWORD PTR [rbp-8]
    mov     eax, DWORD PTR [rax]
    pop     rbp
    ret

优化:

get_v(int&):
    mov     DWORD PTR [rdi], 2
    mov     eax, 2
    ret