[APFloat] Remove dead store in the move constructor of IEEEFloat

[vgao]

Summary

In the move constructor, field semantics is first set to &semBogus, which is a static constant.
It is then set to rhs.semantics, killing the first store. This dead store is not removed in -O3.

freeSignificand() is called between the two stores, and it does read from the field semantics. However with semantics set to &semBogus, this operation always evaluates to nothing.

This diff adds a helper function (moveFields) that copies the fields without calling freeSignificand().
By doing this we save a store (and potentially a call to freeSignicand()) in IEEEFloat(IEEEFloat &&), and do not lose any performance in operator =(IEEEFloat &&), since moveFields is inlined in both callsites.

include/llvm/ADT/APFloat.h

private:
   void initFromQuadrupleAPInt(const APInt &api);
   void initFromF80LongDoubleAPInt(const APInt &api);
   void initFromPPCDoubleDoubleAPInt(const APInt &api);
 
   void assign(const IEEEFloat &);
   void copySignificand(const IEEEFloat &);
   void freeSignificand();
 
+  void moveFields(IEEEFloat &&);
+
   /// Note: this must be the first data member.
   /// The semantics that this value obeys.
   const fltSemantics *semantics;
 
   /// A binary fraction with an explicit integer bit.
   ///
   /// The significand must be at least one bit wider than the target precision.
   union Significand {

lib/Support/APFloat.cpp

if (semantics != rhs.semantics) {
       initialize(rhs.semantics);
     }
     assign(rhs);
   }
 
   return *this;
 }
 
-IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
-  freeSignificand();
-
+void IEEEFloat::moveFields(IEEEFloat &&rhs) {
   semantics = rhs.semantics;
   significand = rhs.significand;
   exponent = rhs.exponent;
   category = rhs.category;
   sign = rhs.sign;
 
   rhs.semantics = &semBogus;
+}
+
+IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
+  freeSignificand();
+  moveFields(std::move(rhs));
   return *this;
 }
 
 bool IEEEFloat::isDenormal() const {
   return isFiniteNonZero() && (exponent == semantics->minExponent) &&
          (APInt::tcExtractBit(significandParts(),
                               semantics->precision - 1) == 0);
 }

 IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag)
     : IEEEFloat(ourSemantics) {}
 
 IEEEFloat::IEEEFloat(const IEEEFloat &rhs) {
   initialize(rhs.semantics);
   assign(rhs);
 }
 
-IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
-  *this = std::move(rhs);
-}
+IEEEFloat::IEEEFloat(IEEEFloat &&rhs) { moveFields(std::move(rhs)); }
 
 IEEEFloat::~IEEEFloat() { freeSignificand(); }
 
 unsigned int IEEEFloat::partCount() const {
   return partCountForBits(semantics->precision + 1);
 }
 
 const IEEEFloat::integerPart *IEEEFloat::significandParts() const {