[APFloat] Switch from (PPCDoubleDoubleImpl, IEEEdouble) layout to (IEEEdouble, IEEEdouble)

[timshen]

Summary

This patch changes the layout of DoubleAPFloat, and adjust all
operations to do either:

1. (IEEEdouble, IEEEdouble) -> (uint64_t, uint64_t) -> PPCDoubleDoubleImpl, then run the old algorithm.
2. Do the right thing directly.

1. includes multiply, divide, remainder, mod, fusedMultiplyAdd, roundToIntegral, convertFromString, next, convertToInteger, convertFromAPInt, convertFromSignExtendedInteger, convertFromZeroExtendedInteger, convertToHexString, toString, getExactInverse.
2. includes makeZero, makeLargest, makeSmallest, makeSmallestNormalized, compare, bitwiseIsEqual, bitcastToAPInt, isDenormal, isSmallest, isLargest, isInteger, ilogb, scalbn, frexp, hash_value, Profile.

I could split this into two patches, e.g. use

1. for all operatoins first, then incrementally change some of them to

2). I didn't do that, because 1) involves code that converts data between
PPCDoubleDoubleImpl and (IEEEdouble, IEEEdouble) back and forth, and may
pessimize the compiler. Instead, I find easy functions and use
approach 2) for them directly.

Next step is to implement move multiply and divide from 1) to 2). I don't
have plans for other functions in 1).

[ahatanak]

llvm/include/llvm/ADT/APFloat.h

773

You don't need else after return.

[jtony]

llvm/include/llvm/ADT/APFloat.h

800

I know it is allowed to return a void function call inside a void function, but I think this reduces the code readability in general and causes some confusing to some people. Maybe it is better to avoid using this kind of coding style. I think we can simply call each function in each branch without the 'return' keyword, by default, the program will reach the end of function and return.

One possible equivalent code:

void makeNaN(bool SNaN, bool Neg, const APInt *fill) {

  if (usesLayout<IEEEFloat>(getSemantics())) {
    U.IEEE.makeNaN(SNaN, Neg, fill);
  } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
    U.Double.makeNaN(SNaN, Neg, fill);
  } else {
    llvm_unreachable("Unexpected semantics");
  }
}

811

Same here.

821

Same here.

1100

Same here.

[timshen]

Remove 'else' after return.
Remove 'return' on void type.

[timshen]

Remove more 'else' after return.

[mehdi_amini]

llvm/include/llvm/ADT/APFloat.h

800

Two reasons not to do that:

1. It makes it less consistent with all the other cases, and consistency is a high criteria for readability
2. returning a function call in a void function makes it so that if the callee signature is changed to return something in the future, it can't be ignored here (i.e. it makes it less error prone somehow).

Alternatively, you can also write it this way:

if (usesLayout<IEEEFloat>(getSemantics())) {
  U.IEEE.makeNaN(SNaN, Neg, fill);
  return;
} 
if (usesLayout<DoubleAPFloat>(getSemantics())) {
  U.Double.makeNaN(SNaN, Neg, fill);
  return;
} 
llvm_unreachable("Unexpected semantics");

[timshen]

Consistently use early return style.

[timshen]

I changed type style to early return.

For constructors and destructors, I use:

if (...) {
  // statement;
  return;
}

For normal functions that returns void, I chose:

if (...)
  return Foo();
llvm_unreachable(...);

since it's more compact. If returning void looks weird, we should add it to the style guide.

Other functions are not controversial.

[echristo]

In D27872#628212, @timshen wrote:

I changed type style to early return.

For constructors and destructors, I use:

if (...) {
  // statement;
  return;
}

For normal functions that returns void, I chose:

if (...)
  return Foo();
llvm_unreachable(...);

since it's more compact. If returning void looks weird, we should add it to the style guide.

Looks pretty weird. Typically I'd suggest just:

if (foo) {

Foo();
return;

}

since that will keep cognitive overhead to a minimum.

-eric

Other functions are not controversial.

[timshen]

In D27872#636130, @echristo wrote:

Looks pretty weird. Typically I'd suggest just:

if (foo) {

Foo();
return;

}

since that will keep cognitive overhead to a minimum.

-eric

Other functions are not controversial.

I'm happy to discuss on a style guide <del>bikeshedding</del>change, since you are the second person that raises this concern, and now it's like 2 vs 2 :).

Another reason to not to do so is consistency with other returning functions, and potential changes required in the future, when a void-returning function starts to return values.

[echristo]

In D27872#636147, @timshen wrote:

In D27872#636130, @echristo wrote:

Looks pretty weird. Typically I'd suggest just:

if (foo) {

Foo();
return;

}

since that will keep cognitive overhead to a minimum.

-eric

Other functions are not controversial.

I'm happy to discuss on a style guide <del>bikeshedding</del>change, since you are the second person that raises this concern, and now it's like 2 vs 2 :).

Another reason to not to do so is consistency with other returning functions, and potential changes required in the future, when a void-returning function starts to return values.

I'm pretty sure I've never seen return <void type function> widely used in the code base versus my suggestion. That said, if you've looked and it's roughly 50/50 then I care a lot less (and we can bike shed in some separate thread).

-eric

[timshen]

In D27872#636149, @echristo wrote:

I'm pretty sure I've never seen return <void type function> widely used in the code base versus my suggestion. That said, if you've looked and it's roughly 50/50 then I care a lot less (and we can bike shed in some separate thread).

I didn't count, and I don't know how to count it in the code base. :(

[timshen]

Friendly ping :)

Is there anyone else I can add as a reviewer, if no one feels comfortable reviewing the semantic?

[echristo]

Adding Steve in an attempt to get him to review :)

[hfinkel]

(IEEEdouble, IEEEdouble) -> (uint64_t, uint64_t) -> PPCDoubleDoubleImpl, then run the old algorithm.

We need to document in the code what is going on here and why it works. Just looking at a bunch of code like this:

if (Semantics == &semPPCDoubleDouble) {
  APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
  auto Ret = Tmp.next(nextDown);
  *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
  return Ret;
}

it is not at all obvious what is going on (i.e. why are we casting to integers?). Maybe semPPCDoubleDoubleImpl needs a better name now? It seems confusing to have semPPCDoubleDoubleImpl and semPPCDoubleDouble where one is not really an "implementation" class of the other.

llvm/include/llvm/ADT/APFloat.h

791–797

I realize that some of this existed before, but is there any way to refactor this so that we don't have so much boiler plate? Even using a utility macro is probably better than this.

[timshen]

Rename semPPCDoubleDoubleImpl to semPPCDoubleDoubleLegacy to reflect its use more accurately.

[timshen]

In D27872#639020, @hfinkel wrote:

it is not at all obvious what is going on (i.e. why are we casting to integers?). Maybe semPPCDoubleDoubleImpl needs a better name now? It seems confusing to have semPPCDoubleDoubleImpl and semPPCDoubleDouble where one is not really an "implementation" class of the other.

This is true. I renamed it to semPPCDoubleDoubleLegacy, and modified its documentation. I didn't put the documentation for each of the uses, because that'd be too verbose.

[timshen]

llvm/include/llvm/ADT/APFloat.h

791–797

I was thinking about using a macro. I can do that after this patch.

The right way though, is to use virtual functions to do the dynamic dispatch. Ideally, we will have APFloatInterface as a pure virtual base, IEEEFloat and DoubleAPFloat as its two derives, and APFloat managing the union buffer to hold the objects. This approach is not easy to transit to, since then the object needs to keep a vtable pointer around, which costs a word. In order to compensate that overhead, we need somehow stash the "semantics" data member into the vtable.

[timshen]

Friendly ping. :)

We still have internal test failures that this patch (and the next one) fixes, and I think this is the last "hard to review" patch in the APFloat refactoring.

[echristo]

Few comments inline. Generally looks OK, I do share Hal's comment on finding some way of simplifying the if (someSemantics) ... if (otherSemantics) ... llvm_unreachable(...) pattern.

What did you have in mind?

llvm/include/llvm/ADT/APFloat.h

800

I prefer the alternate way that Mehdi has it here rather than returning void if possible.

842–843

Go ahead and commit this separately. (And the rest of the assert changes to add descriptions of the assert).

1059

What's with the no error checking. Also, unless my font kerning is terrible you have nmNearestTiesToEven versus rmNearestTiesToEven.

llvm/lib/Support/APFloat.cpp

4026

To reduce indentation I'd probably assert first? (And all below)

[timshen]

Stylish changes.

llvm/include/llvm/ADT/APFloat.h

1059

That original IEEEFloat does so. I think it's reasonable, since the operators are mostly for convenience, while a serious user should use add/subtract/multiply/divide.

Fixed the typo.

[echristo]

This looks fine to me now, might be good to get someone else to ack as well though.

[echristo]

Hal has given an ack (offline) as well. Go ahead Tim.

[jlebar]

Eric asked me to do a review of this. I notice now it was submitted while I was doing the review. Oh well. Here are the comments I had.

llvm/include/llvm/ADT/APFloat.h

1058

FWIW, see my screed on this: http://jlebar.com/2011/12/16/Boolean_parameters_to_API_functions_considered_harmful..html

1066

We have autobrief, which I do not understand, but I believe renders "\brief" unnecessary?

1066

Nit, Since "operator" is a keyword, it should be capitalized as in the C++

1066

Nit, It's clear from the code that this is an operator+ overload. Perhaps all we need to say is

Add two APFloats using rmNearestTiesToEven semantics. No error checking.

llvm/lib/Support/APFloat.cpp

88

s/case/operation/?

88

s/have/having/

88

s/consecutive 106 bits/106 consecutive bits/

89

No comma before "and". (Comma before "and" is usually reserved for the case when "and" joins two "independent clauses" -- things which could themselves be complete sentences.)

89

Suggest

It's not equivalent to the true PPC double-double semantics, because in reality, the two 53-bit mantissa parts ...

91

Can we rephrase "the two 53-bit mantissa parts don't actually have to be consecutive, e.g. 1 + epsilon."? I don't understand what this means.

4139

Nit: makeZero(/* Neg = */ false)? (See aforementioned screed. :)

4181

Is it worth adding a comment here that this is correct because in a double-double (x, y), we always have x >= y?

At least, I assume that's why this is correct. :)

4192

Nit, do you want to include the semantics? I mean, I guess it doesn't really matter.

4276

This shouldn't be == cmpEqual or something? Otherwise this makes no sense to me; perhaps we could add a comment?

llvm/unittests/ADT/APFloatTest.cpp

3511

Can you use {} instead of make_tuple? https://godbolt.org/g/1Y1P0F

3534

Honestly I am not sure this is an improvement over writing it out by hand:

EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, {0xblah, 0xblah})).bitwiseIsEqual(...)))

(You should be able to pass an initializer_list to the constructor, no problem, afaict.) Up to you though.

[timshen]

llvm/include/llvm/ADT/APFloat.h

1058

I totally agree, but I'm not going to change it right now, so I added a TODO.

llvm/lib/Support/APFloat.cpp

89

I re-worked on the comments to make it readable by a programmer with no IBM double-double knowledge.

4181

I think you mean |x| > |y|. Now it's mentioned in the semPPCDoubleDouble documentation.

4192

It's more like a defensive style, just in case DoubleAPFloat supports more than just two doubles.

4276

It's by IBM double-double's definition, as previously commented.

llvm/unittests/ADT/APFloatTest.cpp

3511

Nope, GCC 4.8 will puke. lul.

3534

It's more of being consistent with other tests. I might be too lazy to change, unless you insist. :)

[jlebar]

llvm/unittests/ADT/APFloatTest.cpp

3534

I mean, the only tests that use make_tuple also seem to be ppc long-double tests. :) Up to you, though; not a big deal.

clang/test/CodeGen/ppc64-complex-parms.c

void bar_long_double(void) {
   foo_long_double(2.0L - 2.5Li);
 }
 
 // CHECK: define void @bar_long_double() [[NUW]] {
 // CHECK: %[[VAR21:[A-Za-z0-9.]+]] = alloca { ppc_fp128, ppc_fp128 }, align 16
 // CHECK: %[[VAR22:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
 // CHECK: %[[VAR23:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
 // CHECK: store ppc_fp128 0xM40000000000000000000000000000000, ppc_fp128* %[[VAR22]]
-// CHECK: store ppc_fp128 0xMC0040000000000000000000000000000, ppc_fp128* %[[VAR23]]
+// CHECK: store ppc_fp128 0xMC0040000000000008000000000000000, ppc_fp128* %[[VAR23]]
 // CHECK: %[[VAR24:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 0
 // CHECK: %[[VAR25:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR24]], align 16
 // CHECK: %[[VAR26:[A-Za-z0-9.]+]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* %[[VAR21]], i32 0, i32 1
 // CHECK: %[[VAR27:[A-Za-z0-9.]+]] = load ppc_fp128, ppc_fp128* %[[VAR26]], align 16
 // CHECK: %{{[A-Za-z0-9.]+}} = call ppc_fp128 @foo_long_double(ppc_fp128 %[[VAR25]], ppc_fp128 %[[VAR27]])
 
 void bar_int(void) {
   foo_int(2 - 3i);

llvm/include/llvm/ADT/APFloat.h

public:
   /// \brief Returns whether this instance allocated memory.
   bool needsCleanup() const { return partCount() > 1; }
 
   /// \name Convenience "constructors"
   /// @{
 
   /// @}
 
-  /// Used to insert APFloat objects, or objects that contain APFloat objects,
-  /// into FoldingSets.
-  void Profile(FoldingSetNodeID &NID) const;
-
   /// \name Arithmetic
   /// @{
 
   opStatus add(const IEEEFloat &, roundingMode);
   opStatus subtract(const IEEEFloat &, roundingMode);
   opStatus multiply(const IEEEFloat &, roundingMode);
   opStatus divide(const IEEEFloat &, roundingMode);
   /// IEEE remainder.
   opStatus remainder(const IEEEFloat &);
   /// C fmod, or llvm frem.
   opStatus mod(const IEEEFloat &);
   opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode);
   opStatus roundToIntegral(roundingMode);
   /// IEEE-754R 5.3.1: nextUp/nextDown.
   opStatus next(bool nextDown);
 
-  /// \brief Operator+ overload which provides the default
-  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
-  IEEEFloat operator+(const IEEEFloat &RHS) const {
-    IEEEFloat Result = *this;
-    Result.add(RHS, rmNearestTiesToEven);
-    return Result;
-  }
-
-  /// \brief Operator- overload which provides the default
-  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
-  IEEEFloat operator-(const IEEEFloat &RHS) const {
-    IEEEFloat Result = *this;
-    Result.subtract(RHS, rmNearestTiesToEven);
-    return Result;
-  }
-
-  /// \brief Operator* overload which provides the default
-  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
-  IEEEFloat operator*(const IEEEFloat &RHS) const {
-    IEEEFloat Result = *this;
-    Result.multiply(RHS, rmNearestTiesToEven);
-    return Result;
-  }
-
-  /// \brief Operator/ overload which provides the default
-  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
-  IEEEFloat operator/(const IEEEFloat &RHS) const {
-    IEEEFloat Result = *this;
-    Result.divide(RHS, rmNearestTiesToEven);
-    return Result;
-  }
-
   /// @}
 
   /// \name Sign operations.
   /// @{
 
   void changeSign();
-  void clearSign();
-  void copySign(const IEEEFloat &);
-
-  /// \brief A static helper to produce a copy of an APFloat value with its sign
-  /// copied from some other APFloat.
-  static IEEEFloat copySign(IEEEFloat Value, const IEEEFloat &Sign) {
-    Value.copySign(Sign);
-    return Value;
-  }
 
   /// @}
 
   /// \name Conversions
   /// @{
 
   opStatus convert(const fltSemantics &, roundingMode, bool *);
   opStatus convertToInteger(integerPart *, unsigned int, bool, roundingMode,
                             bool *) const;
-  opStatus convertToInteger(APSInt &, roundingMode, bool *) const;
   opStatus convertFromAPInt(const APInt &, bool, roundingMode);
   opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int,
                                           bool, roundingMode);
   opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
                                           bool, roundingMode);
   opStatus convertFromString(StringRef, roundingMode);
   APInt bitcastToAPInt() const;
   double convertToDouble() const;
public:
   /// 1.01E-2              5             2       0.0101
   /// 1.01E-2              4             2       0.0101
   /// 1.01E-2              4             1       1.01E-2
   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
                 unsigned FormatMaxPadding = 3) const;
 
   /// If this value has an exact multiplicative inverse, store it in inv and
   /// return true.
-  bool getExactInverse(IEEEFloat *inv) const;
+  bool getExactInverse(APFloat *inv) const;
 
   /// \brief Returns the exponent of the internal representation of the APFloat.
   ///
   /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
   /// For special APFloat values, this returns special error codes:
   ///
   ///   NaN -> \c IEK_NaN
   ///   0   -> \c IEK_Zero
public:
 
   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);
+  opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM);
+  opStatus divide(const DoubleAPFloat &RHS, roundingMode RM);
+  opStatus remainder(const DoubleAPFloat &RHS);
+  opStatus mod(const DoubleAPFloat &RHS);
+  opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
+                            const DoubleAPFloat &Addend, roundingMode RM);
+  opStatus roundToIntegral(roundingMode RM);
   void changeSign();
   cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const;
 
   fltCategory getCategory() const;
   bool isNegative() const;
 
   void makeInf(bool Neg);
+  void makeZero(bool Neg);
+  void makeLargest(bool Neg);
+  void makeSmallest(bool Neg);
+  void makeSmallestNormalized(bool Neg);
   void makeNaN(bool SNaN, bool Neg, const APInt *fill);
+
+  cmpResult compare(const DoubleAPFloat &RHS) const;
+  bool bitwiseIsEqual(const DoubleAPFloat &RHS) const;
+  APInt bitcastToAPInt() const;
+  opStatus convertFromString(StringRef, roundingMode);
+  opStatus next(bool nextDown);
+
+  opStatus convertToInteger(integerPart *Input, unsigned int Width,
+                            bool IsSigned, roundingMode RM,
+                            bool *IsExact) const;
+  opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM);
+  opStatus convertFromSignExtendedInteger(const integerPart *Input,
+                                          unsigned int InputSize, bool IsSigned,
+                                          roundingMode RM);
+  opStatus convertFromZeroExtendedInteger(const integerPart *Input,
+                                          unsigned int InputSize, bool IsSigned,
+                                          roundingMode RM);
+  unsigned int convertToHexString(char *DST, unsigned int HexDigits,
+                                  bool UpperCase, roundingMode RM) const;
+
+  bool isDenormal() const;
+  bool isSmallest() const;
+  bool isLargest() const;
+  bool isInteger() const;
+
+  void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
+                unsigned FormatMaxPadding) const;
+
+  bool getExactInverse(APFloat *inv) const;
+
+  friend int ilogb(const DoubleAPFloat &Arg);
+  friend DoubleAPFloat scalbn(DoubleAPFloat X, int Exp, roundingMode);
+  friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode);
+  friend hash_code hash_value(const DoubleAPFloat &Arg);
 };
 
+hash_code hash_value(const DoubleAPFloat &Arg);
+
 } // End detail namespace
 
 // This is a interface class that is currently forwarding functionalities from
 // detail::IEEEFloat.
 class APFloat : public APFloatBase {
   typedef detail::IEEEFloat IEEEFloat;
   typedef detail::DoubleAPFloat DoubleAPFloat;
 
if (usesLayout<IEEEFloat>(*U.semantics)) {
       return U.IEEE;
     } else if (usesLayout<DoubleAPFloat>(*U.semantics)) {
       return U.Double.getFirst().U.IEEE;
     } else {
       llvm_unreachable("Unexpected semantics");
     }
   }
 
-  void makeZero(bool Neg) { getIEEE().makeZero(Neg); }
+  void makeZero(bool Neg) {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.makeZero(Neg);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.makeZero(Neg);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
 
   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);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.makeNaN(SNaN, Neg, fill);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.makeNaN(SNaN, Neg, fill);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
-  void makeLargest(bool Neg) { getIEEE().makeLargest(Neg); }
+  void makeLargest(bool Neg) {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.makeLargest(Neg);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.makeLargest(Neg);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
 
-  void makeSmallest(bool Neg) { getIEEE().makeSmallest(Neg); }
+  void makeSmallest(bool Neg) {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.makeSmallest(Neg);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.makeSmallest(Neg);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
 
   void makeSmallestNormalized(bool Neg) {
-    getIEEE().makeSmallestNormalized(Neg);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.makeSmallestNormalized(Neg);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.makeSmallestNormalized(Neg);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
   // 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());
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only compare APFloats with the same semantics");
     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:
   }
 
   /// Returns a float which is bitcasted from an all one value int.
   ///
   /// \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); }
+  /// Used to insert APFloat objects, or objects that contain APFloat objects,
+  /// into FoldingSets.
+  void Profile(FoldingSetNodeID &NID) const;
 
   opStatus add(const APFloat &RHS, roundingMode RM) {
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
     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) {
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
     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);
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.multiply(RHS.U.IEEE, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.multiply(RHS.U.Double, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus divide(const APFloat &RHS, roundingMode RM) {
-    return getIEEE().divide(RHS.getIEEE(), RM);
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.divide(RHS.U.IEEE, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.divide(RHS.U.Double, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus remainder(const APFloat &RHS) {
-    return getIEEE().remainder(RHS.getIEEE());
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.remainder(RHS.U.IEEE);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.remainder(RHS.U.Double);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+  opStatus mod(const APFloat &RHS) {
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only call on two APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.mod(RHS.U.IEEE);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.mod(RHS.U.Double);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
-  opStatus mod(const APFloat &RHS) { return getIEEE().mod(RHS.getIEEE()); }
   opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
                             roundingMode RM) {
-    return getIEEE().fusedMultiplyAdd(Multiplicand.getIEEE(), Addend.getIEEE(),
+    assert(&getSemantics() == &Multiplicand.getSemantics() &&
+           "Should only call on APFloats with the same semantics");
+    assert(&getSemantics() == &Addend.getSemantics() &&
+           "Should only call on APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
                                        RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus roundToIntegral(roundingMode RM) {
-    return getIEEE().roundToIntegral(RM);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.roundToIntegral(RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.roundToIntegral(RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+
+  opStatus next(bool nextDown) {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.next(nextDown);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.next(nextDown);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
-  opStatus next(bool nextDown) { return getIEEE().next(nextDown); }
 
+  /// \brief Operator+ overload which provides the default
+  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
   APFloat operator+(const APFloat &RHS) const {
-    return APFloat(getIEEE() + RHS.getIEEE(), getSemantics());
+    APFloat Result(*this);
+    (void)Result.add(RHS, rmNearestTiesToEven);
+    return Result;
   }
 
+  /// \brief Operator- overload which provides the default
+  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
   APFloat operator-(const APFloat &RHS) const {
-    return APFloat(getIEEE() - RHS.getIEEE(), getSemantics());
+    APFloat Result(*this);
+    (void)Result.subtract(RHS, rmNearestTiesToEven);
+    return Result;
   }
 
+  /// \brief Operator* overload which provides the default
+  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
   APFloat operator*(const APFloat &RHS) const {
-    return APFloat(getIEEE() * RHS.getIEEE(), getSemantics());
+    APFloat Result(*this);
+    (void)Result.multiply(RHS, rmNearestTiesToEven);
+    return Result;
   }
 
+  /// \brief Operator/ overload which provides the default
+  /// \c nmNearestTiesToEven rounding mode and *no* error checking.
   APFloat operator/(const APFloat &RHS) const {
-    return APFloat(getIEEE() / RHS.getIEEE(), getSemantics());
+    APFloat Result(*this);
+    (void)Result.divide(RHS, rmNearestTiesToEven);
+    return Result;
   }
 
-  void changeSign() { getIEEE().changeSign(); }
-  void clearSign() { getIEEE().clearSign(); }
-  void copySign(const APFloat &RHS) { getIEEE().copySign(RHS.getIEEE()); }
+  void changeSign() {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.changeSign();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.changeSign();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+  void clearSign() {
+    if (isNegative())
+      changeSign();
+  }
+  void copySign(const APFloat &RHS) {
+    if (isNegative() != RHS.isNegative())
+      changeSign();
+  }
 
+  /// \brief A static helper to produce a copy of an APFloat value with its sign
+  /// copied from some other APFloat.
   static APFloat copySign(APFloat Value, const APFloat &Sign) {
-    return APFloat(IEEEFloat::copySign(Value.getIEEE(), Sign.getIEEE()),
-                   Value.getSemantics());
+    Value.copySign(Sign);
+    return Value;
   }
 
   opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
                    bool *losesInfo);
   opStatus convertToInteger(integerPart *Input, unsigned int Width,
                             bool IsSigned, roundingMode RM,
                             bool *IsExact) const {
-    return getIEEE().convertToInteger(Input, Width, IsSigned, RM, IsExact);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.convertToInteger(Input, Width, IsSigned, RM, IsExact);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.convertToInteger(Input, Width, IsSigned, RM, IsExact);
+    } else {
+      llvm_unreachable("Unexpected semantics");
     }
-  opStatus convertToInteger(APSInt &Result, roundingMode RM,
-                            bool *IsExact) const {
-    return getIEEE().convertToInteger(Result, RM, IsExact);
   }
+  opStatus convertToInteger(APSInt &Result, roundingMode RM,
+                            bool *IsExact) const;
   opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
                             roundingMode RM) {
-    return getIEEE().convertFromAPInt(Input, IsSigned, RM);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.convertFromAPInt(Input, IsSigned, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.convertFromAPInt(Input, IsSigned, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus convertFromSignExtendedInteger(const integerPart *Input,
                                           unsigned int InputSize, bool IsSigned,
                                           roundingMode RM) {
-    return getIEEE().convertFromSignExtendedInteger(Input, InputSize, IsSigned,
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.convertFromSignExtendedInteger(Input, InputSize, IsSigned,
+                                                   RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.convertFromSignExtendedInteger(Input, InputSize, IsSigned,
                                                      RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus convertFromZeroExtendedInteger(const integerPart *Input,
                                           unsigned int InputSize, bool IsSigned,
                                           roundingMode RM) {
-    return getIEEE().convertFromZeroExtendedInteger(Input, InputSize, IsSigned,
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.convertFromZeroExtendedInteger(Input, InputSize, IsSigned,
+                                                   RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.convertFromZeroExtendedInteger(Input, InputSize, IsSigned,
                                                      RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
   opStatus convertFromString(StringRef, roundingMode);
-  APInt bitcastToAPInt() const { return getIEEE().bitcastToAPInt(); }
+  APInt bitcastToAPInt() const {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.bitcastToAPInt();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.bitcastToAPInt();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
   double convertToDouble() const { return getIEEE().convertToDouble(); }
   float convertToFloat() const { return getIEEE().convertToFloat(); }
 
   bool operator==(const APFloat &) const = delete;
 
   cmpResult compare(const APFloat &RHS) const {
-    return getIEEE().compare(RHS.getIEEE());
+    assert(&getSemantics() == &RHS.getSemantics() &&
+           "Should only compare APFloats with the same semantics");
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.compare(RHS.U.IEEE);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.compare(RHS.U.Double);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
   bool bitwiseIsEqual(const APFloat &RHS) const {
-    return getIEEE().bitwiseIsEqual(RHS.getIEEE());
+    if (&getSemantics() != &RHS.getSemantics())
+      return false;
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.bitwiseIsEqual(RHS.U.Double);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
   unsigned int convertToHexString(char *DST, unsigned int HexDigits,
                                   bool UpperCase, roundingMode RM) const {
-    return getIEEE().convertToHexString(DST, HexDigits, UpperCase, RM);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.convertToHexString(DST, HexDigits, UpperCase, RM);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.convertToHexString(DST, HexDigits, UpperCase, RM);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
   bool isZero() const { return getCategory() == fcZero; }
   bool isInfinity() const { return getCategory() == fcInfinity; }
   bool isNaN() const { return getCategory() == fcNaN; }
 
   bool isNegative() const { return getIEEE().isNegative(); }
-  bool isDenormal() const { return getIEEE().isDenormal(); }
+  bool isDenormal() const {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.isDenormal();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.isDenormal();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
   bool isSignaling() const { return getIEEE().isSignaling(); }
 
   bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
   bool isFinite() const { return !isNaN() && !isInfinity(); }
 
   fltCategory getCategory() const { return getIEEE().getCategory(); }
   const fltSemantics &getSemantics() const { return *U.semantics; }
   bool isNonZero() const { return !isZero(); }
   bool isFiniteNonZero() const { return isFinite() && !isZero(); }
   bool isPosZero() const { return isZero() && !isNegative(); }
   bool isNegZero() const { return isZero() && isNegative(); }
-  bool isSmallest() const { return getIEEE().isSmallest(); }
-  bool isLargest() const { return getIEEE().isLargest(); }
-  bool isInteger() const { return getIEEE().isInteger(); }
+  bool isSmallest() const {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.isSmallest();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.isSmallest();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+  bool isLargest() const {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.isLargest();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.isLargest();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
+  bool isInteger() const {
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.isInteger();
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.isInteger();
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
+  }
 
   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);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.toString(Str, FormatPrecision, FormatMaxPadding);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.toString(Str, FormatPrecision, FormatMaxPadding);
+    } else {
+      llvm_unreachable("Unexpected semantics");
+    }
   }
 
   void print(raw_ostream &) const;
   void dump() const;
 
   bool getExactInverse(APFloat *inv) const {
-    return getIEEE().getExactInverse(inv ? &inv->getIEEE() : nullptr);
+    if (usesLayout<IEEEFloat>(getSemantics())) {
+      return U.IEEE.getExactInverse(inv);
+    } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+      return U.Double.getExactInverse(inv);
+    } else {
+      llvm_unreachable("Unexpected semantics");
     }
-
-  // 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);
 inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
-  return APFloat(scalbn(X.getIEEE(), Exp, RM), X.getSemantics());
+  if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) {
+    return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
+  } else if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) {
+    return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
+  } else {
+    llvm_unreachable("Unexpected semantics");
+  }
 }
 
 /// \brief Equivalent of C standard library function.
 ///
 /// While the C standard says Exp is an unspecified value for infinity and nan,
 /// this returns INT_MAX for infinities, and INT_MIN for NaNs.
 inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
-  return APFloat(frexp(X.getIEEE(), Exp, RM), X.getSemantics());
+  if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) {
+    return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics());
+  } else if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) {
+    return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics());
+  } else {
+    llvm_unreachable("Unexpected semantics");
+  }
 }
 /// \brief Returns the absolute value of the argument.
 inline APFloat abs(APFloat X) {
   X.clearSign();
   return X;
 }
 
 /// Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if

llvm/lib/Support/APFloat.cpp

namespace llvm {
   static const fltSemantics semPPCDoubleDouble = {0, 0, 0, 0};
 
   /* There are temporary semantics for the real PPCDoubleDouble implementation.
      Currently, APFloat of PPCDoubleDouble holds one PPCDoubleDoubleImpl as the
      high part of double double, and one IEEEdouble as the low part, so that
      the old operations operate on PPCDoubleDoubleImpl, while the newly added
      operations also populate the IEEEdouble.
 
      TODO: Once all functions support DoubleAPFloat mode, we'll change all
      PPCDoubleDoubleImpl to IEEEdouble and remove PPCDoubleDoubleImpl.  */
   static const fltSemantics semPPCDoubleDoubleImpl = {1023, -1022 + 53, 53 + 53,
                                                       128};
 
   const fltSemantics &APFloatBase::IEEEhalf() {
     return semIEEEhalf;
   }
   const fltSemantics &APFloatBase::IEEEsingle() {
     return semIEEEsingle;
   }
   const fltSemantics &APFloatBase::IEEEdouble() {

 }
 
 IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
   *this = std::move(rhs);
 }
 
 IEEEFloat::~IEEEFloat() { freeSignificand(); }
 
-// Profile - This method 'profiles' an APFloat for use with FoldingSet.
-void IEEEFloat::Profile(FoldingSetNodeID &ID) const {
-  ID.Add(bitcastToAPInt());
-}
-
 unsigned int IEEEFloat::partCount() const {
   return partCountForBits(semantics->precision + 1);
 }
 
 const integerPart *IEEEFloat::significandParts() const {
   return const_cast<IEEEFloat *>(this)->significandParts();
 }
 

 }
 
 /* Change sign.  */
 void IEEEFloat::changeSign() {
   /* Look mummy, this one's easy.  */
   sign = !sign;
 }
 
-void IEEEFloat::clearSign() {
-  /* So is this one. */
-  sign = 0;
-}
-
-void IEEEFloat::copySign(const IEEEFloat &rhs) {
-  /* And this one. */
-  sign = rhs.sign;
-}
-
 /* Normalized addition or subtraction.  */
 IEEEFloat::opStatus IEEEFloat::addOrSubtract(const IEEEFloat &rhs,
                                              roundingMode rounding_mode,
                                              bool subtract) {
   opStatus fs;
 
   fs = addOrSubtractSpecials(rhs, subtract);
 
IEEEFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
   // for our integral rounding as well.
   // NOTE: When the input value is negative, we do subtraction followed by
   // addition instead.
   APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
   IntegerConstant <<= semanticsPrecision(*semantics)-1;
   IEEEFloat MagicConstant(*semantics);
   fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
                                       rmNearestTiesToEven);
-  MagicConstant.copySign(*this);
+  MagicConstant.sign = sign;
 
   if (fs != opOK)
     return fs;
 
   // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
   bool inputSign = isNegative();
 
   fs = add(MagicConstant, rounding_mode);
if (fs == opInvalidOp) {
     APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
     if (sign && isSigned)
       APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
   }
 
   return fs;
 }
 
-/* Same as convertToInteger(integerPart*, ...), except the result is returned in
-   an APSInt, whose initial bit-width and signed-ness are used to determine the
-   precision of the conversion.
- */
-IEEEFloat::opStatus IEEEFloat::convertToInteger(APSInt &result,
-                                                roundingMode rounding_mode,
-                                                bool *isExact) const {
-  unsigned bitWidth = result.getBitWidth();
-  SmallVector<uint64_t, 4> parts(result.getNumWords());
-  opStatus status = convertToInteger(
-    parts.data(), bitWidth, result.isSigned(), rounding_mode, isExact);
-  // Keeps the original signed-ness.
-  result = APInt(bitWidth, parts);
-  return status;
-}
-
 /* Convert an unsigned integer SRC to a floating point number,
    rounding according to ROUNDING_MODE.  The sign of the floating
    point number is not modified.  */
 IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
     const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
   unsigned int omsb, precision, dstCount;
   integerPart *dst;
   lostFraction lost_fraction;
if (NWholeDigits > 0) {
     for (unsigned Z = 1; Z != NZeros; ++Z)
       Str.push_back('0');
   }
 
   for (; I != NDigits; ++I)
     Str.push_back(buffer[NDigits-I-1]);
 }
 
-bool IEEEFloat::getExactInverse(IEEEFloat *inv) const {
+bool IEEEFloat::getExactInverse(APFloat *inv) const {
   // Special floats and denormals have no exact inverse.
   if (!isFiniteNonZero())
     return false;
 
   // Check that the number is a power of two by making sure that only the
   // integer bit is set in the significand.
   if (significandLSB() != semantics->precision - 1)
     return false;
 
   // Get the inverse.
   IEEEFloat reciprocal(*semantics, 1ULL);
   if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
     return false;
 
   // Avoid multiplication with a denormal, it is not safe on all platforms and
   // may be slower than a normal division.
   if (reciprocal.isDenormal())
     return false;
 
   assert(reciprocal.isFiniteNonZero() &&
          reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
 
   if (inv)
-    *inv = reciprocal;
+    *inv = APFloat(reciprocal, *semantics);
 
   return true;
 }
 
 bool IEEEFloat::isSignaling() const {
   if (!isNaN())
     return false;
 
IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM) {
 
   // 1 is added because frexp is defined to return a normalized fraction in
   // +/-[0.5, 1.0), rather than the usual +/-[1.0, 2.0).
   Exp = Exp == IEEEFloat::IEK_Zero ? 0 : Exp + 1;
   return scalbn(Val, -Exp, RM);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S)
-    : Semantics(&S), Floats(new APFloat[2]{APFloat(semPPCDoubleDoubleImpl),
-                                           APFloat(semIEEEdouble)}) {
+    : Semantics(&S),
+      Floats(new APFloat[2]{APFloat(semIEEEdouble), APFloat(semIEEEdouble)}) {
   assert(Semantics == &semPPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, uninitializedTag)
     : Semantics(&S),
-      Floats(new APFloat[2]{APFloat(semPPCDoubleDoubleImpl, uninitialized),
+      Floats(new APFloat[2]{APFloat(semIEEEdouble, uninitialized),
                             APFloat(semIEEEdouble, uninitialized)}) {
   assert(Semantics == &semPPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
-    : Semantics(&S), Floats(new APFloat[2]{APFloat(semPPCDoubleDoubleImpl, I),
+    : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
                                            APFloat(semIEEEdouble)}) {
   assert(Semantics == &semPPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const APInt &I)
-    : Semantics(&S), Floats(new APFloat[2]{
-                         APFloat(semPPCDoubleDoubleImpl, I),
-                         APFloat(semIEEEdouble, APInt(64, I.getRawData()[1]))}) {
+    : Semantics(&S),
+      Floats(new APFloat[2]{
+          APFloat(semIEEEdouble, APInt(64, I.getRawData()[0])),
   assert(Semantics == &semPPCDoubleDouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
                              APFloat &&Second)
     : Semantics(&S),
       Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
   assert(Semantics == &semPPCDoubleDouble);
-  // TODO Check for First == &IEEEdouble once the transition is done.
-  assert(&Floats[0].getSemantics() == &semPPCDoubleDoubleImpl ||
-         &Floats[0].getSemantics() == &semIEEEdouble);
+  assert(&Floats[0].getSemantics() == &semIEEEdouble);
   assert(&Floats[1].getSemantics() == &semIEEEdouble);
 }
 
 DoubleAPFloat::DoubleAPFloat(const DoubleAPFloat &RHS)
     : Semantics(RHS.Semantics),
       Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
                                          APFloat(RHS.Floats[1])}
                         : nullptr) {
if (LHS.getCategory() == fcInfinity) {
     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(semIEEEdouble,
-            APInt(64, LHS.Floats[0].bitcastToAPInt().getRawData()[0])),
-      AA(LHS.Floats[1]),
-      C(semIEEEdouble, APInt(64, RHS.Floats[0].bitcastToAPInt().getRawData()[0])),
+  APFloat A(LHS.Floats[0]), AA(LHS.Floats[1]), C(RHS.Floats[0]),
       CC(RHS.Floats[1]);
+  assert(&A.getSemantics() == &semIEEEdouble);
   assert(&AA.getSemantics() == &semIEEEdouble);
+  assert(&C.getSemantics() == &semIEEEdouble);
   assert(&CC.getSemantics() == &semIEEEdouble);
-  Out.Floats[0] = APFloat(semIEEEdouble);
+  assert(&Out.Floats[0].getSemantics() == &semIEEEdouble);
   assert(&Out.Floats[1].getSemantics() == &semIEEEdouble);
-
-  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(semPPCDoubleDoubleImpl, APInt(128, 2, Buffer));
-  return Ret;
+  return Out.addImpl(A, AA, C, CC, RM);
 }
 
 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;
 }
 
+APFloat::opStatus DoubleAPFloat::multiply(const DoubleAPFloat &RHS,
+                                          APFloat::roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret =
+        Tmp.multiply(APFloat(semPPCDoubleDoubleImpl, RHS.bitcastToAPInt()), RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::divide(const DoubleAPFloat &RHS,
+                                        APFloat::roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret =
+        Tmp.divide(APFloat(semPPCDoubleDoubleImpl, RHS.bitcastToAPInt()), RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::remainder(const DoubleAPFloat &RHS) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret =
+        Tmp.remainder(APFloat(semPPCDoubleDoubleImpl, RHS.bitcastToAPInt()));
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::mod(const DoubleAPFloat &RHS) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret = Tmp.mod(APFloat(semPPCDoubleDoubleImpl, RHS.bitcastToAPInt()));
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus
+DoubleAPFloat::fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
+                                const DoubleAPFloat &Addend,
+                                APFloat::roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret = Tmp.fusedMultiplyAdd(
+        APFloat(semPPCDoubleDoubleImpl, Multiplicand.bitcastToAPInt()),
+        APFloat(semPPCDoubleDoubleImpl, Addend.bitcastToAPInt()), RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret = Tmp.roundToIntegral(RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
 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]);

 
 bool DoubleAPFloat::isNegative() const { return Floats[0].isNegative(); }
 
 void DoubleAPFloat::makeInf(bool Neg) {
   Floats[0].makeInf(Neg);
   Floats[1].makeZero(false);
 }
 
+void DoubleAPFloat::makeZero(bool Neg) {
+  Floats[0].makeZero(Neg);
+  Floats[1].makeZero(false);
+}
+
+void DoubleAPFloat::makeLargest(bool Neg) {
+  if (Semantics == &semPPCDoubleDouble) {
+    Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x7fefffffffffffffull));
+    Floats[1] = APFloat(semIEEEdouble, APInt(64, 0x7c8ffffffffffffeull));
+    if (Neg)
+      changeSign();
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+void DoubleAPFloat::makeSmallest(bool Neg) {
+  if (Semantics == &semPPCDoubleDouble) {
+    Floats[0].makeSmallest(Neg);
+    Floats[1].makeZero(false);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+void DoubleAPFloat::makeSmallestNormalized(bool Neg) {
+  if (Semantics == &semPPCDoubleDouble) {
+    Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x0360000000000000ull));
+    if (Neg)
+      Floats[0].changeSign();
+    Floats[1].makeZero(false);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
 void DoubleAPFloat::makeNaN(bool SNaN, bool Neg, const APInt *fill) {
   Floats[0].makeNaN(SNaN, Neg, fill);
   Floats[1].makeZero(false);
 }
 
+APFloat::cmpResult DoubleAPFloat::compare(const DoubleAPFloat &RHS) const {
+  auto Result = Floats[0].compare(RHS.Floats[0]);
+  if (Result == APFloat::cmpEqual)
+    return Floats[1].compare(RHS.Floats[1]);
+  return Result;
+}
+
+bool DoubleAPFloat::bitwiseIsEqual(const DoubleAPFloat &RHS) const {
+  return Floats[0].bitwiseIsEqual(RHS.Floats[0]) &&
+         Floats[1].bitwiseIsEqual(RHS.Floats[1]);
+}
+
+hash_code hash_value(const DoubleAPFloat &Arg) {
+  if (Arg.Floats)
+    return hash_combine(hash_value(Arg.Floats[0]), hash_value(Arg.Floats[1]));
+  return hash_combine(Arg.Semantics);
+}
+
+APInt DoubleAPFloat::bitcastToAPInt() const {
+  if (Semantics == &semPPCDoubleDouble) {
+    uint64_t Data[] = {
+        Floats[0].bitcastToAPInt().getRawData()[0],
+        Floats[1].bitcastToAPInt().getRawData()[0],
+    };
+    return APInt(128, 2, Data);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::convertFromString(StringRef S,
+                                                   roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl);
+    auto Ret = Tmp.convertFromString(S, RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    auto Ret = Tmp.next(nextDown);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::convertToInteger(integerPart *Input,
+                                                  unsigned int Width,
+                                                  bool IsSigned,
+                                                  roundingMode RM,
+                                                  bool *IsExact) const {
+  if (Semantics == &semPPCDoubleDouble) {
+    return APFloat(semPPCDoubleDoubleImpl, bitcastToAPInt())
+        .convertToInteger(Input, Width, IsSigned, RM, IsExact);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
+                                                  bool IsSigned,
+                                                  roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl);
+    auto Ret = Tmp.convertFromAPInt(Input, IsSigned, RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus
+DoubleAPFloat::convertFromSignExtendedInteger(const integerPart *Input,
+                                              unsigned int InputSize,
+                                              bool IsSigned, roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl);
+    auto Ret =
+        Tmp.convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+APFloat::opStatus
+DoubleAPFloat::convertFromZeroExtendedInteger(const integerPart *Input,
+                                              unsigned int InputSize,
+                                              bool IsSigned, roundingMode RM) {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl);
+    auto Ret =
+        Tmp.convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM);
+    *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+unsigned int DoubleAPFloat::convertToHexString(char *DST,
+                                               unsigned int HexDigits,
+                                               bool UpperCase,
+                                               roundingMode RM) const {
+  if (Semantics == &semPPCDoubleDouble) {
+    return APFloat(semPPCDoubleDoubleImpl, bitcastToAPInt())
+        .convertToHexString(DST, HexDigits, UpperCase, RM);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+bool DoubleAPFloat::isDenormal() const {
+  return getCategory() == fcNormal &&
+         (Floats[0].isDenormal() || Floats[1].isDenormal() ||
+          Floats[0].compare(Floats[0] + Floats[1]) != cmpEqual);
+}
+
+bool DoubleAPFloat::isSmallest() const {
+  if (getCategory() != fcNormal)
+    return false;
+  DoubleAPFloat Tmp(*this);
+  Tmp.makeSmallest(this->isNegative());
+  return Tmp.compare(*this) == cmpEqual;
+}
+
+bool DoubleAPFloat::isLargest() const {
+  if (getCategory() != fcNormal)
+    return false;
+  DoubleAPFloat Tmp(*this);
+  Tmp.makeLargest(this->isNegative());
+  return Tmp.compare(*this) == cmpEqual;
+}
+
+bool DoubleAPFloat::isInteger() const {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl);
+    (void)Tmp.add(Floats[0], rmNearestTiesToEven);
+    (void)Tmp.add(Floats[1], rmNearestTiesToEven);
+    return Tmp.isInteger();
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+void DoubleAPFloat::toString(SmallVectorImpl<char> &Str,
+                             unsigned FormatPrecision,
+                             unsigned FormatMaxPadding) const {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat(semPPCDoubleDoubleImpl, bitcastToAPInt())
+        .toString(Str, FormatPrecision, FormatMaxPadding);
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
+  if (Semantics == &semPPCDoubleDouble) {
+    APFloat Tmp(semPPCDoubleDoubleImpl, bitcastToAPInt());
+    if (!inv)
+      return Tmp.getExactInverse(nullptr);
+    APFloat Inv(semPPCDoubleDoubleImpl);
+    auto Ret = Tmp.getExactInverse(&Inv);
+    *inv = APFloat(semPPCDoubleDouble, Inv.bitcastToAPInt());
+    return Ret;
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+DoubleAPFloat scalbn(DoubleAPFloat Arg, int Exp, APFloat::roundingMode RM) {
+  if (Arg.Semantics == &semPPCDoubleDouble) {
+    return DoubleAPFloat(semPPCDoubleDouble, scalbn(Arg.Floats[0], Exp, RM),
+                         scalbn(Arg.Floats[1], Exp, RM));
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
+DoubleAPFloat frexp(const DoubleAPFloat &Arg, int &Exp,
+                    APFloat::roundingMode RM) {
+  if (Arg.Semantics == &semPPCDoubleDouble) {
+    APFloat First = frexp(Arg.Floats[0], Exp, RM);
+    APFloat Second = Arg.Floats[1];
+    if (Arg.getCategory() == APFloat::fcNormal)
+      Second = scalbn(Second, -Exp, RM);
+    return DoubleAPFloat(semPPCDoubleDouble, std::move(First),
+                         std::move(Second));
+  } else {
+    llvm_unreachable("Only PPCDoubleDouble is supported for now");
+  }
+}
+
 } // 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()),
                       APFloat(semIEEEdouble));
   } else {
     llvm_unreachable("Unexpected semantics");
   }
 }
 
 APFloat::opStatus APFloat::convertFromString(StringRef Str, roundingMode RM) {
-  return getIEEE().convertFromString(Str, RM);
+  if (usesLayout<IEEEFloat>(getSemantics())) {
+    return U.IEEE.convertFromString(Str, RM);
+  } else if (usesLayout<DoubleAPFloat>(getSemantics())) {
+    return U.Double.convertFromString(Str, RM);
+  } else {
+    llvm_unreachable("Unexpected semantics");
+  }
 }
 
-hash_code hash_value(const APFloat &Arg) { return hash_value(Arg.getIEEE()); }
+hash_code hash_value(const APFloat &Arg) {
+  if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics())) {
+    return hash_value(Arg.U.IEEE);
+  } else if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics())) {
+    return hash_value(Arg.U.Double);
+  } else {
+    llvm_unreachable("Unexpected semantics");
+  }
+}
 
 APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
     : APFloat(Semantics) {
   convertFromString(S, rmNearestTiesToEven);
 }
 
 APFloat::opStatus APFloat::convert(const fltSemantics &ToSemantics,
                                    roundingMode RM, bool *losesInfo) {
   if (&getSemantics() == &ToSemantics)
     return opOK;
   if (usesLayout<IEEEFloat>(getSemantics()) &&
       usesLayout<IEEEFloat>(ToSemantics)) {
     return U.IEEE.convert(ToSemantics, RM, losesInfo);
   } else if (usesLayout<IEEEFloat>(getSemantics()) &&
              usesLayout<DoubleAPFloat>(ToSemantics)) {
     assert(&ToSemantics == &semPPCDoubleDouble);
     auto Ret = U.IEEE.convert(semPPCDoubleDoubleImpl, RM, losesInfo);
-    *this = APFloat(
-        DoubleAPFloat(semPPCDoubleDouble, std::move(*this), APFloat(semIEEEdouble)),
-        ToSemantics);
+    *this = APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
     return Ret;
   } else if (usesLayout<DoubleAPFloat>(getSemantics()) &&
              usesLayout<IEEEFloat>(ToSemantics)) {
     auto Ret = getIEEE().convert(ToSemantics, RM, losesInfo);
     *this = APFloat(std::move(getIEEE()), ToSemantics);
     return Ret;
   } else {
     llvm_unreachable("Unexpected semantics");

 void APFloat::print(raw_ostream &OS) const {
   SmallVector<char, 16> Buffer;
   toString(Buffer);
   OS << Buffer << "\n";
 }
 
 void APFloat::dump() const { print(dbgs()); }
 
+void APFloat::Profile(FoldingSetNodeID &NID) const {
+  NID.Add(bitcastToAPInt());
+}
+
+/* Same as convertToInteger(integerPart*, ...), except the result is returned in
+   an APSInt, whose initial bit-width and signed-ness are used to determine the
+   precision of the conversion.
+ */
+APFloat::opStatus APFloat::convertToInteger(APSInt &result,
+                                            roundingMode rounding_mode,
+                                            bool *isExact) const {
+  unsigned bitWidth = result.getBitWidth();
+  SmallVector<uint64_t, 4> parts(result.getNumWords());
+  opStatus status = convertToInteger(parts.data(), bitWidth, result.isSigned(),
+                                     rounding_mode, isExact);
+  // Keeps the original signed-ness.
+  result = APInt(bitWidth, parts);
+  return status;
+}
+
 } // End llvm namespace

llvm/test/CodeGen/PowerPC/fp128-bitcast-after-operation.ll

 ; PPC32: stfd 1, [[STACK:[0-9]+]](1)
 ; PPC32: nop
 ; PPC32: lwz [[HI:[0-9]+]], [[STACK]](1)
 ; PPC32: rlwinm [[FLIP_BIT:[0-9]+]], [[HI]], 0, 0, 0
 ; PPC32-NOT: BARRIER
 ; PPC32-DAG: oris {{[0-9]+}}, [[FLIP_BIT]], 16399
 ; PPC32-DAG: xoris {{[0-9]+}}, [[FLIP_BIT]], 48304
 ; PPC32: blr
-  %0 = tail call ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 0xMBCB0000000000000400F000000000000, ppc_fp128 %x)
+  %0 = tail call ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 0xM400F000000000000BCB0000000000000, ppc_fp128 %x)
   %1 = bitcast ppc_fp128 %0 to i128
   ret i128 %1
 }
 
 declare ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128)
 declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128, ppc_fp128)

llvm/unittests/ADT/APFloatTest.cpp

 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <cmath>
 #include <ostream>
 #include <string>
 #include <tuple>
for (auto Tp : Data) {
     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])
         << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                    Op2[1])
                .str();
-    EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
+    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
         << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                    Op2[1])
                .str();
   }
 }
 
 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
for (auto Tp : Data) {
     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])
         << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                    Op2[1])
                .str();
-    EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
+    EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
         << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                    Op2[1])
                .str();
   }
 }
 
 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
TEST(APFloatTest, PPCDoubleDoubleCompare) {
   for (auto Tp : Data) {
     uint64_t Op1[2], Op2[2];
     APFloat::cmpResult Expected;
     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
 
     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
     EXPECT_EQ(Expected, A1.compare(A2))
-        << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+        << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
+                   Op2[0], Op2[1])
+               .str();
+  }
+}
+
+TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
+  using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
+
+  DataType Data[] = {
+      // (1 + 0) = (1 + 0)
+      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
+      // (1 + 0) != (1.00...1 + 0)
+      std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
+                      false),
+      // NaN = NaN
+      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
+      // NaN != NaN with a different bit pattern
+      std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
+                      0x3ff0000000000000ull, false),
+      // Inf = Inf
+      std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
+  };
+
+  for (auto Tp : Data) {
+    uint64_t Op1[2], Op2[2];
+    bool Expected;
+    std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
+
+    APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
+    APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
+    EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
+        << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
                    Op2[1])
                .str();
   }
 }
 
+TEST(APFloatTest, PPCDoubleDoubleHashValue) {
+  uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
+  uint64_t Data2[] = {0x3ff0000000000001ull, 0};
+  // The hash values are *hopefully* different.
+  EXPECT_NE(
+      hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
+      hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
+}
+
 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
   uint64_t Data[] = {
       0x400f000000000000ull, 0xbcb0000000000000ull,
   };
   APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
   {
     APFloat Actual =
         APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
TEST(APFloatTest, PPCDoubleDoubleFactories) {
     uint64_t Data[] = {
         0, 0,
     };
     EXPECT_EQ(APInt(128, 2, Data),
               APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
   }
   {
     uint64_t Data[] = {
+        0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
+    };
+    EXPECT_EQ(APInt(128, 2, Data),
+              APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
+  }
+  {
+    uint64_t Data[] = {
         0x0000000000000001ull, 0,
     };
     EXPECT_EQ(
         APInt(128, 2, Data),
         APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
   }
   {
     uint64_t Data[] = {0x0360000000000000ull, 0};
     EXPECT_EQ(APInt(128, 2, Data),
               APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
                   .bitcastToAPInt());
   }
   {
     uint64_t Data[] = {
         0x8000000000000000ull, 0x0000000000000000ull,
     };
     EXPECT_EQ(
         APInt(128, 2, Data),
         APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
   }
   {
     uint64_t Data[] = {
+        0xffefffffffffffffull, 0xfc8ffffffffffffeull,
+    };
+    EXPECT_EQ(
+        APInt(128, 2, Data),
+        APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
+  }
+  {
+    uint64_t Data[] = {
         0x8000000000000001ull, 0x0000000000000000ull,
     };
     EXPECT_EQ(APInt(128, 2, Data),
               APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
                   .bitcastToAPInt());
   }
-
-  EXPECT_EQ(0x8360000000000000ull,
-            APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
-                .bitcastToAPInt()
-                .getRawData()[0]);
-  EXPECT_EQ(0x0000000000000000ull,
+  {
+    uint64_t Data[] = {
+        0x8360000000000000ull, 0x0000000000000000ull,
+    };
+    EXPECT_EQ(APInt(128, 2, Data),
               APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
-                .getSecondFloat()
-                .bitcastToAPInt()
-                .getRawData()[0]);
-
+                  .bitcastToAPInt());
+  }
   EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
   EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
 }
+
+TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
+  EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
+  EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
+  EXPECT_FALSE(
+      APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
+  {
+    // (4 + 3) is not normalized
+    uint64_t Data[] = {
+        0x4010000000000000ull, 0x4008000000000000ull,
+    };
+    EXPECT_TRUE(
+        APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
+  }
+}
+
+TEST(APFloatTest, PPCDoubleDoubleScalbn) {
+  // 3.0 + 3.0 << 53
+  uint64_t Input[] = {
+      0x4008000000000000ull, 0x3cb8000000000000ull,
+  };
+  APFloat Result =
+      scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
+             APFloat::rmNearestTiesToEven);
+  // 6.0 + 6.0 << 53
+  EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
+  EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
+}
+
+TEST(APFloatTest, PPCDoubleDoubleFrexp) {
+  // 3.0 + 3.0 << 53
+  uint64_t Input[] = {
+      0x4008000000000000ull, 0x3cb8000000000000ull,
+  };
+  int Exp;
+  // 0.75 + 0.75 << 53
+  APFloat Result =
+      frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
+            APFloat::rmNearestTiesToEven);
+  EXPECT_EQ(2, Exp);
+  EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
+  EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
+}
 }