[APFloat] Fix memory bugs revealed by MSan

[timshen]

Reproduced the MSan failures and verifed the fix. I'm going to check this in to make the bot happy.

[timshen]

r285486 is also checked in to remove unnecessary function body.

llvm/include/llvm/ADT/APFloat.h

class APFloat : public APFloatBase {
 
   explicit APFloat(IEEEFloat F) : U(std::move(F)) {}
   explicit APFloat(DoubleAPFloat F) : U(std::move(F)) {}
 
 public:
   APFloat(const fltSemantics &Semantics) : U(Semantics) {}
   APFloat(const fltSemantics &Semantics, StringRef S);
   APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
+  // TODO: Remove this constructor. This isn't faster than the first one.
   APFloat(const fltSemantics &Semantics, uninitializedTag)
       : U(Semantics, uninitialized) {}
   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
   explicit APFloat(double d) : U(IEEEFloat(d)) {}
   explicit APFloat(float f) : U(IEEEFloat(f)) {}
   APFloat(const APFloat &RHS) = default;
   APFloat(APFloat &&RHS) = default;
 

llvm/lib/Support/APFloat.cpp

 }
 
 IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics) {
   initialize(&ourSemantics);
   category = fcZero;
   sign = false;
 }
 
-IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
+// Delegate to the previous constructor, because later copy constructor may
+// actually inspects category, which can't be garbage.
+IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag)
+    : IEEEFloat(ourSemantics) {
   // Allocates storage if necessary but does not initialize it.
   initialize(&ourSemantics);
 }
 
 IEEEFloat::IEEEFloat(const IEEEFloat &rhs) {
   initialize(rhs.semantics);
   assign(rhs);
 }
DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
   assert(Semantics == &PPCDoubleDouble);
   // TODO Check for First == &IEEEdouble once the transition is done.
   assert(&Floats[0].getSemantics() == &PPCDoubleDoubleImpl);
   assert(&Floats[1].getSemantics() == &IEEEdouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const DoubleAPFloat &RHS)
     : Semantics(RHS.Semantics),
-      Floats(new APFloat[2]{APFloat(RHS.Floats[0]), APFloat(RHS.Floats[1])}) {
+      Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
+                                         APFloat(RHS.Floats[1])}
+                        : nullptr) {
   assert(Semantics == &PPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(DoubleAPFloat &&RHS)
     : Semantics(RHS.Semantics), Floats(std::move(RHS.Floats)) {
   RHS.Semantics = &Bogus;
   assert(Semantics == &PPCDoubleDouble);
 }
 
 DoubleAPFloat &DoubleAPFloat::operator=(const DoubleAPFloat &RHS) {
-  if (Semantics == RHS.Semantics) {
+  if (Semantics == RHS.Semantics && RHS.Floats) {
     Floats[0] = RHS.Floats[0];
     Floats[1] = RHS.Floats[1];
   } else if (this != &RHS) {
     this->~DoubleAPFloat();
     new (this) DoubleAPFloat(RHS);
   }
   return *this;
 }