考虑下面的类，主要是为了基准测试而创建的：

class String {
  char* data_; 
public:
  String(const char* arg = "") : data_(new char[strlen(arg) + 1]) { strcpy(data_, arg); }
  String(const String& other) : String(other.data_) { }
  String(String&& other) noexcept : data_(other.data_) { other.data_ = nullptr; }
  String& operator=(String other) noexcept { swap(other); return *this; }  
  ~String() { delete[] data_; }
  void swap(String& rhs) noexcept { std::swap(data_, rhs.data_); }
  const char* data() const { return data_; }   
};
void swap(String& lhs, String& rhs) noexcept { lhs.swap(rhs); }

我尝试比较两个示例与自定义swap和std::swap的交换效率。对于自定义swap，GCC 8.2（-O2）生成以下x86_64程序集：

mov     rax, QWORD PTR [rdi]
mov     rdx, QWORD PTR [rsi]
mov     QWORD PTR [rdi], rdx
mov     QWORD PTR [rsi], rax
ret

这与两个指针的交换完全匹配。然而，对于std::swap，生成的程序集是：

mov     rdx, QWORD PTR [rsi]
  mov     QWORD PTR [rsi], 0    // (A)
  mov     rax, QWORD PTR [rdi]
  mov     QWORD PTR [rdi], 0    // (1)
  mov     QWORD PTR [rsi], rax  // (B)
  mov     rax, QWORD PTR [rdi]  // (2)
  mov     QWORD PTR [rdi], rdx
  test    rax, rax              // (3)
  je      .L3
  mov     rdi, rax
  jmp     operator delete[](void*) 
.L3:
  ret

我好奇的是为什么GCC会产生如此低效的代码。指令（1）将[rdi]设置为零。然后将该零加载到rax（2）。然后，rax被测试（3）是否应该调用operator delete。
如果rax保证为零，为什么GCC要测试rax？对于优化器来说，避免这种测试似乎是一个非常简单的案例。
Godbolt演示：https://godbolt.org/z/WNm2if
效率低下的另一个原因是0首先被写入[rsi]（A），然后被另一个值覆盖（B）。
底线是：我希望编译器为std::swap和自定义swap生成相同的机器码，但这并没有发生。这表明即使对于支持移动语义的类，编写自定义交换函数也是有意义的。