[APFloat] Implement PPCDoubleDouble add and subtract.

[timshen]

Summary

I looked at libgcc's implementation (which is based on the paper,
Software for Doubled-Precision Floating-Point Computations", by Seppo Linnainmaa,
ACM TOMS vol 7 no 3, September 1981, pages 272-283.) and made it generic to
arbitrary IEEE floats.

[hfinkel]

Can you please comment on how similar/different this algorithm is from the one in compiler-rt/lib/builtins/ppc/gcc_qadd.c (and other nearby files)?

[timshen]

Added a comment about the paper.

[timshen]

In D26817#600032, @hfinkel wrote:

Can you please comment on how similar/different this algorithm is from the one in compiler-rt/lib/builtins/ppc/gcc_qadd.c (and other nearby files)?

I didn't look at compiler-rt/lib/builtins/ppc/gcc_qadd.c. These algorithms take time to reason about, so currently the only thing I know is that they are different :P. I chose libgcc's version, because it has a paper to refer to.

[hfinkel]

In D26817#600060, @timshen wrote:

In D26817#600032, @hfinkel wrote:

Can you please comment on how similar/different this algorithm is from the one in compiler-rt/lib/builtins/ppc/gcc_qadd.c (and other nearby files)?

I didn't look at compiler-rt/lib/builtins/ppc/gcc_qadd.c. These algorithms take time to reason about, so currently the only thing I know is that they are different :P. I chose libgcc's version, because it has a paper to refer to.

Okay, can you explain your comment about overflow/underflow. Can't you do it the same way that the libgcc implementations do?

[timshen]

Added more comments to the implementation, and propagate all status of the internal computations to the returned status.

[timshen]

In D26817#600068, @hfinkel wrote:

In D26817#600060, @timshen wrote:

In D26817#600032, @hfinkel wrote:

Can you please comment on how similar/different this algorithm is from the one in compiler-rt/lib/builtins/ppc/gcc_qadd.c (and other nearby files)?

I didn't look at compiler-rt/lib/builtins/ppc/gcc_qadd.c. These algorithms take time to reason about, so currently the only thing I know is that they are different :P. I chose libgcc's version, because it has a paper to refer to.

Okay, can you explain your comment about overflow/underflow. Can't you do it the same way that the libgcc implementations do?

You are right. libgcc just let the underlying double arithmetic modify the fenv exception flags, so we should do the same thing.

[kbarton]

I looked through this, but my review is mostly superficial as I don't have the background to be able to comment on the logic here.

llvm/lib/Support/APFloat.cpp

4071

Why is this an empty string?

4078

Is it possible for Floats[1] to ever be negative?

[hubert.reinterpretcast]

llvm/lib/Support/APFloat.cpp

4078

The magnitude of Floats[0] should be greater than that of Floats[1].
The negative zero case may be interesting.

[timshen]

llvm/lib/Support/APFloat.cpp

4078

Is it possible for Floats[1] to ever be negative?

It's possible, e.g. (+1.0, -1e-100), which models mathematical 1-1e-100.

And yes, the magnitude of Floats[0] is greater than Floats[1].

APFloat has special category flags for zero, so Floats[1] is completely ignored when Floats[0].getCategory() is Zero.

[timshen]

I'm adding more tests.

[timshen]

Added more tests and support for bitcastToAPInt (the tests use it).

[timshen]

I believe that now it's mostly behaving in the same way as libgcc does, except for one bug that libgcc has (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78759), but I fixed it here.

[echristo]

Couple of small inline nits. Willing to go with it on the implementation details.

Adding Steve in case he wishes to comment.

-eric

llvm/lib/Support/APFloat.cpp

4071

Still an empty string :)

4163

Since you're adding a Print you might want to add a dump as well. (And while I realize it's against how the class currently works Print->print please).

[hfinkel]

llvm/lib/Support/APFloat.cpp

3949

It looks here like q = (a - z), but it would be useful to put that in the comment explicitly. Also, is there a reason for computing (a - (q + z)) as -((q + z) - a)?

[timshen]

Removed unnecessary llvm_unreachable(), and add comments for addImpl details.

[timshen]

llvm/lib/Support/APFloat.cpp

3949

We compute -((q + z) - a) instead of (a-(q+z)) to avoid creating temporary APFloat variables, thus avoid copying the object. Added a comment about that.

4071

Removed unnecessary llvm_unreachable.

[hfinkel]

LGTM

llvm/include/llvm/ADT/APFloat.h

 #include <memory>
 
 namespace llvm {
 
 struct fltSemantics;
 class APSInt;
 class StringRef;
 class APFloat;
+class raw_ostream;
 
 template <typename T> class SmallVectorImpl;
 
 /// Enum that represents what fraction of the LSB truncated bits of an fp number
 /// represent.
 ///
 /// This essentially combines the roles of guard and sticky bits.
 enum lostFraction { // Example of truncated bits:
public:
   /// Returns the smallest (by magnitude) normalized finite number in the given
   /// semantics.
   ///
   /// \param Negative - True iff the number should be negative
   void makeSmallestNormalized(bool Negative = false);
 
   /// @}
 
+  cmpResult compareAbsoluteValue(const IEEEFloat &) const;
+
 private:
   /// \name Simple Queries
   /// @{
 
   integerPart *significandParts();
   const integerPart *significandParts() const;
   unsigned int partCount() const;
 
private:
   /// @}
 
   /// \name Miscellany
   /// @{
 
   bool convertFromStringSpecials(StringRef str);
   opStatus normalize(roundingMode, lostFraction);
   opStatus addOrSubtract(const IEEEFloat &, roundingMode, bool subtract);
-  cmpResult compareAbsoluteValue(const IEEEFloat &) const;
   opStatus handleOverflow(roundingMode);
   bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const;
   opStatus convertToSignExtendedInteger(integerPart *, unsigned int, bool,
                                         roundingMode, bool *) const;
   opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
                                     roundingMode);
   opStatus convertFromHexadecimalString(StringRef, roundingMode);
   opStatus convertFromDecimalString(StringRef, roundingMode);

 // The interface and layout is designed for arbitray underlying semantics,
 // though currently only PPCDoubleDouble semantics are supported, whose
 // corresponding underlying semantics are IEEEdouble.
 class DoubleAPFloat final : public APFloatBase {
   // Note: this must be the first data member.
   const fltSemantics *Semantics;
   std::unique_ptr<APFloat[]> Floats;
 
+  opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
+                   const APFloat &cc, roundingMode RM);
+
+  opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS,
+                          DoubleAPFloat &Out, roundingMode RM);
+
 public:
   DoubleAPFloat(const fltSemantics &S);
   DoubleAPFloat(const fltSemantics &S, uninitializedTag);
   DoubleAPFloat(const fltSemantics &S, integerPart);
   DoubleAPFloat(const fltSemantics &S, const APInt &I);
   DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second);
   DoubleAPFloat(const DoubleAPFloat &RHS);
   DoubleAPFloat(DoubleAPFloat &&RHS);
 
   DoubleAPFloat &operator=(const DoubleAPFloat &RHS);
 
   DoubleAPFloat &operator=(DoubleAPFloat &&RHS) {
     if (this != &RHS) {
       this->~DoubleAPFloat();
       new (this) DoubleAPFloat(std::move(RHS));
     }
     return *this;
   }
 
   bool needsCleanup() const { return Floats != nullptr; }
 
   APFloat &getFirst() { return Floats[0]; }
   const APFloat &getFirst() const { return Floats[0]; }
+  APFloat &getSecond() { return Floats[1]; }
+  const APFloat &getSecond() const { return Floats[1]; }
+
+  opStatus add(const DoubleAPFloat &RHS, roundingMode RM);
+  opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM);
+  void changeSign();
+  cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const;
+
+  fltCategory getCategory() const;
+  bool isNegative() const;
+
+  void makeInf(bool Neg);
+  void makeNaN(bool SNaN, bool Neg, const APInt *fill);
 };
 
 } // End detail namespace
 
 // This is a interface class that is currently forwarding functionalities from
 // detail::IEEEFloat.
 class APFloat : public APFloatBase {
   typedef detail::IEEEFloat IEEEFloat;
if (usesLayout<IEEEFloat>(*U.semantics)) {
       return U.Double.getFirst().U.IEEE;
     } else {
       llvm_unreachable("Unexpected semantics");
     }
   }
 
   void makeZero(bool Neg) { getIEEE().makeZero(Neg); }
 
-  void makeInf(bool Neg) { getIEEE().makeInf(Neg); }
+  void makeInf(bool Neg) {
+    if (usesLayout<IEEEFloat>(*U.semantics)) {
+      return U.IEEE.makeInf(Neg);
+    } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
+      return U.Double.makeInf(Neg);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
 
   void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
     getIEEE().makeNaN(SNaN, Neg, fill);
   }
 
   void makeLargest(bool Neg) { getIEEE().makeLargest(Neg); }
 
   void makeSmallest(bool Neg) { getIEEE().makeSmallest(Neg); }
 
   void makeSmallestNormalized(bool Neg) {
     getIEEE().makeSmallestNormalized(Neg);
   }
 
   // FIXME: This is due to clang 3.3 (or older version) always checks for the
   // default constructor in an array aggregate initialization, even if no
   // elements in the array is default initialized.
   APFloat() : U(IEEEdouble) {
     llvm_unreachable("This is a workaround for old clang.");
   }
 
   explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {}
   explicit APFloat(DoubleAPFloat F, const fltSemantics &S)
       : U(std::move(F), S) {}
 
+  cmpResult compareAbsoluteValue(const APFloat &RHS) const {
+    assert(&getSemantics() == &RHS.getSemantics());
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.compareAbsoluteValue(RHS.U.Double);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+
 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) {}
public:
   ///
   /// \param BitWidth - Select float type
   /// \param isIEEE   - If 128 bit number, select between PPC and IEEE
   static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
 
   void Profile(FoldingSetNodeID &NID) const { getIEEE().Profile(NID); }
 
   opStatus add(const APFloat &RHS, roundingMode RM) {
-    return getIEEE().add(RHS.getIEEE(), RM);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.add(RHS.U.IEEE, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.add(RHS.U.Double, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus subtract(const APFloat &RHS, roundingMode RM) {
-    return getIEEE().subtract(RHS.getIEEE(), RM);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.subtract(RHS.U.IEEE, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.subtract(RHS.U.Double, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus multiply(const APFloat &RHS, roundingMode RM) {
     return getIEEE().multiply(RHS.getIEEE(), RM);
   }
   opStatus divide(const APFloat &RHS, roundingMode RM) {
     return getIEEE().divide(RHS.getIEEE(), RM);
   }
   opStatus remainder(const APFloat &RHS) {
public:
   APFloat &operator=(const APFloat &RHS) = default;
   APFloat &operator=(APFloat &&RHS) = default;
 
   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
                 unsigned FormatMaxPadding = 3) const {
     return getIEEE().toString(Str, FormatPrecision, FormatMaxPadding);
   }
 
+  void print(raw_ostream &) const;
+  void dump() const;
+
   bool getExactInverse(APFloat *inv) const {
     return getIEEE().getExactInverse(inv ? &inv->getIEEE() : nullptr);
   }
 
+  // This is for internal test only.
+  // TODO: Remove it after the PPCDoubleDouble transition.
+  const APFloat &getSecondFloat() const {
+    assert(&getSemantics() == &PPCDoubleDouble);
+    return U.Double.getSecond();
+  }
+
   friend hash_code hash_value(const APFloat &Arg);
   friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
   friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
   friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
+  friend IEEEFloat;
   friend DoubleAPFloat;
 };
 
 /// See friend declarations above.
 ///
 /// These additional declarations are required in order to compile LLVM with IBM
 /// xlC compiler.
 hash_code hash_value(const APFloat &Arg);

llvm/lib/Support/APFloat.cpp

 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <limits.h>
 
 using namespace llvm;
 
 /// A macro used to combine two fcCategory enums into one key which can be used
 /// in a switch statement to classify how the interaction of two APFloat's
 /// categories affects an operation.

 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
     : Semantics(&S), Floats(new APFloat[2]{APFloat(PPCDoubleDoubleImpl, I),
                                            APFloat(IEEEdouble)}) {
   assert(Semantics == &PPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const APInt &I)
-    : Semantics(&S), Floats(new APFloat[2]{APFloat(PPCDoubleDoubleImpl, I),
-                                           APFloat(IEEEdouble)}) {
+    : Semantics(&S), Floats(new APFloat[2]{
+                         APFloat(PPCDoubleDoubleImpl, I),
+                         APFloat(IEEEdouble, APInt(64, I.getRawData()[1]))}) {
   assert(Semantics == &PPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
                              APFloat &&Second)
     : Semantics(&S),
       Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
   assert(Semantics == &PPCDoubleDouble);
   // TODO Check for First == &IEEEdouble once the transition is done.
-  assert(&Floats[0].getSemantics() == &PPCDoubleDoubleImpl);
+  assert(&Floats[0].getSemantics() == &PPCDoubleDoubleImpl ||
+         &Floats[0].getSemantics() == &IEEEdouble);
   assert(&Floats[1].getSemantics() == &IEEEdouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const DoubleAPFloat &RHS)
     : Semantics(RHS.Semantics),
       Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
                                          APFloat(RHS.Floats[1])}
                         : nullptr) {
if (Semantics == RHS.Semantics && RHS.Floats) {
     Floats[1] = RHS.Floats[1];
   } else if (this != &RHS) {
     this->~DoubleAPFloat();
     new (this) DoubleAPFloat(RHS);
   }
   return *this;
 }
 
+// "Software for Doubled-Precision Floating-Point Computations",
+// by Seppo Linnainmaa, ACM TOMS vol 7 no 3, September 1981, pages 272-283.
+APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
+                                         const APFloat &c, const APFloat &cc,
+                                         roundingMode RM) {
+  int Status = opOK;
+  APFloat z = a;
+  Status |= z.add(c, RM);
+  if (!z.isFinite()) {
+    if (!z.isInfinity()) {
+      Floats[0] = std::move(z);
+      Floats[1].makeZero(false);
+      return (opStatus)Status;
+    }
+    Status = opOK;
+    auto AComparedToC = a.compareAbsoluteValue(c);
+    z = cc;
+    Status |= z.add(aa, RM);
+    if (AComparedToC == APFloat::cmpGreaterThan) {
+      // z = cc + aa + c + a;
+      Status |= z.add(c, RM);
+      Status |= z.add(a, RM);
+    } else {
+      // z = cc + aa + a + c;
+      Status |= z.add(a, RM);
+      Status |= z.add(c, RM);
+    }
+    if (!z.isFinite()) {
+      Floats[0] = std::move(z);
+      Floats[1].makeZero(false);
+      return (opStatus)Status;
+    }
+    Floats[0] = z;
+    APFloat zz = aa;
+    Status |= zz.add(cc, RM);
+    if (AComparedToC == APFloat::cmpGreaterThan) {
+      // Floats[1] = a - z + c + zz;
+      Floats[1] = a;
+      Status |= Floats[1].subtract(z, RM);
+      Status |= Floats[1].add(c, RM);
+      Status |= Floats[1].add(zz, RM);
+    } else {
+      // Floats[1] = c - z + a + zz;
+      Floats[1] = c;
+      Status |= Floats[1].subtract(z, RM);
+      Status |= Floats[1].add(a, RM);
+      Status |= Floats[1].add(zz, RM);
+    }
+  } else {
+    // q = a - z;
+    APFloat q = a;
+    Status |= q.subtract(z, RM);
+
+    // zz = q + c + (a - (q + z)) + aa + cc;
+    // Compute a - (q + z) as -((q + z) - a) to avoid temporary copies.
+    auto zz = q;
+    Status |= zz.add(c, RM);
+    Status |= q.add(z, RM);
+    Status |= q.subtract(a, RM);
+    q.changeSign();
+    Status |= zz.add(q, RM);
+    Status |= zz.add(aa, RM);
+    Status |= zz.add(cc, RM);
+    if (zz.isZero() && !zz.isNegative()) {
+      Floats[0] = std::move(z);
+      Floats[1].makeZero(false);
+      return opOK;
+    }
+    Floats[0] = z;
+    Status |= Floats[0].add(zz, RM);
+    if (!Floats[0].isFinite()) {
+      Floats[1].makeZero(false);
+      return (opStatus)Status;
+    }
+    Floats[1] = std::move(z);
+    Status |= Floats[1].subtract(Floats[0], RM);
+    Status |= Floats[1].add(zz, RM);
+  }
+  return (opStatus)Status;
+}
+
+APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
+                                                const DoubleAPFloat &RHS,
+                                                DoubleAPFloat &Out,
+                                                roundingMode RM) {
+  if (LHS.getCategory() == fcNaN) {
+    Out = LHS;
+    return opOK;
+  }
+  if (RHS.getCategory() == fcNaN) {
+    Out = RHS;
+    return opOK;
+  }
+  if (LHS.getCategory() == fcZero) {
+    Out = RHS;
+    return opOK;
+  }
+  if (RHS.getCategory() == fcZero) {
+    Out = LHS;
+    return opOK;
+  }
+  if (LHS.getCategory() == fcInfinity && RHS.getCategory() == fcInfinity &&
+      LHS.isNegative() != RHS.isNegative()) {
+    Out.makeNaN(false, Out.isNegative(), nullptr);
+    return opInvalidOp;
+  }
+  if (LHS.getCategory() == fcInfinity) {
+    Out = LHS;
+    return opOK;
+  }
+  if (RHS.getCategory() == fcInfinity) {
+    Out = RHS;
+    return opOK;
+  }
+  assert(LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal);
+
+  // These conversions will go away once PPCDoubleDoubleImpl goes away.
+  // (PPCDoubleDoubleImpl, IEEEDouble) -> (IEEEDouble, IEEEDouble)
+  APFloat A(IEEEdouble,
+            APInt(64, LHS.Floats[0].bitcastToAPInt().getRawData()[0])),
+      AA(LHS.Floats[1]),
+      C(IEEEdouble, APInt(64, RHS.Floats[0].bitcastToAPInt().getRawData()[0])),
+      CC(RHS.Floats[1]);
+  assert(&AA.getSemantics() == &IEEEdouble);
+  assert(&CC.getSemantics() == &IEEEdouble);
+  Out.Floats[0] = APFloat(IEEEdouble);
+  assert(&Out.Floats[1].getSemantics() == &IEEEdouble);
+
+  auto Ret = Out.addImpl(A, AA, C, CC, RM);
+
+  // (IEEEDouble, IEEEDouble) -> (PPCDoubleDoubleImpl, IEEEDouble)
+  uint64_t Buffer[] = {Out.Floats[0].bitcastToAPInt().getRawData()[0],
+                       Out.Floats[1].bitcastToAPInt().getRawData()[0]};
+  Out.Floats[0] = APFloat(PPCDoubleDoubleImpl, APInt(128, 2, Buffer));
+  return Ret;
+}
+
+APFloat::opStatus DoubleAPFloat::add(const DoubleAPFloat &RHS,
+                                     roundingMode RM) {
+  return addWithSpecial(*this, RHS, *this, RM);
+}
+
+APFloat::opStatus DoubleAPFloat::subtract(const DoubleAPFloat &RHS,
+                                          roundingMode RM) {
+  changeSign();
+  auto Ret = add(RHS, RM);
+  changeSign();
+  return Ret;
+}
+
+void DoubleAPFloat::changeSign() {
+  Floats[0].changeSign();
+  Floats[1].changeSign();
+}
+
+APFloat::cmpResult
+DoubleAPFloat::compareAbsoluteValue(const DoubleAPFloat &RHS) const {
+  auto Result = Floats[0].compareAbsoluteValue(RHS.Floats[0]);
+  if (Result != cmpEqual)
+    return Result;
+  Result = Floats[1].compareAbsoluteValue(RHS.Floats[1]);
+  if (Result == cmpLessThan || Result == cmpGreaterThan) {
+    auto Against = Floats[0].isNegative() ^ Floats[1].isNegative();
+    auto RHSAgainst = RHS.Floats[0].isNegative() ^ RHS.Floats[1].isNegative();
+    if (Against && !RHSAgainst)
+      return cmpLessThan;
+    if (!Against && RHSAgainst)
+      return cmpGreaterThan;
+    if (!Against && !RHSAgainst)
+      return Result;
+    if (Against && RHSAgainst)
+      return (cmpResult)(cmpLessThan + cmpGreaterThan - Result);
+  }
+  return Result;
+}
+
+APFloat::fltCategory DoubleAPFloat::getCategory() const {
+  return Floats[0].getCategory();
+}
+
+bool DoubleAPFloat::isNegative() const { return Floats[0].isNegative(); }
+
+void DoubleAPFloat::makeInf(bool Neg) {
+  Floats[0].makeInf(Neg);
+  Floats[1].makeZero(false);
+}
+
+void DoubleAPFloat::makeNaN(bool SNaN, bool Neg, const APInt *fill) {
+  Floats[0].makeNaN(SNaN, Neg, fill);
+  Floats[1].makeZero(false);
+}
+
 } // End detail namespace
 
 APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
   if (usesLayout<IEEEFloat>(Semantics)) {
     new (&IEEE) IEEEFloat(std::move(F));
   } else if (usesLayout<DoubleAPFloat>(Semantics)) {
     new (&Double)
         DoubleAPFloat(Semantics, APFloat(std::move(F), F.getSemantics()),
default:
       llvm_unreachable("Unknown floating bit width");
     }
   } else {
     assert(BitWidth == 128);
     return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
   }
 }
 
+void APFloat::print(raw_ostream &OS) const {
+  SmallVector<char, 16> Buffer;
+  toString(Buffer);
+  OS << Buffer << "\n";
+}
+
+void APFloat::dump() const { print(dbgs()); }
+
 } // End llvm namespace

llvm/unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, PPCDoubleDouble) {
   EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
   EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
 
   // LDBL_MIN
   test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
   EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
 
-  test = APFloat(APFloat::PPCDoubleDouble, "1.0");
-  test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
-  EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
-  EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
-
-  test = APFloat(APFloat::PPCDoubleDouble, "1.0");
-  test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
-  EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
-#if 0 // XFAIL
-  // This is what we would expect with a true double-double implementation
-  EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
-#else
-  // This is what we get with our 106-bit mantissa approximation
-  EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
-#endif
-
   // PR30869
   {
     auto Result = APFloat(APFloat::PPCDoubleDouble, "1.0") +
                   APFloat(APFloat::PPCDoubleDouble, "1.0");
     EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics());
 
     Result = APFloat(APFloat::PPCDoubleDouble, "1.0") -
              APFloat(APFloat::PPCDoubleDouble, "1.0");
TEST(APFloatTest, frexp) {
   Frac = frexp(APFloat(APFloat::IEEEdouble, "0x1p-51"), Exp, RM);
   EXPECT_EQ(-50, Exp);
   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p-1").bitwiseIsEqual(Frac));
 
   Frac = frexp(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp+51"), Exp, RM);
   EXPECT_EQ(52, Exp);
   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
 }
+
+TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
+  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
+                              APFloat::fltCategory, APFloat::roundingMode>;
+  DataType Data[] = {
+      // (1 + 0) + (-1 + 0) = fcZero
+      {0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0, APFloat::fcZero,
+       APFloat::rmNearestTiesToEven},
+      // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
+      {0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 0x7948000000000000ull,
+       0ull, APFloat::fcInfinity, APFloat::rmNearestTiesToEven},
+      // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
+      // PPCDoubleDoubleImpl is gone.
+      // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
+      // 160))) = fcNormal
+      {0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 0x7947ffffffffffffull,
+       0x75effffffffffffeull, APFloat::fcNormal, APFloat::rmNearestTiesToEven},
+      // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
+      {0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 0x7fefffffffffffffull,
+       0x7c8ffffffffffffeull, APFloat::fcInfinity,
+       APFloat::rmNearestTiesToEven},
+      // NaN + (1 + 0) = fcNaN
+      {0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0, APFloat::fcNaN,
+       APFloat::rmNearestTiesToEven},
+  };
+
+  for (auto Tp : Data) {
+    uint64_t Op1[2], Op2[2];
+    APFloat::fltCategory Expected;
+    APFloat::roundingMode RM;
+    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
+
+    APFloat A1(APFloat::PPCDoubleDouble, APInt(128, 2, Op1));
+    APFloat A2(APFloat::PPCDoubleDouble, APInt(128, 2, Op2));
+    A1.add(A2, RM);
+
+    EXPECT_EQ(Expected, A1.getCategory());
+  }
+}
+
+TEST(APFloatTest, PPCDoubleDoubleAdd) {
+  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
+                              uint64_t, APFloat::roundingMode>;
+  DataType Data[] = {
+      // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
+      {0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
+       0x3ff0000000000000ull, 0x3960000000000000ull,
+       APFloat::rmNearestTiesToEven},
+      // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
+      {0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
+       0x3ff0000000000000ull, 0x3950000000000000ull,
+       APFloat::rmNearestTiesToEven},
+      // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
+      {0x3ff0000000000000ull, 0x3950000000000000ull, 0x3950000000000000ull, 0,
+       0x3ff0000000000000ull, 0x3960000000000000ull,
+       APFloat::rmNearestTiesToEven},
+      // (1 + 0) + (epsilon + 0) = (1 + epsilon)
+      {0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
+       0x3ff0000000000000ull, 0x0000000000000001ull,
+       APFloat::rmNearestTiesToEven},
+      // TODO: change 0xf950000000000000 to 0xf940000000000000, when
+      // PPCDoubleDoubleImpl is gone.
+      // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
+      // 1.11111... << (1023 - 52)
+      {0x7fefffffffffffffull, 0xf950000000000000ull, 0x7c90000000000000ull, 0,
+       0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
+       APFloat::rmNearestTiesToEven},
+      // TODO: change 0xf950000000000000 to 0xf940000000000000, when
+      // PPCDoubleDoubleImpl is gone.
+      // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
+      // 1.11111... << (1023 - 52)
+      {0x7c90000000000000ull, 0, 0x7fefffffffffffffull, 0xf950000000000000ull,
+       0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
+       APFloat::rmNearestTiesToEven},
+  };
+
+  for (auto Tp : Data) {
+    uint64_t Op1[2], Op2[2], Expected[2];
+    APFloat::roundingMode RM;
+    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
+
+    APFloat A1(APFloat::PPCDoubleDouble, APInt(128, 2, Op1));
+    APFloat A2(APFloat::PPCDoubleDouble, APInt(128, 2, Op2));
+    A1.add(A2, RM);
+
+    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]);
+    EXPECT_EQ(Expected[1],
+              A1.getSecondFloat().bitcastToAPInt().getRawData()[0]);
+  }
+}
+
+TEST(APFloatTest, PPCDoubleDoubleSubtract) {
+  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
+                              uint64_t, APFloat::roundingMode>;
+  DataType Data[] = {
+      // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
+      {0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
+       0x3ff0000000000000ull, 0x3960000000000000ull,
+       APFloat::rmNearestTiesToEven},
+      // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
+      {0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
+       0x3ff0000000000000ull, 0x3950000000000000ull,
+       APFloat::rmNearestTiesToEven},
+  };
+
+  for (auto Tp : Data) {
+    uint64_t Op1[2], Op2[2], Expected[2];
+    APFloat::roundingMode RM;
+    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
+
+    APFloat A1(APFloat::PPCDoubleDouble, APInt(128, 2, Op1));
+    APFloat A2(APFloat::PPCDoubleDouble, APInt(128, 2, Op2));
+    A1.subtract(A2, RM);
+
+    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]);
+    EXPECT_EQ(Expected[1],
+              A1.getSecondFloat().bitcastToAPInt().getRawData()[0]);
+  }
+}
 }