Le ctor de copie explicitement par défaut génère un meilleur code que l'équivalent écrit à la main

Je vois une différence dans le code généré selon que je par défaut explicitement le constructeur de copie ou que j'écris à la main la même chose. C'est une classe simple qui ne contient qu'un int et définit des opérateurs arithmétiques dessus.

Clang et g ++ gèrent cette situation de manière similaire, donc je me suis demandé s'il existe une exigence de langage sous-jacente pour cela, et si oui, que fait-il? Recherche de citations dans la norme si possible. :)

Pour montrer cela en action, j'ai écrit la fonction average () de deux manières, fonctionnant sur des entiers bruts et également sur des supports . Je m'attendais à ce que les deux génèrent le même code. Voici la sortie:

Constructeur de copie par défaut explicite:

average(Holder, Holder):
  add esi, edi
  mov eax, esi
  shr eax, 31
  add eax, esi
  sar eax
  ret
average(int, int):
  add esi, edi
  mov eax, esi
  shr eax, 31
  add eax, esi
  sar eax
  ret

Il est le même! Génial, non? La question se pose lorsque j'oublie de "par défaut" l'implémentation et que j'écris simplement la version à la main. Jusqu'à présent, j'avais l'impression que cela devrait avoir le même code résultant que le code par défaut, mais ce n'est pas le cas.

constructeur de copie manuscrite

average(Holder, Holder):
  mov edx, DWORD PTR [rdx]
  mov ecx, DWORD PTR [rsi]
  mov rax, rdi
  add ecx, edx
  mov edx, ecx
  shr edx, 31
  add edx, ecx
  sar edx
  mov DWORD PTR [rdi], edx
  ret
average(int, int):
  add esi, edi
  mov eax, esi
  shr eax, 31
  add eax, esi
  sar eax
  ret

J'essaie de comprendre la raison de cela, et les citations pertinentes de la norme sont les plus appréciées.

Voici le code

#define EXPLICITLY_DEFAULTED_COPY_CTOR true

class Holder {
public:

#if EXPLICITLY_DEFAULTED_COPY_CTOR
    Holder(Holder const & other) = default;
#else
    Holder(Holder const & other) noexcept : value{other.value} { }
#endif 
    constexpr explicit Holder(int value) noexcept : value{value} {}

    Holder& operator+=(Holder rhs) { value += rhs.value; return *this; } 
    Holder& operator/=(Holder rhs) { value /= rhs.value; return *this; } 
    friend Holder operator+(Holder lhs, Holder rhs) { return lhs += rhs; }
    friend Holder operator/(Holder lhs, Holder rhs) { return lhs /= rhs; }    

private:
    int value;
};

Holder average(Holder lhs, Holder rhs) {
    return (lhs + rhs) / Holder{2};
}

int average(int lhs, int rhs) {
    return (lhs + rhs) / int{2};
}

Si cela est attendu, puis-je faire quelque chose à l'implémentation manuscrite qui lui permettra de générer le même code que la version par défaut? Je pensais que noexcept pourrait aider, mais ce n'est pas le cas.

Notes: Si j'ajoute un constructeur de déplacement, le même problème persiste, sauf que cette différence se produit avec lui au lieu du constructeur de copie. C'est la raison sous-jacente que je cherche, pas seulement des solutions de contournement. Je ne suis pas intéressé par une revue de code ou des commentaires sur le style qui ne sont pas directement pertinents pour répondre aux raisons pour lesquelles la génération de code est différente, car cela est fortement minimisé pour montrer le problème que je pose.

Voyez-le en direct sur Godbolt: https://godbolt.org/g/YA5Zsq