64位调用约定寄存器传this,但用的指令更多,比32位效率似乎更低了.

asker160

64位调用约定，既然是用了寄存器，想来应该是效率更高才对。
但是我发现: 64位程序调用类的成员函数(例如构造函数的时候)，编译器生成的代码，又把这个寄存器的this内容放回内存，再调用函数。
这岂不是多出了用寄存器做中转这一步? 为什么不在调用时直接用到寄存器内容呢?

实验: 下面的程序，观察比较构造函数的代码生成。首先编译成32位版本:

1. struct Test
   
2. {
   
3.   int i;
   
4.   Test(){
   
5.     i=23;
   
6.   }
   
7. };
   
8. int main()
   
9. {
   
10.   Test obj1;
    
11.   return 0;
    
12. }

复制代码

$ gcc Test.cpp -g -o Test -m32
然后用gdb来调试，断点放在i=23这里,看反汇编代码:

1. (gdb) disassemble
   
2. Dump of assembler code for function Test::Test():
   
3.    0x08048484 <+0>:        push   %ebp
   
4.    0x08048485 <+1>:        mov    %esp,%ebp
   
5. => 0x08048487 <+3>:        mov    0x8(%ebp),%eax # 对象地址在%ebp+8的位置，看起来this指针是传入的参数
   
6.    0x0804848a <+6>:        movl   $0x17,(%eax)   # 把23放入对象头部
   
7.    0x08048490 <+12>:        nop
   
8.    0x08048491 <+13>:        pop    %ebp
   
9.    0x08048492 <+14>:        ret   
   
10. End of assembler dump.

复制代码

问题(1): 这个32位程序看起来效率还可以，不过，this参数似乎不是从ecx来直接访问的。我知道vc使用ecx传this参数，gcc是吗?

然后我编译64位的版本，不加-m32选项。用gdb来看反汇编

1. (gdb) disassemble
   
2. Dump of assembler code for function Test::Test():
   
3.    0x0000000000400584 <+0>:        push   %rbp
   
4.    0x0000000000400585 <+1>:        mov    %rsp,%rbp
   
5.    0x0000000000400588 <+4>:        mov    %rdi,-0x8(%rbp) #中转一次，岂不是效率更低?
   
6. => 0x000000000040058c <+8>:        mov    -0x8(%rbp),%rax #同32位版本
   
7.    0x0000000000400590 <+12>:        movl   $0x17,(%rax)
   
8.    0x0000000000400596 <+18>:        nop
   
9.    0x0000000000400597 <+19>:        pop    %rbp
   
10.    0x0000000000400598 <+20>:        retq   
    
11. End of assembler dump.

复制代码

问题(2): 显然，这次的指令更多了，岂不是说明64位版本效率反而不如32位版本?
(2.1)我知道64位函数调用前2个参数使用rdi,rsi，但是这里看起来rdi的，先放在某个内存地址，然后再调用构造函数。比32位的多了一条指令。
(2.2)而且，还多使用了一个内存位置(%rbp-来从寄存器里面取得this指针。

那看起来64位的时空效率比32位都要低啊。这是64位调用约定导致的，还是在别的场景下64位效率会更高，只是我这里的场景32位效率更高呢?
谢谢。

MMMIX

回复 1# asker160

g++ 默认是 -O0，把优化打开（-O2）再看看。