[APFloat] Make APFloat an interface class to the internal IEEEFloat. NFC.

[timshen]

Summary

The intention is to make APFloat an interface class, so that later I can add a second implementation class DoubleAPFloat to correctly implement PPCDoubleDouble semantic. The interface of IEEEFloat is not public, and can be simplified (currently it's exactly the same as the old APFloat), but that (if exists) belongs to a separate patch.

DoubleAPFloat should look like:

class DoubleAPFloat {
  const fltSemantics *Semantics;
  std::unique_ptr<APFloat[]> APFloats;  // Two heap-allocated APFloats.
};

There is no functional change, nor public interface change.

[hfinkel]

To be clear, you plan is to later change:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
};

to be something like:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  PPCDoubleDouble PPCDD;
};

and then make:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return IEEE.divide(RHS.IEEE, RM);
}

into:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return isPPCDoubleDouble() ? PPCDD.divide(RHS, RM) : IEEE.divide(RHS, RM);
}

or similar?

[timshen]

In D25536#568766, @hfinkel wrote:

To be clear, you plan is to later change:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
};

to be something like:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  PPCDoubleDouble PPCDD;
};

and then make:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return IEEE.divide(RHS.IEEE, RM);
}

into:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return isPPCDoubleDouble() ? PPCDD.divide(RHS, RM) : IEEE.divide(RHS, RM);
}

or similar?

Yes, this is the plan.

[hfinkel]

In D25536#568792, @timshen wrote:

In D25536#568766, @hfinkel wrote:

To be clear, you plan is to later change:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
};

to be something like:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  PPCDoubleDouble PPCDD;
};

and then make:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return IEEE.divide(RHS.IEEE, RM);
}

into:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return isPPCDoubleDouble() ? PPCDD.divide(RHS, RM) : IEEE.divide(RHS, RM);
}

or similar?

Yes, this is the plan.

Makes sense to me. Opinions from anyone else?

[echristo]

In D25536#568978, @hfinkel wrote:

In D25536#568792, @timshen wrote:

In D25536#568766, @hfinkel wrote:

To be clear, you plan is to later change:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
};

to be something like:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  PPCDoubleDouble PPCDD;
};

and then make:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return IEEE.divide(RHS.IEEE, RM);
}

into:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return isPPCDoubleDouble() ? PPCDD.divide(RHS, RM) : IEEE.divide(RHS, RM);
}

or similar?

Yes, this is the plan.

Makes sense to me. Opinions from anyone else?

Seems reasonable and the easiest solution here.

-eric

In D25536#568978, @hfinkel wrote:

In D25536#568792, @timshen wrote:

In D25536#568766, @hfinkel wrote:

To be clear, you plan is to later change:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
};

to be something like:

union {
  const fltSemantics *semantics;
  IEEEFloat IEEE;
  PPCDoubleDouble PPCDD;
};

and then make:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return IEEE.divide(RHS.IEEE, RM);
}

into:

opStatus divide(const APFloat &RHS, roundingMode RM) {
  return isPPCDoubleDouble() ? PPCDD.divide(RHS, RM) : IEEE.divide(RHS, RM);
}

or similar?

Yes, this is the plan.

Makes sense to me. Opinions from anyone else?

[hfinkel]

llvm/include/llvm/ADT/APFloat.h

127

I think this should be named APFloatBase (e.g. we have DenseMapBase, SmallPtrSetImplBase, StringMapEntryBase).

[timshen]

s/APFloatStatic/APFloatBase/

[kbarton]

Sounds good to me also!

[kbarton]

LGTM.
I went through this fairly carefully and couldn't spot anything wrong. I think there are some opportunities to make some of the methods const, but that would be outside the scope of this patch.

llvm/include/llvm/ADT/APFloat.h

 ///
 /// Optional ability to detect underflow tininess before rounding.
 ///
 /// New formats: x87 in single and double precision mode (IEEE apart from
 /// extended exponent range) (hard).
 ///
 /// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward.
 ///
-class APFloat {
-public:
 
+// This is the common type definitions shared by APFloat and its internal
+// implementation classes. This struct should not define any non-static data
+// members.
+struct APFloatBase {
   /// A signed type to represent a floating point numbers unbiased exponent.
   typedef signed short ExponentType;
 
   /// \name Floating Point Semantics.
   /// @{
 
   static const fltSemantics IEEEhalf;
   static const fltSemantics IEEEsingle;
   static const fltSemantics IEEEdouble;
   static const fltSemantics IEEEquad;
   static const fltSemantics PPCDoubleDouble;
   static const fltSemantics x87DoubleExtended;
 
   /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with
   /// anything real.
   static const fltSemantics Bogus;
 
   /// @}
 
-  static unsigned int semanticsPrecision(const fltSemantics &);
-  static ExponentType semanticsMinExponent(const fltSemantics &);
-  static ExponentType semanticsMaxExponent(const fltSemantics &);
-  static unsigned int semanticsSizeInBits(const fltSemantics &);
-
   /// IEEE-754R 5.11: Floating Point Comparison Relations.
   enum cmpResult {
     cmpLessThan,
     cmpEqual,
     cmpGreaterThan,
     cmpUnordered
   };
 
enum fltCategory {
     fcZero
   };
 
   /// Convenience enum used to construct an uninitialized APFloat.
   enum uninitializedTag {
     uninitialized
   };
 
+  /// \brief Enumeration of \c ilogb error results.
+  enum IlogbErrorKinds {
+    IEK_Zero = INT_MIN + 1,
+    IEK_NaN = INT_MIN,
+    IEK_Inf = INT_MAX
+  };
+
+  static unsigned int semanticsPrecision(const fltSemantics &);
+  static ExponentType semanticsMinExponent(const fltSemantics &);
+  static ExponentType semanticsMaxExponent(const fltSemantics &);
+  static unsigned int semanticsSizeInBits(const fltSemantics &);
+
+  /// Returns the size of the floating point number (in bits) in the given
+  /// semantics.
+  static unsigned getSizeInBits(const fltSemantics &Sem);
+};
+
+namespace detail {
+
+class IEEEFloat : public APFloatBase {
+public:
   /// \name Constructors
   /// @{
 
-  APFloat(const fltSemantics &); // Default construct to 0.0
-  APFloat(const fltSemantics &, StringRef);
-  APFloat(const fltSemantics &, integerPart);
-  APFloat(const fltSemantics &, uninitializedTag);
-  APFloat(const fltSemantics &, const APInt &);
-  explicit APFloat(double d);
-  explicit APFloat(float f);
-  APFloat(const APFloat &);
-  APFloat(APFloat &&);
-  ~APFloat();
+  IEEEFloat(const fltSemantics &); // Default construct to 0.0
+  IEEEFloat(const fltSemantics &, StringRef);
+  IEEEFloat(const fltSemantics &, integerPart);
+  IEEEFloat(const fltSemantics &, uninitializedTag);
+  IEEEFloat(const fltSemantics &, const APInt &);
+  explicit IEEEFloat(double d);
+  explicit IEEEFloat(float f);
+  IEEEFloat(const IEEEFloat &);
+  IEEEFloat(IEEEFloat &&);
+  ~IEEEFloat();
 
   /// @}
 
   /// \brief Returns whether this instance allocated memory.
   bool needsCleanup() const { return partCount() > 1; }
 
   /// \name Convenience "constructors"
   /// @{
 
   /// Factory for Positive and Negative Zero.
   ///
   /// \param Negative True iff the number should be negative.
-  static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
-    APFloat Val(Sem, uninitialized);
+  static IEEEFloat getZero(const fltSemantics &Sem, bool Negative = false) {
+    IEEEFloat Val(Sem, uninitialized);
     Val.makeZero(Negative);
     return Val;
   }
 
   /// Factory for Positive and Negative Infinity.
   ///
   /// \param Negative True iff the number should be negative.
-  static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
-    APFloat Val(Sem, uninitialized);
+  static IEEEFloat getInf(const fltSemantics &Sem, bool Negative = false) {
+    IEEEFloat Val(Sem, uninitialized);
     Val.makeInf(Negative);
     return Val;
   }
 
   /// Factory for QNaN values.
   ///
   /// \param Negative - True iff the NaN generated should be negative.
   /// \param type - The unspecified fill bits for creating the NaN, 0 by
   /// default.  The value is truncated as necessary.
-  static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
+  static IEEEFloat getNaN(const fltSemantics &Sem, bool Negative = false,
                           unsigned type = 0) {
     if (type) {
       APInt fill(64, type);
       return getQNaN(Sem, Negative, &fill);
     } else {
       return getQNaN(Sem, Negative, nullptr);
     }
   }
 
   /// Factory for QNaN values.
-  static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
+  static IEEEFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
                            const APInt *payload = nullptr) {
     return makeNaN(Sem, false, Negative, payload);
   }
 
   /// Factory for SNaN values.
-  static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
+  static IEEEFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
                            const APInt *payload = nullptr) {
     return makeNaN(Sem, true, Negative, payload);
   }
 
   /// Returns the largest finite number in the given semantics.
   ///
   /// \param Negative - True iff the number should be negative
-  static APFloat getLargest(const fltSemantics &Sem, bool Negative = false);
+  static IEEEFloat getLargest(const fltSemantics &Sem, bool Negative = false);
 
   /// Returns the smallest (by magnitude) finite number in the given semantics.
   /// Might be denormalized, which implies a relative loss of precision.
   ///
   /// \param Negative - True iff the number should be negative
-  static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false);
+  static IEEEFloat getSmallest(const fltSemantics &Sem, bool Negative = false);
 
   /// Returns the smallest (by magnitude) normalized finite number in the given
   /// semantics.
   ///
   /// \param Negative - True iff the number should be negative
-  static APFloat getSmallestNormalized(const fltSemantics &Sem,
+  static IEEEFloat getSmallestNormalized(const fltSemantics &Sem,
                                          bool Negative = false);
 
   /// 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);
-
-  /// Returns the size of the floating point number (in bits) in the given
-  /// semantics.
-  static unsigned getSizeInBits(const fltSemantics &Sem);
+  static IEEEFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
 
   /// @}
 
   /// Used to insert APFloat objects, or objects that contain APFloat objects,
   /// into FoldingSets.
   void Profile(FoldingSetNodeID &NID) const;
 
   /// \name Arithmetic
   /// @{
 
-  opStatus add(const APFloat &, roundingMode);
-  opStatus subtract(const APFloat &, roundingMode);
-  opStatus multiply(const APFloat &, roundingMode);
-  opStatus divide(const APFloat &, roundingMode);
+  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 APFloat &);
+  opStatus remainder(const IEEEFloat &);
   /// C fmod, or llvm frem.
-  opStatus mod(const APFloat &);
-  opStatus fusedMultiplyAdd(const APFloat &, const APFloat &, roundingMode);
+  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.
-  APFloat operator+(const APFloat &RHS) const {
-    APFloat Result = *this;
+  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.
-  APFloat operator-(const APFloat &RHS) const {
-    APFloat Result = *this;
+  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.
-  APFloat operator*(const APFloat &RHS) const {
-    APFloat Result = *this;
+  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.
-  APFloat operator/(const APFloat &RHS) const {
-    APFloat Result = *this;
+  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 APFloat &);
+  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 APFloat copySign(APFloat Value, const APFloat &Sign) {
+  static IEEEFloat copySign(IEEEFloat Value, const IEEEFloat &Sign) {
     Value.copySign(Sign);
     return Value;
   }
 
   /// @}
 
   /// \name Conversions
   /// @{
public:
   double convertToDouble() const;
   float convertToFloat() const;
 
   /// @}
 
   /// The definition of equality is not straightforward for floating point, so
   /// we won't use operator==.  Use one of the following, or write whatever it
   /// is you really mean.
-  bool operator==(const APFloat &) const = delete;
+  bool operator==(const IEEEFloat &) const = delete;
 
   /// IEEE comparison with another floating point number (NaNs compare
   /// unordered, 0==-0).
-  cmpResult compare(const APFloat &) const;
+  cmpResult compare(const IEEEFloat &) const;
 
   /// Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
-  bool bitwiseIsEqual(const APFloat &) const;
+  bool bitwiseIsEqual(const IEEEFloat &) const;
 
   /// Write out a hexadecimal representation of the floating point value to DST,
   /// which must be of sufficient size, in the C99 form [-]0xh.hhhhp[+-]d.
   /// Return the number of characters written, excluding the terminating NUL.
   unsigned int convertToHexString(char *dst, unsigned int hexDigits,
                                   bool upperCase, roundingMode) const;
 
   /// \name IEEE-754R 5.7.2 General operations.
public:
   /// magnitude in the current semantics.
   bool isLargest() const;
   
   /// Returns true if and only if the number is an exact integer.
   bool isInteger() const;
 
   /// @}
 
-  APFloat &operator=(const APFloat &);
-  APFloat &operator=(APFloat &&);
+  IEEEFloat &operator=(const IEEEFloat &);
+  IEEEFloat &operator=(IEEEFloat &&);
 
   /// \brief Overload to compute a hash code for an APFloat value.
   ///
   /// Note that the use of hash codes for floating point values is in general
   /// frought with peril. Equality is hard to define for these values. For
   /// example, should negative and positive zero hash to different codes? Are
   /// they equal or not? This hash value implementation specifically
   /// emphasizes producing different codes for different inputs in order to
   /// be used in canonicalization and memoization. As such, equality is
   /// bitwiseIsEqual, and 0 != -0.
-  friend hash_code hash_value(const APFloat &Arg);
+  friend hash_code hash_value(const IEEEFloat &Arg);
 
   /// Converts this value into a decimal string.
   ///
   /// \param FormatPrecision The maximum number of digits of
   ///   precision to output.  If there are fewer digits available,
   ///   zero padding will not be used unless the value is
   ///   integral and small enough to be expressed in
   ///   FormatPrecision digits.  0 means to use the natural
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(APFloat *inv) const;
-
-  /// \brief Enumeration of \c ilogb error results.
-  enum IlogbErrorKinds {
-    IEK_Zero = INT_MIN+1,
-    IEK_NaN = INT_MIN,
-    IEK_Inf = INT_MAX
-  };
+  bool getExactInverse(IEEEFloat *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
   ///   Inf -> \c IEK_Inf
   ///
-  friend int ilogb(const APFloat &Arg);
+  friend int ilogb(const IEEEFloat &Arg);
 
   /// \brief Returns: X * 2^Exp for integral exponents.
-  friend APFloat scalbn(APFloat X, int Exp, roundingMode);
+  friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);
 
-  friend APFloat frexp(const APFloat &X, int &Exp, roundingMode);
+  friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode);
 
 private:
-
   /// \name Simple Queries
   /// @{
 
   integerPart *significandParts();
   const integerPart *significandParts() const;
   unsigned int partCount() const;
 
   /// @}
 
   /// \name Significand operations.
   /// @{
 
-  integerPart addSignificand(const APFloat &);
-  integerPart subtractSignificand(const APFloat &, integerPart);
-  lostFraction addOrSubtractSignificand(const APFloat &, bool subtract);
-  lostFraction multiplySignificand(const APFloat &, const APFloat *);
-  lostFraction divideSignificand(const APFloat &);
+  integerPart addSignificand(const IEEEFloat &);
+  integerPart subtractSignificand(const IEEEFloat &, integerPart);
+  lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract);
+  lostFraction multiplySignificand(const IEEEFloat &, const IEEEFloat *);
+  lostFraction divideSignificand(const IEEEFloat &);
   void incrementSignificand();
   void initialize(const fltSemantics *);
   void shiftSignificandLeft(unsigned int);
   lostFraction shiftSignificandRight(unsigned int);
   unsigned int significandLSB() const;
   unsigned int significandMSB() const;
   void zeroSignificand();
   /// Return true if the significand excluding the integral bit is all ones.
   bool isSignificandAllOnes() const;
   /// Return true if the significand excluding the integral bit is all zeros.
   bool isSignificandAllZeros() const;
 
   /// @}
 
   /// \name Arithmetic on special values.
   /// @{
 
-  opStatus addOrSubtractSpecials(const APFloat &, bool subtract);
-  opStatus divideSpecials(const APFloat &);
-  opStatus multiplySpecials(const APFloat &);
-  opStatus modSpecials(const APFloat &);
+  opStatus addOrSubtractSpecials(const IEEEFloat &, bool subtract);
+  opStatus divideSpecials(const IEEEFloat &);
+  opStatus multiplySpecials(const IEEEFloat &);
+  opStatus modSpecials(const IEEEFloat &);
 
   /// @}
 
   /// \name Special value setters.
   /// @{
 
   void makeLargest(bool Neg = false);
   void makeSmallest(bool Neg = false);
   void makeNaN(bool SNaN = false, bool Neg = false,
                const APInt *fill = nullptr);
-  static APFloat makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
+  static IEEEFloat makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
                            const APInt *fill);
   void makeInf(bool Neg = false);
   void makeZero(bool Neg = false);
   void makeQuiet();
 
   /// @}
 
   /// \name Miscellany
   /// @{
 
   bool convertFromStringSpecials(StringRef str);
   opStatus normalize(roundingMode, lostFraction);
-  opStatus addOrSubtract(const APFloat &, roundingMode, bool subtract);
-  cmpResult compareAbsoluteValue(const APFloat &) const;
+  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);
private:
   void initFromAPInt(const fltSemantics *Sem, const APInt &api);
   void initFromHalfAPInt(const APInt &api);
   void initFromFloatAPInt(const APInt &api);
   void initFromDoubleAPInt(const APInt &api);
   void initFromQuadrupleAPInt(const APInt &api);
   void initFromF80LongDoubleAPInt(const APInt &api);
   void initFromPPCDoubleDoubleAPInt(const APInt &api);
 
-  void assign(const APFloat &);
-  void copySignificand(const APFloat &);
+  void assign(const IEEEFloat &);
+  void copySignificand(const IEEEFloat &);
   void freeSignificand();
 
   /// The semantics that this value obeys.
   const fltSemantics *semantics;
 
   /// A binary fraction with an explicit integer bit.
   ///
   /// The significand must be at least one bit wider than the target precision.
private:
   /// Only 2 bits are required, but VisualStudio incorrectly sign extends it.
   /// Using the extra bit keeps it from failing under VisualStudio.
   fltCategory category : 3;
 
   /// Sign bit of the number.
   unsigned int sign : 1;
 };
 
+hash_code hash_value(const IEEEFloat &Arg);
+int ilogb(const IEEEFloat &Arg);
+IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
+IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
+
+} // End detail namespace
+
+// This is a interface class that is currently forwarding functionalities from
+// detail::IEEEFloat.
+class APFloat : public APFloatBase {
+  typedef detail::IEEEFloat IEEEFloat;
+
+  static_assert(std::is_standard_layout<IEEEFloat>::value, "");
+
+  union {
+    const fltSemantics *semantics;
+    IEEEFloat IEEE;
+  };
+
+  explicit APFloat(IEEEFloat F) : IEEE(std::move(F)) {}
+
+public:
+  APFloat(const fltSemantics &Semantics) : APFloat(IEEEFloat(Semantics)) {}
+  APFloat(const fltSemantics &Semantics, StringRef S);
+  APFloat(const fltSemantics &Semantics, integerPart I)
+      : APFloat(IEEEFloat(Semantics, I)) {}
+  APFloat(const fltSemantics &Semantics, uninitializedTag U)
+      : APFloat(IEEEFloat(Semantics, U)) {}
+  APFloat(const fltSemantics &Semantics, const APInt &I)
+      : APFloat(IEEEFloat(Semantics, I)) {}
+  explicit APFloat(double d) : APFloat(IEEEFloat(d)) {}
+  explicit APFloat(float f) : APFloat(IEEEFloat(f)) {}
+  APFloat(const APFloat &RHS) : APFloat(IEEEFloat(RHS.IEEE)) {}
+  APFloat(APFloat &&RHS) : APFloat(IEEEFloat(std::move(RHS.IEEE))) {}
+
+  ~APFloat() { IEEE.~IEEEFloat(); }
+
+  bool needsCleanup() const { return IEEE.needsCleanup(); }
+
+  static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
+    return APFloat(IEEEFloat::getZero(Sem, Negative));
+  }
+
+  static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
+    return APFloat(IEEEFloat::getInf(Sem, Negative));
+  }
+
+  static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
+                        unsigned type = 0) {
+    return APFloat(IEEEFloat::getNaN(Sem, Negative, type));
+  }
+
+  static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
+                         const APInt *payload = nullptr) {
+    return APFloat(IEEEFloat::getQNaN(Sem, Negative, payload));
+  }
+
+  static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
+                         const APInt *payload = nullptr) {
+    return APFloat(IEEEFloat::getSNaN(Sem, Negative, payload));
+  }
+
+  static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) {
+    return APFloat(IEEEFloat::getLargest(Sem, Negative));
+  }
+
+  static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) {
+    return APFloat(IEEEFloat::getSmallest(Sem, Negative));
+  }
+
+  static APFloat getSmallestNormalized(const fltSemantics &Sem,
+                                       bool Negative = false) {
+    return APFloat(IEEEFloat::getSmallestNormalized(Sem, Negative));
+  }
+
+  static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false) {
+    return APFloat(IEEEFloat::getAllOnesValue(BitWidth, isIEEE));
+  }
+
+  void Profile(FoldingSetNodeID &NID) const { IEEE.Profile(NID); }
+
+  opStatus add(const APFloat &RHS, roundingMode RM) {
+    return IEEE.add(RHS.IEEE, RM);
+  }
+  opStatus subtract(const APFloat &RHS, roundingMode RM) {
+    return IEEE.subtract(RHS.IEEE, RM);
+  }
+  opStatus multiply(const APFloat &RHS, roundingMode RM) {
+    return IEEE.multiply(RHS.IEEE, RM);
+  }
+  opStatus divide(const APFloat &RHS, roundingMode RM) {
+    return IEEE.divide(RHS.IEEE, RM);
+  }
+  opStatus remainder(const APFloat &RHS) { return IEEE.remainder(RHS.IEEE); }
+  opStatus mod(const APFloat &RHS) { return IEEE.mod(RHS.IEEE); }
+  opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
+                            roundingMode RM) {
+    return IEEE.fusedMultiplyAdd(Multiplicand.IEEE, Addend.IEEE, RM);
+  }
+  opStatus roundToIntegral(roundingMode RM) { return IEEE.roundToIntegral(RM); }
+  opStatus next(bool nextDown) { return IEEE.next(nextDown); }
+
+  APFloat operator+(const APFloat &RHS) const {
+    return APFloat(IEEE + RHS.IEEE);
+  }
+
+  APFloat operator-(const APFloat &RHS) const {
+    return APFloat(IEEE - RHS.IEEE);
+  }
+
+  APFloat operator*(const APFloat &RHS) const {
+    return APFloat(IEEE * RHS.IEEE);
+  }
+
+  APFloat operator/(const APFloat &RHS) const {
+    return APFloat(IEEE / RHS.IEEE);
+  }
+
+  void changeSign() { IEEE.changeSign(); }
+  void clearSign() { IEEE.clearSign(); }
+  void copySign(const APFloat &RHS) { IEEE.copySign(RHS.IEEE); }
+
+  static APFloat copySign(APFloat Value, const APFloat &Sign) {
+    return APFloat(IEEEFloat::copySign(Value.IEEE, Sign.IEEE));
+  }
+
+  opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
+                   bool *losesInfo) {
+    return IEEE.convert(ToSemantics, RM, losesInfo);
+  }
+  opStatus convertToInteger(integerPart *Input, unsigned int Width,
+                            bool IsSigned, roundingMode RM,
+                            bool *IsExact) const {
+    return IEEE.convertToInteger(Input, Width, IsSigned, RM, IsExact);
+  }
+  opStatus convertToInteger(APSInt &Result, roundingMode RM,
+                            bool *IsExact) const {
+    return IEEE.convertToInteger(Result, RM, IsExact);
+  }
+  opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
+                            roundingMode RM) {
+    return IEEE.convertFromAPInt(Input, IsSigned, RM);
+  }
+  opStatus convertFromSignExtendedInteger(const integerPart *Input,
+                                          unsigned int InputSize, bool IsSigned,
+                                          roundingMode RM) {
+    return IEEE.convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM);
+  }
+  opStatus convertFromZeroExtendedInteger(const integerPart *Input,
+                                          unsigned int InputSize, bool IsSigned,
+                                          roundingMode RM) {
+    return IEEE.convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM);
+  }
+  opStatus convertFromString(StringRef, roundingMode);
+  APInt bitcastToAPInt() const { return IEEE.bitcastToAPInt(); }
+  double convertToDouble() const { return IEEE.convertToDouble(); }
+  float convertToFloat() const { return IEEE.convertToFloat(); }
+
+  bool operator==(const APFloat &) const = delete;
+
+  cmpResult compare(const APFloat &RHS) const { return IEEE.compare(RHS.IEEE); }
+
+  bool bitwiseIsEqual(const APFloat &RHS) const {
+    return IEEE.bitwiseIsEqual(RHS.IEEE);
+  }
+
+  unsigned int convertToHexString(char *DST, unsigned int HexDigits,
+                                  bool UpperCase, roundingMode RM) const {
+    return IEEE.convertToHexString(DST, HexDigits, UpperCase, RM);
+  }
+
+  bool isZero() const { return getCategory() == fcZero; }
+  bool isInfinity() const { return getCategory() == fcInfinity; }
+  bool isNaN() const { return getCategory() == fcNaN; }
+
+  bool isNegative() const { return IEEE.isNegative(); }
+  bool isDenormal() const { return IEEE.isDenormal(); }
+  bool isSignaling() const { return IEEE.isSignaling(); }
+
+  bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
+  bool isFinite() const { return !isNaN() && !isInfinity(); }
+
+  fltCategory getCategory() const { return IEEE.getCategory(); }
+  const fltSemantics &getSemantics() const { return *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 IEEE.isSmallest(); }
+  bool isLargest() const { return IEEE.isLargest(); }
+  bool isInteger() const { return IEEE.isInteger(); }
+
+  APFloat &operator=(const APFloat &RHS) {
+    IEEE = RHS.IEEE;
+    return *this;
+  }
+  APFloat &operator=(APFloat &&RHS) {
+    IEEE = std::move(RHS.IEEE);
+    return *this;
+  }
+
+  void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
+                unsigned FormatMaxPadding = 3) const {
+    return IEEE.toString(Str, FormatPrecision, FormatMaxPadding);
+  }
+
+  bool getExactInverse(APFloat *inv) const {
+    return IEEE.getExactInverse(&inv->IEEE);
+  }
+
+  friend hash_code hash_value(const APFloat &Arg);
+  friend int ilogb(const APFloat &Arg) { return ilogb(Arg.IEEE); }
+  friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
+  friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
+};
+
 /// 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);
-int ilogb(const APFloat &Arg);
-APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode);
+inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
+  return APFloat(scalbn(X.IEEE, Exp, RM));
+}
 
 /// \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.
-APFloat frexp(const APFloat &Val, int &Exp, APFloat::roundingMode RM);
-
+inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
+  return APFloat(frexp(X.IEEE, Exp, RM));
+}
 /// \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
 /// both are not NaN. If either argument is a NaN, returns the other argument.

llvm/lib/Support/APFloat.cpp

 /// codebase, change this into a static inline function.
 #define PackCategoriesIntoKey(_lhs, _rhs) ((_lhs) * 4 + (_rhs))
 
 /* Assumed in hexadecimal significand parsing, and conversion to
    hexadecimal strings.  */
 static_assert(integerPartWidth % 4 == 0, "Part width must be divisible by 4!");
 
 namespace llvm {
-
   /* Represents floating point arithmetic semantics.  */
   struct fltSemantics {
     /* The largest E such that 2^E is representable; this matches the
        definition of IEEE 754.  */
-    APFloat::ExponentType maxExponent;
+    APFloatBase::ExponentType maxExponent;
 
     /* The smallest E such that 2^E is a normalized number; this
        matches the definition of IEEE 754.  */
-    APFloat::ExponentType minExponent;
+    APFloatBase::ExponentType minExponent;
 
     /* Number of bits in the significand.  This includes the integer
        bit.  */
     unsigned int precision;
 
     /* Number of bits actually used in the semantics. */
     unsigned int sizeInBits;
   };
 
-  const fltSemantics APFloat::IEEEhalf = { 15, -14, 11, 16 };
-  const fltSemantics APFloat::IEEEsingle = { 127, -126, 24, 32 };
-  const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53, 64 };
-  const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113, 128 };
-  const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64, 80 };
-  const fltSemantics APFloat::Bogus = { 0, 0, 0, 0 };
+  const fltSemantics APFloatBase::IEEEhalf = {15, -14, 11, 16};
+  const fltSemantics APFloatBase::IEEEsingle = {127, -126, 24, 32};
+  const fltSemantics APFloatBase::IEEEdouble = {1023, -1022, 53, 64};
+  const fltSemantics APFloatBase::IEEEquad = {16383, -16382, 113, 128};
+  const fltSemantics APFloatBase::x87DoubleExtended = {16383, -16382, 64, 80};
+  const fltSemantics APFloatBase::Bogus = {0, 0, 0, 0};
 
   /* The PowerPC format consists of two doubles.  It does not map cleanly
      onto the usual format above.  It is approximated using twice the
      mantissa bits.  Note that for exponents near the double minimum,
      we no longer can represent the full 106 mantissa bits, so those
      will be treated as denormal numbers.
 
      FIXME: While this approximation is equivalent to what GCC uses for
      compile-time arithmetic on PPC double-double numbers, it is not able
      to represent all possible values held by a PPC double-double number,
      for example: (long double) 1.0 + (long double) 0x1p-106
      Should this be replaced by a full emulation of PPC double-double?  */
-  const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022 + 53, 53 + 53, 128 };
+  const fltSemantics APFloatBase::PPCDoubleDouble = {1023, -1022 + 53, 53 + 53,
+                                                     128};
 
   /* A tight upper bound on number of parts required to hold the value
      pow(5, power) is
 
        power * 815 / (351 * integerPartWidth) + 1
 
      However, whilst the result may require only this many parts,
      because we are multiplying two values to get it, the
      multiplication may require an extra part with the excess part
      being zero (consider the trivial case of 1 * 1, tcFullMultiply
      requires two parts to hold the single-part result).  So we add an
      extra one to guarantee enough space whilst multiplying.  */
   const unsigned int maxExponent = 16383;
   const unsigned int maxPrecision = 113;
   const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
   const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
                                                 / (351 * integerPartWidth));
+
+  unsigned int APFloatBase::semanticsPrecision(const fltSemantics &semantics) {
+    return semantics.precision;
+  }
+  APFloatBase::ExponentType
+  APFloatBase::semanticsMaxExponent(const fltSemantics &semantics) {
+    return semantics.maxExponent;
+  }
+  APFloatBase::ExponentType
+  APFloatBase::semanticsMinExponent(const fltSemantics &semantics) {
+    return semantics.minExponent;
+  }
+  unsigned int APFloatBase::semanticsSizeInBits(const fltSemantics &semantics) {
+    return semantics.sizeInBits;
+  }
+
+  unsigned APFloatBase::getSizeInBits(const fltSemantics &Sem) {
+    return Sem.sizeInBits;
 }
 
 /* A bunch of private, handy routines.  */
 
 static inline unsigned int
 partCountForBits(unsigned int bits)
 {
   return ((bits) + integerPartWidth - 1) / integerPartWidth;
if (value < 0) {
     *dst++ = '-';
     dst = writeUnsignedDecimal(dst, -(unsigned) value);
   } else
     dst = writeUnsignedDecimal(dst, value);
 
   return dst;
 }
 
+namespace detail {
 /* Constructors.  */
-void
-APFloat::initialize(const fltSemantics *ourSemantics)
-{
+void IEEEFloat::initialize(const fltSemantics *ourSemantics) {
   unsigned int count;
 
   semantics = ourSemantics;
   count = partCount();
   if (count > 1)
     significand.parts = new integerPart[count];
 }
 
-void
-APFloat::freeSignificand()
-{
+void IEEEFloat::freeSignificand() {
   if (needsCleanup())
     delete [] significand.parts;
 }
 
-void
-APFloat::assign(const APFloat &rhs)
-{
+void IEEEFloat::assign(const IEEEFloat &rhs) {
   assert(semantics == rhs.semantics);
 
   sign = rhs.sign;
   category = rhs.category;
   exponent = rhs.exponent;
   if (isFiniteNonZero() || category == fcNaN)
     copySignificand(rhs);
 }
 
-void
-APFloat::copySignificand(const APFloat &rhs)
-{
+void IEEEFloat::copySignificand(const IEEEFloat &rhs) {
   assert(isFiniteNonZero() || category == fcNaN);
   assert(rhs.partCount() >= partCount());
 
   APInt::tcAssign(significandParts(), rhs.significandParts(),
                   partCount());
 }
 
 /* Make this number a NaN, with an arbitrary but deterministic value
    for the significand.  If double or longer, this is a signalling NaN,
    which may not be ideal.  If float, this is QNaN(0).  */
-void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
-{
+void IEEEFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill) {
   category = fcNaN;
   sign = Negative;
 
   integerPart *significand = significandParts();
   unsigned numParts = partCount();
 
   // Set the significand bits to the fill.
   if (!fill || fill->getNumWords() < numParts)
void IEEEFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill) {
 
   // For x87 extended precision, we want to make a NaN, not a
   // pseudo-NaN.  Maybe we should expose the ability to make
   // pseudo-NaNs?
   if (semantics == &APFloat::x87DoubleExtended)
     APInt::tcSetBit(significand, QNaNBit + 1);
 }
 
-APFloat APFloat::makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
+IEEEFloat IEEEFloat::makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
                              const APInt *fill) {
-  APFloat value(Sem, uninitialized);
+  IEEEFloat value(Sem, uninitialized);
   value.makeNaN(SNaN, Negative, fill);
   return value;
 }
 
-APFloat &
-APFloat::operator=(const APFloat &rhs)
-{
+IEEEFloat &IEEEFloat::operator=(const IEEEFloat &rhs) {
   if (this != &rhs) {
     if (semantics != rhs.semantics) {
       freeSignificand();
       initialize(rhs.semantics);
     }
     assign(rhs);
   }
 
   return *this;
 }
 
-APFloat &
-APFloat::operator=(APFloat &&rhs) {
+IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
   freeSignificand();
 
   semantics = rhs.semantics;
   significand = rhs.significand;
   exponent = rhs.exponent;
   category = rhs.category;
   sign = rhs.sign;
 
   rhs.semantics = &Bogus;
   return *this;
 }
 
-bool
-APFloat::isDenormal() const {
+bool IEEEFloat::isDenormal() const {
   return isFiniteNonZero() && (exponent == semantics->minExponent) &&
          (APInt::tcExtractBit(significandParts(), 
                               semantics->precision - 1) == 0);
 }
 
-bool
-APFloat::isSmallest() const {
+bool IEEEFloat::isSmallest() const {
   // The smallest number by magnitude in our format will be the smallest
   // denormal, i.e. the floating point number with exponent being minimum
   // exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
   return isFiniteNonZero() && exponent == semantics->minExponent &&
     significandMSB() == 0;
 }
 
-bool APFloat::isSignificandAllOnes() const {
+bool IEEEFloat::isSignificandAllOnes() const {
   // Test if the significand excluding the integral bit is all ones. This allows
   // us to test for binade boundaries.
   const integerPart *Parts = significandParts();
   const unsigned PartCount = partCount();
   for (unsigned i = 0; i < PartCount - 1; i++)
     if (~Parts[i])
       return false;
 
   // Set the unused high bits to all ones when we compare.
   const unsigned NumHighBits =
     PartCount*integerPartWidth - semantics->precision + 1;
   assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
          "fill than integerPartWidth");
   const integerPart HighBitFill =
     ~integerPart(0) << (integerPartWidth - NumHighBits);
   if (~(Parts[PartCount - 1] | HighBitFill))
     return false;
 
   return true;
 }
 
-bool APFloat::isSignificandAllZeros() const {
+bool IEEEFloat::isSignificandAllZeros() const {
   // Test if the significand excluding the integral bit is all zeros. This
   // allows us to test for binade boundaries.
   const integerPart *Parts = significandParts();
   const unsigned PartCount = partCount();
 
   for (unsigned i = 0; i < PartCount - 1; i++)
     if (Parts[i])
       return false;
 
   const unsigned NumHighBits =
     PartCount*integerPartWidth - semantics->precision + 1;
   assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
          "clear than integerPartWidth");
   const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
 
   if (Parts[PartCount - 1] & HighBitMask)
     return false;
 
   return true;
 }
 
-bool
-APFloat::isLargest() const {
+bool IEEEFloat::isLargest() const {
   // The largest number by magnitude in our format will be the floating point
   // number with maximum exponent and with significand that is all ones.
   return isFiniteNonZero() && exponent == semantics->maxExponent
     && isSignificandAllOnes();
 }
 
-bool
-APFloat::isInteger() const {
+bool IEEEFloat::isInteger() const {
   // This could be made more efficient; I'm going for obviously correct.
   if (!isFinite()) return false;
-  APFloat truncated = *this;
+  IEEEFloat truncated = *this;
   truncated.roundToIntegral(rmTowardZero);
   return compare(truncated) == cmpEqual;
 }
 
-bool
-APFloat::bitwiseIsEqual(const APFloat &rhs) const {
+bool IEEEFloat::bitwiseIsEqual(const IEEEFloat &rhs) const {
   if (this == &rhs)
     return true;
   if (semantics != rhs.semantics ||
       category != rhs.category ||
       sign != rhs.sign)
     return false;
   if (category==fcZero || category==fcInfinity)
     return true;
 
   if (isFiniteNonZero() && exponent != rhs.exponent)
     return false;
 
   return std::equal(significandParts(), significandParts() + partCount(),
                     rhs.significandParts());
 }
 
-APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value) {
+IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, integerPart value) {
   initialize(&ourSemantics);
   sign = 0;
   category = fcNormal;
   zeroSignificand();
   exponent = ourSemantics.precision - 1;
   significandParts()[0] = value;
   normalize(rmNearestTiesToEven, lfExactlyZero);
 }
 
-APFloat::APFloat(const fltSemantics &ourSemantics) {
+IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics) {
   initialize(&ourSemantics);
   category = fcZero;
   sign = false;
 }
 
-APFloat::APFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
+IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
   // Allocates storage if necessary but does not initialize it.
   initialize(&ourSemantics);
 }
 
-APFloat::APFloat(const fltSemantics &ourSemantics, StringRef text) {
+IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, StringRef text) {
   initialize(&ourSemantics);
   convertFromString(text, rmNearestTiesToEven);
 }
 
-APFloat::APFloat(const APFloat &rhs) {
+IEEEFloat::IEEEFloat(const IEEEFloat &rhs) {
   initialize(rhs.semantics);
   assign(rhs);
 }
 
-APFloat::APFloat(APFloat &&rhs) : semantics(&Bogus) {
+IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&Bogus) {
   *this = std::move(rhs);
 }
 
-APFloat::~APFloat()
-{
-  freeSignificand();
-}
+IEEEFloat::~IEEEFloat() { freeSignificand(); }
 
 // Profile - This method 'profiles' an APFloat for use with FoldingSet.
-void APFloat::Profile(FoldingSetNodeID& ID) const {
+void IEEEFloat::Profile(FoldingSetNodeID &ID) const {
   ID.Add(bitcastToAPInt());
 }
 
-unsigned int
-APFloat::partCount() const
-{
+unsigned int IEEEFloat::partCount() const {
   return partCountForBits(semantics->precision + 1);
 }
 
-unsigned int
-APFloat::semanticsPrecision(const fltSemantics &semantics)
-{
-  return semantics.precision;
-}
-APFloat::ExponentType
-APFloat::semanticsMaxExponent(const fltSemantics &semantics)
-{
-  return semantics.maxExponent;
-}
-APFloat::ExponentType
-APFloat::semanticsMinExponent(const fltSemantics &semantics)
-{
-  return semantics.minExponent;
-}
-unsigned int
-APFloat::semanticsSizeInBits(const fltSemantics &semantics)
-{
-  return semantics.sizeInBits;
-}
-
-const integerPart *
-APFloat::significandParts() const
-{
-  return const_cast<APFloat *>(this)->significandParts();
+const integerPart *IEEEFloat::significandParts() const {
+  return const_cast<IEEEFloat *>(this)->significandParts();
 }
 
-integerPart *
-APFloat::significandParts()
-{
+integerPart *IEEEFloat::significandParts() {
   if (partCount() > 1)
     return significand.parts;
   else
     return &significand.part;
 }
 
-void
-APFloat::zeroSignificand()
-{
+void IEEEFloat::zeroSignificand() {
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
 /* Increment an fcNormal floating point number's significand.  */
-void
-APFloat::incrementSignificand()
-{
+void IEEEFloat::incrementSignificand() {
   integerPart carry;
 
   carry = APInt::tcIncrement(significandParts(), partCount());
 
   /* Our callers should never cause us to overflow.  */
   assert(carry == 0);
   (void)carry;
 }
 
 /* Add the significand of the RHS.  Returns the carry flag.  */
-integerPart
-APFloat::addSignificand(const APFloat &rhs)
-{
+integerPart IEEEFloat::addSignificand(const IEEEFloat &rhs) {
   integerPart *parts;
 
   parts = significandParts();
 
   assert(semantics == rhs.semantics);
   assert(exponent == rhs.exponent);
 
   return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
 }
 
 /* Subtract the significand of the RHS with a borrow flag.  Returns
    the borrow flag.  */
-integerPart
-APFloat::subtractSignificand(const APFloat &rhs, integerPart borrow)
-{
+integerPart IEEEFloat::subtractSignificand(const IEEEFloat &rhs,
+                                           integerPart borrow) {
   integerPart *parts;
 
   parts = significandParts();
 
   assert(semantics == rhs.semantics);
   assert(exponent == rhs.exponent);
 
   return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
                            partCount());
 }
 
 /* Multiply the significand of the RHS.  If ADDEND is non-NULL, add it
    on to the full-precision result of the multiplication.  Returns the
    lost fraction.  */
-lostFraction
-APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
-{
+lostFraction IEEEFloat::multiplySignificand(const IEEEFloat &rhs,
+                                            const IEEEFloat *addend) {
   unsigned int omsb;        // One, not zero, based MSB.
   unsigned int partsCount, newPartsCount, precision;
   integerPart *lhsSignificand;
   integerPart scratch[4];
   integerPart *fullSignificand;
   lostFraction lost_fraction;
   bool ignored;
 
if (addend && addend->isNonZero()) {
     extendedSemantics.precision = extendedPrecision;
 
     if (newPartsCount == 1)
       significand.part = fullSignificand[0];
     else
       significand.parts = fullSignificand;
     semantics = &extendedSemantics;
 
-    APFloat extendedAddend(*addend);
+    IEEEFloat extendedAddend(*addend);
     status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
     assert(status == opOK);
     (void)status;
 
     // Shift the significand of the addend right by one bit. This guarantees
     // that the high bit of the significand is zero (same as fullSignificand),
     // so the addition will overflow (if it does overflow at all) into the top bit.
     lost_fraction = extendedAddend.shiftSignificandRight(1);
lostFraction IEEEFloat::multiplySignificand(const IEEEFloat &rhs,
   // adjusted by "2*precision - 1" - "precision - 1" = "precision".
   exponent -= precision + 1;
 
   // In case MSB resides at the left-hand side of radix point, shift the
   // mantissa right by some amount to make sure the MSB reside right before
   // the radix point (i.e. "MSB . rest-significant-bits").
   //
   // Note that the result is not normalized when "omsb < precision". So, the
-  // caller needs to call APFloat::normalize() if normalized value is expected.
+  // caller needs to call IEEEFloat::normalize() if normalized value is
+  // expected.
   if (omsb > precision) {
     unsigned int bits, significantParts;
     lostFraction lf;
 
     bits = omsb - precision;
     significantParts = partCountForBits(omsb);
     lf = shiftRight(fullSignificand, significantParts, bits);
     lost_fraction = combineLostFractions(lf, lost_fraction);
     exponent += bits;
   }
 
   APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
 
   if (newPartsCount > 4)
     delete [] fullSignificand;
 
   return lost_fraction;
 }
 
 /* Multiply the significands of LHS and RHS to DST.  */
-lostFraction
-APFloat::divideSignificand(const APFloat &rhs)
-{
+lostFraction IEEEFloat::divideSignificand(const IEEEFloat &rhs) {
   unsigned int bit, i, partsCount;
   const integerPart *rhsSignificand;
   integerPart *lhsSignificand, *dividend, *divisor;
   integerPart scratch[4];
   lostFraction lost_fraction;
 
   assert(semantics == rhs.semantics);
 
else
     lost_fraction = lfLessThanHalf;
 
   if (partsCount > 2)
     delete [] dividend;
 
   return lost_fraction;
 }
 
-unsigned int
-APFloat::significandMSB() const
-{
+unsigned int IEEEFloat::significandMSB() const {
   return APInt::tcMSB(significandParts(), partCount());
 }
 
-unsigned int
-APFloat::significandLSB() const
-{
+unsigned int IEEEFloat::significandLSB() const {
   return APInt::tcLSB(significandParts(), partCount());
 }
 
 /* Note that a zero result is NOT normalized to fcZero.  */
-lostFraction
-APFloat::shiftSignificandRight(unsigned int bits)
-{
+lostFraction IEEEFloat::shiftSignificandRight(unsigned int bits) {
   /* Our exponent should not overflow.  */
   assert((ExponentType) (exponent + bits) >= exponent);
 
   exponent += bits;
 
   return shiftRight(significandParts(), partCount(), bits);
 }
 
 /* Shift the significand left BITS bits, subtract BITS from its exponent.  */
-void
-APFloat::shiftSignificandLeft(unsigned int bits)
-{
+void IEEEFloat::shiftSignificandLeft(unsigned int bits) {
   assert(bits < semantics->precision);
 
   if (bits) {
     unsigned int partsCount = partCount();
 
     APInt::tcShiftLeft(significandParts(), partsCount, bits);
     exponent -= bits;
 
     assert(!APInt::tcIsZero(significandParts(), partsCount));
   }
 }
 
-APFloat::cmpResult
-APFloat::compareAbsoluteValue(const APFloat &rhs) const
-{
+IEEEFloat::cmpResult
+IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const {
   int compare;
 
   assert(semantics == rhs.semantics);
   assert(isFiniteNonZero());
   assert(rhs.isFiniteNonZero());
 
   compare = exponent - rhs.exponent;
 
   /* If exponents are equal, do an unsigned bignum comparison of the
      significands.  */
   if (compare == 0)
     compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
                                partCount());
 
   if (compare > 0)
     return cmpGreaterThan;
   else if (compare < 0)
     return cmpLessThan;
   else
     return cmpEqual;
 }
 
 /* Handle overflow.  Sign is preserved.  We either become infinity or
    the largest finite number.  */
-APFloat::opStatus
-APFloat::handleOverflow(roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
   /* Infinity?  */
   if (rounding_mode == rmNearestTiesToEven ||
       rounding_mode == rmNearestTiesToAway ||
       (rounding_mode == rmTowardPositive && !sign) ||
       (rounding_mode == rmTowardNegative && sign)) {
     category = fcInfinity;
     return (opStatus) (opOverflow | opInexact);
   }
 
   /* Otherwise we become the largest finite number.  */
   category = fcNormal;
   exponent = semantics->maxExponent;
   APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
                                    semantics->precision);
 
   return opInexact;
 }
 
 /* Returns TRUE if, when truncating the current number, with BIT the
    new LSB, with the given lost fraction and rounding mode, the result
    would need to be rounded away from zero (i.e., by increasing the
    signficand).  This routine must work for fcZero of both signs, and
    fcNormal numbers.  */
-bool
-APFloat::roundAwayFromZero(roundingMode rounding_mode,
+bool IEEEFloat::roundAwayFromZero(roundingMode rounding_mode,
                                   lostFraction lost_fraction,
-                           unsigned int bit) const
-{
+                                  unsigned int bit) const {
   /* NaNs and infinities should not have lost fractions.  */
   assert(isFiniteNonZero() || category == fcZero);
 
   /* Current callers never pass this so we don't handle it.  */
   assert(lost_fraction != lfExactlyZero);
 
   switch (rounding_mode) {
   case rmNearestTiesToAway:
case rmTowardPositive:
     return !sign;
 
   case rmTowardNegative:
     return sign;
   }
   llvm_unreachable("Invalid rounding mode found");
 }
 
-APFloat::opStatus
-APFloat::normalize(roundingMode rounding_mode,
-                   lostFraction lost_fraction)
-{
+IEEEFloat::opStatus IEEEFloat::normalize(roundingMode rounding_mode,
+                                         lostFraction lost_fraction) {
   unsigned int omsb;                /* One, not zero, based MSB.  */
   int exponentChange;
 
   if (!isFiniteNonZero())
     return opOK;
 
   /* Before rounding normalize the exponent of fcNormal numbers.  */
   omsb = significandMSB() + 1;
IEEEFloat::opStatus IEEEFloat::normalize(roundingMode rounding_mode,
   /* Canonicalize zeroes.  */
   if (omsb == 0)
     category = fcZero;
 
   /* The fcZero case is a denormal that underflowed to zero.  */
   return (opStatus) (opUnderflow | opInexact);
 }
 
-APFloat::opStatus
-APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
-{
+IEEEFloat::opStatus IEEEFloat::addOrSubtractSpecials(const IEEEFloat &rhs,
+                                                     bool subtract) {
   switch (PackCategoriesIntoKey(category, rhs.category)) {
   default:
     llvm_unreachable(nullptr);
 
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
case PackCategoriesIntoKey(fcInfinity, fcInfinity):
     return opOK;
 
   case PackCategoriesIntoKey(fcNormal, fcNormal):
     return opDivByZero;
   }
 }
 
 /* Add or subtract two normal numbers.  */
-lostFraction
-APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
-{
+lostFraction IEEEFloat::addOrSubtractSignificand(const IEEEFloat &rhs,
+                                                 bool subtract) {
   integerPart carry;
   lostFraction lost_fraction;
   int bits;
 
   /* Determine if the operation on the absolute values is effectively
      an addition or subtraction.  */
   subtract ^= static_cast<bool>(sign ^ rhs.sign);
 
   /* Are we bigger exponent-wise than the RHS?  */
   bits = exponent - rhs.exponent;
 
   /* Subtraction is more subtle than one might naively expect.  */
   if (subtract) {
-    APFloat temp_rhs(rhs);
+    IEEEFloat temp_rhs(rhs);
     bool reverse;
 
     if (bits == 0) {
       reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
       lost_fraction = lfExactlyZero;
     } else if (bits > 0) {
       lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
       shiftSignificandLeft(1);
else if (lost_fraction == lfMoreThanHalf)
       lost_fraction = lfLessThanHalf;
 
     /* The code above is intended to ensure that no borrow is
        necessary.  */
     assert(!carry);
     (void)carry;
   } else {
     if (bits > 0) {
-      APFloat temp_rhs(rhs);
+      IEEEFloat temp_rhs(rhs);
 
       lost_fraction = temp_rhs.shiftSignificandRight(bits);
       carry = addSignificand(temp_rhs);
     } else {
       lost_fraction = shiftSignificandRight(-bits);
       carry = addSignificand(rhs);
     }
 
     /* We have a guard bit; generating a carry cannot happen.  */
     assert(!carry);
     (void)carry;
   }
 
   return lost_fraction;
 }
 
-APFloat::opStatus
-APFloat::multiplySpecials(const APFloat &rhs)
-{
+IEEEFloat::opStatus IEEEFloat::multiplySpecials(const IEEEFloat &rhs) {
   switch (PackCategoriesIntoKey(category, rhs.category)) {
   default:
     llvm_unreachable(nullptr);
 
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
case PackCategoriesIntoKey(fcInfinity, fcZero):
     makeNaN();
     return opInvalidOp;
 
   case PackCategoriesIntoKey(fcNormal, fcNormal):
     return opOK;
   }
 }
 
-APFloat::opStatus
-APFloat::divideSpecials(const APFloat &rhs)
-{
+IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
   switch (PackCategoriesIntoKey(category, rhs.category)) {
   default:
     llvm_unreachable(nullptr);
 
   case PackCategoriesIntoKey(fcZero, fcNaN):
   case PackCategoriesIntoKey(fcNormal, fcNaN):
   case PackCategoriesIntoKey(fcInfinity, fcNaN):
     category = fcNaN;
case PackCategoriesIntoKey(fcZero, fcZero):
     makeNaN();
     return opInvalidOp;
 
   case PackCategoriesIntoKey(fcNormal, fcNormal):
     return opOK;
   }
 }
 
-APFloat::opStatus
-APFloat::modSpecials(const APFloat &rhs)
-{
+IEEEFloat::opStatus IEEEFloat::modSpecials(const IEEEFloat &rhs) {
   switch (PackCategoriesIntoKey(category, rhs.category)) {
   default:
     llvm_unreachable(nullptr);
 
   case PackCategoriesIntoKey(fcNaN, fcZero):
   case PackCategoriesIntoKey(fcNaN, fcNormal):
   case PackCategoriesIntoKey(fcNaN, fcInfinity):
   case PackCategoriesIntoKey(fcNaN, fcNaN):
case PackCategoriesIntoKey(fcZero, fcZero):
     return opInvalidOp;
 
   case PackCategoriesIntoKey(fcNormal, fcNormal):
     return opOK;
   }
 }
 
 /* Change sign.  */
-void
-APFloat::changeSign()
-{
+void IEEEFloat::changeSign() {
   /* Look mummy, this one's easy.  */
   sign = !sign;
 }
 
-void
-APFloat::clearSign()
-{
+void IEEEFloat::clearSign() {
   /* So is this one. */
   sign = 0;
 }
 
-void
-APFloat::copySign(const APFloat &rhs)
-{
+void IEEEFloat::copySign(const IEEEFloat &rhs) {
   /* And this one. */
   sign = rhs.sign;
 }
 
 /* Normalized addition or subtraction.  */
-APFloat::opStatus
-APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
-                       bool subtract)
-{
+IEEEFloat::opStatus IEEEFloat::addOrSubtract(const IEEEFloat &rhs,
+                                             roundingMode rounding_mode,
+                                             bool subtract) {
   opStatus fs;
 
   fs = addOrSubtractSpecials(rhs, subtract);
 
   /* This return code means it was not a simple case.  */
   if (fs == opDivByZero) {
     lostFraction lost_fraction;
 
if (category == fcZero) {
     if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
       sign = (rounding_mode == rmTowardNegative);
   }
 
   return fs;
 }
 
 /* Normalized addition.  */
-APFloat::opStatus
-APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::add(const IEEEFloat &rhs,
+                                   roundingMode rounding_mode) {
   return addOrSubtract(rhs, rounding_mode, false);
 }
 
 /* Normalized subtraction.  */
-APFloat::opStatus
-APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::subtract(const IEEEFloat &rhs,
+                                        roundingMode rounding_mode) {
   return addOrSubtract(rhs, rounding_mode, true);
 }
 
 /* Normalized multiply.  */
-APFloat::opStatus
-APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::multiply(const IEEEFloat &rhs,
+                                        roundingMode rounding_mode) {
   opStatus fs;
 
   sign ^= rhs.sign;
   fs = multiplySpecials(rhs);
 
   if (isFiniteNonZero()) {
     lostFraction lost_fraction = multiplySignificand(rhs, nullptr);
     fs = normalize(rounding_mode, lost_fraction);
     if (lost_fraction != lfExactlyZero)
       fs = (opStatus) (fs | opInexact);
   }
 
   return fs;
 }
 
 /* Normalized divide.  */
-APFloat::opStatus
-APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::divide(const IEEEFloat &rhs,
+                                      roundingMode rounding_mode) {
   opStatus fs;
 
   sign ^= rhs.sign;
   fs = divideSpecials(rhs);
 
   if (isFiniteNonZero()) {
     lostFraction lost_fraction = divideSignificand(rhs);
     fs = normalize(rounding_mode, lost_fraction);
     if (lost_fraction != lfExactlyZero)
       fs = (opStatus) (fs | opInexact);
   }
 
   return fs;
 }
 
 /* Normalized remainder.  This is not currently correct in all cases.  */
-APFloat::opStatus
-APFloat::remainder(const APFloat &rhs)
-{
+IEEEFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
   opStatus fs;
-  APFloat V = *this;
+  IEEEFloat V = *this;
   unsigned int origSign = sign;
 
   fs = V.divide(rhs, rmNearestTiesToEven);
   if (fs == opDivByZero)
     return fs;
 
   int parts = partCount();
   integerPart *x = new integerPart[parts];
IEEEFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
   if (isZero())
     sign = origSign;    // IEEE754 requires this
   delete[] x;
   return fs;
 }
 
 /* Normalized llvm frem (C fmod).
    This is not currently correct in all cases.  */
-APFloat::opStatus
-APFloat::mod(const APFloat &rhs)
-{
+IEEEFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) {
   opStatus fs;
   fs = modSpecials(rhs);
 
   if (isFiniteNonZero() && rhs.isFiniteNonZero()) {
-    APFloat V = *this;
+    IEEEFloat V = *this;
     unsigned int origSign = sign;
 
     fs = V.divide(rhs, rmNearestTiesToEven);
     if (fs == opDivByZero)
       return fs;
 
     int parts = partCount();
     integerPart *x = new integerPart[parts];
if (isFiniteNonZero() && rhs.isFiniteNonZero()) {
     if (isZero())
       sign = origSign;    // IEEE754 requires this
     delete[] x;
   }
   return fs;
 }
 
 /* Normalized fused-multiply-add.  */
-APFloat::opStatus
-APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
-                          const APFloat &addend,
-                          roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::fusedMultiplyAdd(const IEEEFloat &multiplicand,
+                                                const IEEEFloat &addend,
+                                                roundingMode rounding_mode) {
   opStatus fs;
 
   /* Post-multiplication sign, before addition.  */
   sign ^= multiplicand.sign;
 
   /* If and only if all arguments are normal do we need to do an
      extended-precision calculation.  */
   if (isFiniteNonZero() &&
if (isFiniteNonZero() &&
     if (fs == opOK)
       fs = addOrSubtract(addend, rounding_mode, false);
   }
 
   return fs;
 }
 
 /* Rounding-mode corrrect round to integral value.  */
-APFloat::opStatus APFloat::roundToIntegral(roundingMode rounding_mode) {
+IEEEFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
   opStatus fs;
 
   // If the exponent is large enough, we know that this value is already
   // integral, and the arithmetic below would potentially cause it to saturate
   // to +/-Inf.  Bail out early instead.
   if (isFiniteNonZero() && exponent+1 >= (int)semanticsPrecision(*semantics))
     return opOK;
 
   // The algorithm here is quite simple: we add 2^(p-1), where p is the
   // precision of our format, and then subtract it back off again.  The choice
   // of rounding modes for the addition/subtraction determines the 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;
-  APFloat MagicConstant(*semantics);
+  IEEEFloat MagicConstant(*semantics);
   fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
                                       rmNearestTiesToEven);
   MagicConstant.copySign(*this);
 
   if (fs != opOK)
     return fs;
 
   // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
IEEEFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
   if (inputSign != isNegative())
     changeSign();
 
   return fs;
 }
 
 
 /* Comparison requires normalized numbers.  */
-APFloat::cmpResult
-APFloat::compare(const APFloat &rhs) const
-{
+IEEEFloat::cmpResult IEEEFloat::compare(const IEEEFloat &rhs) const {
   cmpResult result;
 
   assert(semantics == rhs.semantics);
 
   switch (PackCategoriesIntoKey(category, rhs.category)) {
   default:
     llvm_unreachable(nullptr);
 
if (sign) {
       else if (result == cmpGreaterThan)
         result = cmpLessThan;
     }
   }
 
   return result;
 }
 
-/// APFloat::convert - convert a value of one floating point type to another.
+/// IEEEFloat::convert - convert a value of one floating point type to another.
 /// The return value corresponds to the IEEE754 exceptions.  *losesInfo
 /// records whether the transformation lost information, i.e. whether
 /// converting the result back to the original type will produce the
 /// original value (this is almost the same as return value==fsOK, but there
 /// are edge cases where this is not so).
 
-APFloat::opStatus
-APFloat::convert(const fltSemantics &toSemantics,
-                 roundingMode rounding_mode, bool *losesInfo)
-{
+IEEEFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
+                                       roundingMode rounding_mode,
+                                       bool *losesInfo) {
   lostFraction lostFraction;
   unsigned int newPartCount, oldPartCount;
   opStatus fs;
   int shift;
   const fltSemantics &fromSemantics = *semantics;
 
   lostFraction = lfExactlyZero;
   newPartCount = partCountForBits(toSemantics.precision + 1);
   oldPartCount = partCount();
   shift = toSemantics.precision - fromSemantics.precision;
 
   bool X86SpecialNan = false;
-  if (&fromSemantics == &APFloat::x87DoubleExtended &&
-      &toSemantics != &APFloat::x87DoubleExtended && category == fcNaN &&
+  if (&fromSemantics == &IEEEFloat::x87DoubleExtended &&
+      &toSemantics != &IEEEFloat::x87DoubleExtended && category == fcNaN &&
       (!(*significandParts() & 0x8000000000000000ULL) ||
        !(*significandParts() & 0x4000000000000000ULL))) {
     // x86 has some unusual NaNs which cannot be represented in any other
     // format; note them here.
     X86SpecialNan = true;
   }
 
   // If this is a truncation of a denormal number, and the target semantics
IEEEFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
   if (isFiniteNonZero()) {
     fs = normalize(rounding_mode, lostFraction);
     *losesInfo = (fs != opOK);
   } else if (category == fcNaN) {
     *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
 
     // For x87 extended precision, we want to make a NaN, not a special NaN if
     // the input wasn't special either.
-    if (!X86SpecialNan && semantics == &APFloat::x87DoubleExtended)
+    if (!X86SpecialNan && semantics == &IEEEFloat::x87DoubleExtended)
       APInt::tcSetBit(significandParts(), semantics->precision - 1);
 
     // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
     // does not give you back the same bits.  This is dubious, and we
     // don't currently do it.  You're really supposed to get
     // an invalid operation signal at runtime, but nobody does that.
     fs = opOK;
   } else {
/* Convert a floating point number to an integer according to the
    returns an invalid operation exception and the contents of the
    destination parts are unspecified.  If the rounded value is in
    range but the floating point number is not the exact integer, the C
    standard doesn't require an inexact exception to be raised.  IEEE
    854 does require it so we do that.
 
    Note that for conversions to integer type the C standard requires
    round-to-zero to always be used.  */
-APFloat::opStatus
-APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
-                                      bool isSigned,
-                                      roundingMode rounding_mode,
-                                      bool *isExact) const
-{
+IEEEFloat::opStatus IEEEFloat::convertToSignExtendedInteger(
+    integerPart *parts, unsigned int width, bool isSigned,
+    roundingMode rounding_mode, bool *isExact) const {
   lostFraction lost_fraction;
   const integerPart *src;
   unsigned int dstPartsCount, truncatedBits;
 
   *isExact = false;
 
   /* Handle the three special cases first.  */
   if (category == fcInfinity || category == fcNaN)
/* Same as convertToSignExtendedInteger, except we provide
    deterministic values in case of an invalid operation exception,
    namely zero for NaNs and the minimal or maximal value respectively
    for underflow or overflow.
    The *isExact output tells whether the result is exact, in the sense
    that converting it back to the original floating point type produces
    the original value.  This is almost equivalent to result==opOK,
    except for negative zeroes.
 */
-APFloat::opStatus
-APFloat::convertToInteger(integerPart *parts, unsigned int width,
+IEEEFloat::opStatus IEEEFloat::convertToInteger(integerPart *parts,
+                                                unsigned int width,
                                                 bool isSigned,
-                          roundingMode rounding_mode, bool *isExact) const
-{
+                                                roundingMode rounding_mode,
+                                                bool *isExact) const {
   opStatus fs;
 
   fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
                                     isExact);
 
   if (fs == opInvalidOp) {
     unsigned int bits, dstPartsCount;
 
IEEEFloat::opStatus IEEEFloat::convertToInteger(integerPart *parts,
 
   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.
  */
-APFloat::opStatus
-APFloat::convertToInteger(APSInt &result,
-                          roundingMode rounding_mode, bool *isExact) const
-{
+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.  */
-APFloat::opStatus
-APFloat::convertFromUnsignedParts(const integerPart *src,
-                                  unsigned int srcCount,
-                                  roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
+    const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
   unsigned int omsb, precision, dstCount;
   integerPart *dst;
   lostFraction lost_fraction;
 
   category = fcNormal;
   omsb = APInt::tcMSB(src, srcCount) + 1;
   dst = significandParts();
   dstCount = partCount();
if (precision <= omsb) {
     exponent = precision - 1;
     lost_fraction = lfExactlyZero;
     APInt::tcExtract(dst, dstCount, src, omsb, 0);
   }
 
   return normalize(rounding_mode, lost_fraction);
 }
 
-APFloat::opStatus
-APFloat::convertFromAPInt(const APInt &Val,
-                          bool isSigned,
-                          roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::convertFromAPInt(const APInt &Val, bool isSigned,
+                                                roundingMode rounding_mode) {
   unsigned int partCount = Val.getNumWords();
   APInt api = Val;
 
   sign = false;
   if (isSigned && api.isNegative()) {
     sign = true;
     api = -api;
   }
 
   return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
 }
 
 /* Convert a two's complement integer SRC to a floating point number,
    rounding according to ROUNDING_MODE.  ISSIGNED is true if the
    integer is signed, in which case it must be sign-extended.  */
-APFloat::opStatus
-APFloat::convertFromSignExtendedInteger(const integerPart *src,
-                                        unsigned int srcCount,
-                                        bool isSigned,
-                                        roundingMode rounding_mode)
-{
+IEEEFloat::opStatus
+IEEEFloat::convertFromSignExtendedInteger(const integerPart *src,
+                                          unsigned int srcCount, bool isSigned,
+                                          roundingMode rounding_mode) {
   opStatus status;
 
   if (isSigned &&
       APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
     integerPart *copy;
 
     /* If we're signed and negative negate a copy.  */
     sign = true;
     copy = new integerPart[srcCount];
     APInt::tcAssign(copy, src, srcCount);
     APInt::tcNegate(copy, srcCount);
     status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
     delete [] copy;
   } else {
     sign = false;
     status = convertFromUnsignedParts(src, srcCount, rounding_mode);
   }
 
   return status;
 }
 
 /* FIXME: should this just take a const APInt reference?  */
-APFloat::opStatus
-APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
+IEEEFloat::opStatus
+IEEEFloat::convertFromZeroExtendedInteger(const integerPart *parts,
                                           unsigned int width, bool isSigned,
-                                        roundingMode rounding_mode)
-{
+                                          roundingMode rounding_mode) {
   unsigned int partCount = partCountForBits(width);
   APInt api = APInt(width, makeArrayRef(parts, partCount));
 
   sign = false;
   if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
     sign = true;
     api = -api;
   }
 
   return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
 }
 
-APFloat::opStatus
-APFloat::convertFromHexadecimalString(StringRef s, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus
+IEEEFloat::convertFromHexadecimalString(StringRef s,
+                                        roundingMode rounding_mode) {
   lostFraction lost_fraction = lfExactlyZero;
 
   category = fcNormal;
   zeroSignificand();
   exponent = 0;
 
   integerPart *significand = significandParts();
   unsigned partsCount = partCount();
if (p != firstSignificantDigit) {
 
     /* Adjust for the given exponent.  */
     exponent = totalExponent(p + 1, end, expAdjustment);
   }
 
   return normalize(rounding_mode, lost_fraction);
 }
 
-APFloat::opStatus
-APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
+IEEEFloat::opStatus
+IEEEFloat::roundSignificandWithExponent(const integerPart *decSigParts,
                                         unsigned sigPartCount, int exp,
-                                      roundingMode rounding_mode)
-{
+                                        roundingMode rounding_mode) {
   unsigned int parts, pow5PartCount;
   fltSemantics calcSemantics = { 32767, -32767, 0, 0 };
   integerPart pow5Parts[maxPowerOfFiveParts];
   bool isNearest;
 
   isNearest = (rounding_mode == rmNearestTiesToEven ||
                rounding_mode == rmNearestTiesToAway);
 
   parts = partCountForBits(semantics->precision + 11);
 
   /* Calculate pow(5, abs(exp)).  */
   pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
 
   for (;; parts *= 2) {
     opStatus sigStatus, powStatus;
     unsigned int excessPrecision, truncatedBits;
 
     calcSemantics.precision = parts * integerPartWidth - 1;
     excessPrecision = calcSemantics.precision - semantics->precision;
     truncatedBits = excessPrecision;
 
-    APFloat decSig = APFloat::getZero(calcSemantics, sign);
-    APFloat pow5(calcSemantics);
+    IEEEFloat decSig = IEEEFloat::getZero(calcSemantics, sign);
+    IEEEFloat pow5(calcSemantics);
 
     sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
                                                 rmNearestTiesToEven);
     powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
                                               rmNearestTiesToEven);
     /* Add exp, as 10^n = 5^n * 2^n.  */
     decSig.exponent += exp;
 
if (HUdistance >= HUerr) {
       calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
                                                        decSig.partCount(),
                                                        truncatedBits);
       return normalize(rounding_mode, calcLostFraction);
     }
   }
 }
 
-APFloat::opStatus
-APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus
+IEEEFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode) {
   decimalInfo D;
   opStatus fs;
 
   /* Scan the text.  */
   StringRef::iterator p = str.begin();
   interpretDecimal(p, str.end(), &D);
 
   /* Handle the quick cases.  First the case of no significant digits,
fs = roundSignificandWithExponent(decSignificand, partCount,
                                       D.exponent, rounding_mode);
 
     delete [] decSignificand;
   }
 
   return fs;
 }
 
-bool
-APFloat::convertFromStringSpecials(StringRef str) {
+bool IEEEFloat::convertFromStringSpecials(StringRef str) {
   if (str.equals("inf") || str.equals("INFINITY")) {
     makeInf(false);
     return true;
   }
 
   if (str.equals("-inf") || str.equals("-INFINITY")) {
     makeInf(true);
     return true;
   }
 
   if (str.equals("nan") || str.equals("NaN")) {
     makeNaN(false, false);
     return true;
   }
 
   if (str.equals("-nan") || str.equals("-NaN")) {
     makeNaN(false, true);
     return true;
   }
 
   return false;
 }
 
-APFloat::opStatus
-APFloat::convertFromString(StringRef str, roundingMode rounding_mode)
-{
+IEEEFloat::opStatus IEEEFloat::convertFromString(StringRef str,
+                                                 roundingMode rounding_mode) {
   assert(!str.empty() && "Invalid string length");
 
   // Handle special cases.
   if (convertFromStringSpecials(str))
     return opOK;
 
   /* Handle a leading minus sign.  */
   StringRef::iterator p = str.begin();
/* Write out a hexadecimal representation of the floating point value
    The above rules are as specified by C99.  There is ambiguity about
    what the leading hexadecimal digit should be.  This implementation
    uses whatever is necessary so that the exponent is displayed as
    stored.  This implies the exponent will fall within the IEEE format
    range, and the leading hexadecimal digit will be 0 (for denormals),
    1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
    any other digits zero).
 */
-unsigned int
-APFloat::convertToHexString(char *dst, unsigned int hexDigits,
-                            bool upperCase, roundingMode rounding_mode) const
-{
+unsigned int IEEEFloat::convertToHexString(char *dst, unsigned int hexDigits,
+                                           bool upperCase,
+                                           roundingMode rounding_mode) const {
   char *p;
 
   p = dst;
   if (sign)
     *dst++ = '-';
 
   switch (category) {
   case fcInfinity:
unsigned int IEEEFloat::convertToHexString(char *dst, unsigned int hexDigits,
 
   return static_cast<unsigned int>(dst - p);
 }
 
 /* Does the hard work of outputting the correctly rounded hexadecimal
    form of a normal floating point number with the specified number of
    hexadecimal digits.  If HEXDIGITS is zero the minimum number of
    digits necessary to print the value precisely is output.  */
-char *
-APFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
+char *IEEEFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
                                           bool upperCase,
-                                  roundingMode rounding_mode) const
-{
+                                          roundingMode rounding_mode) const {
   unsigned int count, valueBits, shift, partsCount, outputDigits;
   const char *hexDigitChars;
   const integerPart *significand;
   char *p;
   bool roundUp;
 
   *dst++ = '0';
   *dst++ = upperCase ? 'X': 'x';
else
     p[0] = '.';
 
   /* Finally output the exponent.  */
   *dst++ = upperCase ? 'P': 'p';
 
   return writeSignedDecimal (dst, exponent);
 }
 
-hash_code llvm::hash_value(const APFloat &Arg) {
+hash_code hash_value(const IEEEFloat &Arg) {
   if (!Arg.isFiniteNonZero())
     return hash_combine((uint8_t)Arg.category,
                         // NaN has no sign, fix it at zero.
                         Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
                         Arg.semantics->precision);
 
   // Normal floats need their exponent and significand hashed.
   return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
                       Arg.semantics->precision, Arg.exponent,
                       hash_combine_range(
                         Arg.significandParts(),
                         Arg.significandParts() + Arg.partCount()));
 }
 
 // Conversion from APFloat to/from host float/double.  It may eventually be
 // possible to eliminate these and have everybody deal with APFloats, but that
 // will take a while.  This approach will not easily extend to long double.
 // Current implementation requires integerPartWidth==64, which is correct at
 // the moment but could be made more general.
 
 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
 // the actual IEEE respresentations.  We compensate for that here.
 
-APInt
-APFloat::convertF80LongDoubleAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
   assert(partCount()==2);
 
   uint64_t myexponent, mysignificand;
 
   if (isFiniteNonZero()) {
     myexponent = exponent+16383; //bias
     mysignificand = significandParts()[0];
APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt() const {
 
   uint64_t words[2];
   words[0] = mysignificand;
   words[1] =  ((uint64_t)(sign & 1) << 15) |
               (myexponent & 0x7fffLL);
   return APInt(80, words);
 }
 
-APInt
-APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertPPCDoubleDoubleAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
   assert(partCount()==2);
 
   uint64_t words[2];
   opStatus fs;
   bool losesInfo;
 
   // Convert number to double.  To avoid spurious underflows, we re-
   // normalize against the "double" minExponent first, and only *then*
   // truncate the mantissa.  The result of that second conversion
   // may be inexact, but should never underflow.
   // Declare fltSemantics before APFloat that uses it (and
   // saves pointer to it) to ensure correct destruction order.
   fltSemantics extendedSemantics = *semantics;
   extendedSemantics.minExponent = IEEEdouble.minExponent;
-  APFloat extended(*this);
+  IEEEFloat extended(*this);
   fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
   assert(fs == opOK && !losesInfo);
   (void)fs;
 
-  APFloat u(extended);
+  IEEEFloat u(extended);
   fs = u.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
   assert(fs == opOK || fs == opInexact);
   (void)fs;
   words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
 
   // If conversion was exact or resulted in a special case, we're done;
   // just set the second double to zero.  Otherwise, re-convert back to
   // the extended format and compute the difference.  This now should
   // convert exactly to double.
   if (u.isFiniteNonZero() && losesInfo) {
     fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
     assert(fs == opOK && !losesInfo);
     (void)fs;
 
-    APFloat v(extended);
+    IEEEFloat v(extended);
     v.subtract(u, rmNearestTiesToEven);
     fs = v.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
     assert(fs == opOK && !losesInfo);
     (void)fs;
     words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
   } else {
     words[1] = 0;
   }
 
   return APInt(128, words);
 }
 
-APInt
-APFloat::convertQuadrupleAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertQuadrupleAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEquad);
   assert(partCount()==2);
 
   uint64_t myexponent, mysignificand, mysignificand2;
 
   if (isFiniteNonZero()) {
     myexponent = exponent+16383; //bias
     mysignificand = significandParts()[0];
APInt IEEEFloat::convertQuadrupleAPFloatToAPInt() const {
   words[0] = mysignificand;
   words[1] = ((uint64_t)(sign & 1) << 63) |
              ((myexponent & 0x7fff) << 48) |
              (mysignificand2 & 0xffffffffffffLL);
 
   return APInt(128, words);
 }
 
-APInt
-APFloat::convertDoubleAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertDoubleAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
   assert(partCount()==1);
 
   uint64_t myexponent, mysignificand;
 
   if (isFiniteNonZero()) {
     myexponent = exponent+1023; //bias
     mysignificand = *significandParts();
if (isFiniteNonZero()) {
     mysignificand = *significandParts();
   }
 
   return APInt(64, ((((uint64_t)(sign & 1) << 63) |
                      ((myexponent & 0x7ff) <<  52) |
                      (mysignificand & 0xfffffffffffffLL))));
 }
 
-APInt
-APFloat::convertFloatAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertFloatAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
   assert(partCount()==1);
 
   uint32_t myexponent, mysignificand;
 
   if (isFiniteNonZero()) {
     myexponent = exponent+127; //bias
     mysignificand = (uint32_t)*significandParts();
if (isFiniteNonZero()) {
     myexponent = 0xff;
     mysignificand = (uint32_t)*significandParts();
   }
 
   return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
                     (mysignificand & 0x7fffff)));
 }
 
-APInt
-APFloat::convertHalfAPFloatToAPInt() const
-{
+APInt IEEEFloat::convertHalfAPFloatToAPInt() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEhalf);
   assert(partCount()==1);
 
   uint32_t myexponent, mysignificand;
 
   if (isFiniteNonZero()) {
     myexponent = exponent+15; //bias
     mysignificand = (uint32_t)*significandParts();
APInt IEEEFloat::convertHalfAPFloatToAPInt() const {
   return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
                     (mysignificand & 0x3ff)));
 }
 
 // This function creates an APInt that is just a bit map of the floating
 // point constant as it would appear in memory.  It is not a conversion,
 // and treating the result as a normal integer is unlikely to be useful.
 
-APInt
-APFloat::bitcastToAPInt() const
-{
+APInt IEEEFloat::bitcastToAPInt() const {
   if (semantics == (const llvm::fltSemantics*)&IEEEhalf)
     return convertHalfAPFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
     return convertFloatAPFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
     return convertDoubleAPFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics*)&IEEEquad)
     return convertQuadrupleAPFloatToAPInt();
 
   if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
     return convertPPCDoubleDoubleAPFloatToAPInt();
 
   assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
          "unknown format!");
   return convertF80LongDoubleAPFloatToAPInt();
 }
 
-float
-APFloat::convertToFloat() const
-{
+float IEEEFloat::convertToFloat() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEsingle &&
          "Float semantics are not IEEEsingle");
   APInt api = bitcastToAPInt();
   return api.bitsToFloat();
 }
 
-double
-APFloat::convertToDouble() const
-{
+double IEEEFloat::convertToDouble() const {
   assert(semantics == (const llvm::fltSemantics*)&IEEEdouble &&
          "Float semantics are not IEEEdouble");
   APInt api = bitcastToAPInt();
   return api.bitsToDouble();
 }
 
 /// Integer bit is explicit in this format.  Intel hardware (387 and later)
 /// does not support these bit patterns:
 ///  exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
 ///  exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
 ///  exponent = 0, integer bit 1 ("pseudodenormal")
 ///  exponent!=0 nor all 1's, integer bit 0 ("unnormal")
 /// At the moment, the first two are treated as NaNs, the second two as Normal.
-void
-APFloat::initFromF80LongDoubleAPInt(const APInt &api)
-{
+void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
   assert(api.getBitWidth()==80);
   uint64_t i1 = api.getRawData()[0];
   uint64_t i2 = api.getRawData()[1];
   uint64_t myexponent = (i2 & 0x7fff);
   uint64_t mysignificand = i1;
 
-  initialize(&APFloat::x87DoubleExtended);
+  initialize(&IEEEFloat::x87DoubleExtended);
   assert(partCount()==2);
 
   sign = static_cast<unsigned int>(i2>>15);
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
     // exponent, significand meaningless
     category = fcInfinity;
   } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
     // exponent meaningless
     category = fcNaN;
     significandParts()[0] = mysignificand;
     significandParts()[1] = 0;
   } else {
     category = fcNormal;
     exponent = myexponent - 16383;
     significandParts()[0] = mysignificand;
     significandParts()[1] = 0;
     if (myexponent==0)          // denormal
       exponent = -16382;
   }
 }
 
-void
-APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
-{
+void IEEEFloat::initFromPPCDoubleDoubleAPInt(const APInt &api) {
   assert(api.getBitWidth()==128);
   uint64_t i1 = api.getRawData()[0];
   uint64_t i2 = api.getRawData()[1];
   opStatus fs;
   bool losesInfo;
 
   // Get the first double and convert to our format.
   initFromDoubleAPInt(APInt(64, i1));
   fs = convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
   assert(fs == opOK && !losesInfo);
   (void)fs;
 
   // Unless we have a special case, add in second double.
   if (isFiniteNonZero()) {
-    APFloat v(IEEEdouble, APInt(64, i2));
+    IEEEFloat v(IEEEdouble, APInt(64, i2));
     fs = v.convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
     assert(fs == opOK && !losesInfo);
     (void)fs;
 
     add(v, rmNearestTiesToEven);
   }
 }
 
-void
-APFloat::initFromQuadrupleAPInt(const APInt &api)
-{
+void IEEEFloat::initFromQuadrupleAPInt(const APInt &api) {
   assert(api.getBitWidth()==128);
   uint64_t i1 = api.getRawData()[0];
   uint64_t i2 = api.getRawData()[1];
   uint64_t myexponent = (i2 >> 48) & 0x7fff;
   uint64_t mysignificand  = i1;
   uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
 
-  initialize(&APFloat::IEEEquad);
+  initialize(&IEEEFloat::IEEEquad);
   assert(partCount()==2);
 
   sign = static_cast<unsigned int>(i2>>63);
   if (myexponent==0 &&
       (mysignificand==0 && mysignificand2==0)) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0x7fff &&
if (myexponent==0 &&
     significandParts()[1] = mysignificand2;
     if (myexponent==0)          // denormal
       exponent = -16382;
     else
       significandParts()[1] |= 0x1000000000000LL;  // integer bit
   }
 }
 
-void
-APFloat::initFromDoubleAPInt(const APInt &api)
-{
+void IEEEFloat::initFromDoubleAPInt(const APInt &api) {
   assert(api.getBitWidth()==64);
   uint64_t i = *api.getRawData();
   uint64_t myexponent = (i >> 52) & 0x7ff;
   uint64_t mysignificand = i & 0xfffffffffffffLL;
 
-  initialize(&APFloat::IEEEdouble);
+  initialize(&IEEEFloat::IEEEdouble);
   assert(partCount()==1);
 
   sign = static_cast<unsigned int>(i>>63);
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0x7ff && mysignificand==0) {
     // exponent, significand meaningless
     category = fcInfinity;
   } else if (myexponent==0x7ff && mysignificand!=0) {
     // exponent meaningless
     category = fcNaN;
     *significandParts() = mysignificand;
   } else {
     category = fcNormal;
     exponent = myexponent - 1023;
     *significandParts() = mysignificand;
     if (myexponent==0)          // denormal
       exponent = -1022;
     else
       *significandParts() |= 0x10000000000000LL;  // integer bit
   }
 }
 
-void
-APFloat::initFromFloatAPInt(const APInt & api)
-{
+void IEEEFloat::initFromFloatAPInt(const APInt &api) {
   assert(api.getBitWidth()==32);
   uint32_t i = (uint32_t)*api.getRawData();
   uint32_t myexponent = (i >> 23) & 0xff;
   uint32_t mysignificand = i & 0x7fffff;
 
-  initialize(&APFloat::IEEEsingle);
+  initialize(&IEEEFloat::IEEEsingle);
   assert(partCount()==1);
 
   sign = i >> 31;
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0xff && mysignificand==0) {
     // exponent, significand meaningless
     category = fcInfinity;
   } else if (myexponent==0xff && mysignificand!=0) {
     // sign, exponent, significand meaningless
     category = fcNaN;
     *significandParts() = mysignificand;
   } else {
     category = fcNormal;
     exponent = myexponent - 127;  //bias
     *significandParts() = mysignificand;
     if (myexponent==0)    // denormal
       exponent = -126;
     else
       *significandParts() |= 0x800000; // integer bit
   }
 }
 
-void
-APFloat::initFromHalfAPInt(const APInt & api)
-{
+void IEEEFloat::initFromHalfAPInt(const APInt &api) {
   assert(api.getBitWidth()==16);
   uint32_t i = (uint32_t)*api.getRawData();
   uint32_t myexponent = (i >> 10) & 0x1f;
   uint32_t mysignificand = i & 0x3ff;
 
-  initialize(&APFloat::IEEEhalf);
+  initialize(&IEEEFloat::IEEEhalf);
   assert(partCount()==1);
 
   sign = i >> 15;
   if (myexponent==0 && mysignificand==0) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0x1f && mysignificand==0) {
     // exponent, significand meaningless
else
       *significandParts() |= 0x400; // integer bit
   }
 }
 
 /// Treat api as containing the bits of a floating point number.  Currently
 /// we infer the floating point type from the size of the APInt.  The
 /// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
 /// when the size is anything else).
-void
-APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
-{
+void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
   if (Sem == &IEEEhalf)
     return initFromHalfAPInt(api);
   if (Sem == &IEEEsingle)
     return initFromFloatAPInt(api);
   if (Sem == &IEEEdouble)
     return initFromDoubleAPInt(api);
   if (Sem == &x87DoubleExtended)
     return initFromF80LongDoubleAPInt(api);
   if (Sem == &IEEEquad)
     return initFromQuadrupleAPInt(api);
   if (Sem == &PPCDoubleDouble)
     return initFromPPCDoubleDoubleAPInt(api);
 
   llvm_unreachable(nullptr);
 }
 
-APFloat
-APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE)
-{
+IEEEFloat IEEEFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE) {
   switch (BitWidth) {
   case 16:
-    return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
+    return IEEEFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
   case 32:
-    return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
+    return IEEEFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
   case 64:
-    return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
+    return IEEEFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
   case 80:
-    return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
+    return IEEEFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
   case 128:
     if (isIEEE)
-      return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
-    return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
+      return IEEEFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
+    return IEEEFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
   default:
     llvm_unreachable("Unknown floating bit width");
   }
 }
 
-unsigned APFloat::getSizeInBits(const fltSemantics &Sem) {
-  return Sem.sizeInBits;
-}
-
 /// Make this number the largest magnitude normal number in the given
 /// semantics.
-void APFloat::makeLargest(bool Negative) {
+void IEEEFloat::makeLargest(bool Negative) {
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 1..10
   //   significand = 1..1
   category = fcNormal;
   sign = Negative;
   exponent = semantics->maxExponent;
 
   // Use memset to set all but the highest integerPart to all ones.
   integerPart *significand = significandParts();
   unsigned PartCount = partCount();
   memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));
 
   // Set the high integerPart especially setting all unused top bits for
   // internal consistency.
   const unsigned NumUnusedHighBits =
     PartCount*integerPartWidth - semantics->precision;
   significand[PartCount - 1] = (NumUnusedHighBits < integerPartWidth)
                                    ? (~integerPart(0) >> NumUnusedHighBits)
                                    : 0;
 }
 
 /// Make this number the smallest magnitude denormal number in the given
 /// semantics.
-void APFloat::makeSmallest(bool Negative) {
+void IEEEFloat::makeSmallest(bool Negative) {
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 0..0
   //   significand = 0..01
   category = fcNormal;
   sign = Negative;
   exponent = semantics->minExponent;
   APInt::tcSet(significandParts(), 1, partCount());
 }
 
-
-APFloat APFloat::getLargest(const fltSemantics &Sem, bool Negative) {
+IEEEFloat IEEEFloat::getLargest(const fltSemantics &Sem, bool Negative) {
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 1..10
   //   significand = 1..1
-  APFloat Val(Sem, uninitialized);
+  IEEEFloat Val(Sem, uninitialized);
   Val.makeLargest(Negative);
   return Val;
 }
 
-APFloat APFloat::getSmallest(const fltSemantics &Sem, bool Negative) {
+IEEEFloat IEEEFloat::getSmallest(const fltSemantics &Sem, bool Negative) {
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 0..0
   //   significand = 0..01
-  APFloat Val(Sem, uninitialized);
+  IEEEFloat Val(Sem, uninitialized);
   Val.makeSmallest(Negative);
   return Val;
 }
 
-APFloat APFloat::getSmallestNormalized(const fltSemantics &Sem, bool Negative) {
-  APFloat Val(Sem, uninitialized);
+IEEEFloat IEEEFloat::getSmallestNormalized(const fltSemantics &Sem,
+                                           bool Negative) {
+  IEEEFloat Val(Sem, uninitialized);
 
   // We want (in interchange format):
   //   sign = {Negative}
   //   exponent = 0..0
   //   significand = 10..0
 
   Val.category = fcNormal;
   Val.zeroSignificand();
   Val.sign = Negative;
   Val.exponent = Sem.minExponent;
   Val.significandParts()[partCountForBits(Sem.precision)-1] |=
     (((integerPart) 1) << ((Sem.precision - 1) % integerPartWidth));
 
   return Val;
 }
 
-APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
+IEEEFloat::IEEEFloat(const fltSemantics &Sem, const APInt &API) {
   initFromAPInt(&Sem, API);
 }
 
-APFloat::APFloat(float f) {
+IEEEFloat::IEEEFloat(float f) {
   initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
 }
 
-APFloat::APFloat(double d) {
+IEEEFloat::IEEEFloat(double d) {
   initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
 }
 
 namespace {
   void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
     Buffer.append(Str.begin(), Str.end());
   }
 
if (FirstSignificant == N) {
       return;
     }
 
     exp += FirstSignificant;
     buffer.erase(&buffer[0], &buffer[FirstSignificant]);
   }
 }
 
-void APFloat::toString(SmallVectorImpl<char> &Str,
-                       unsigned FormatPrecision,
+void IEEEFloat::toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
                          unsigned FormatMaxPadding) const {
   switch (category) {
   case fcInfinity:
     if (isNegative())
       return append(Str, "-Inf");
     else
       return append(Str, "+Inf");
 
   case fcNaN: return append(Str, "NaN");
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 APFloat::getExactInverse(APFloat *inv) const {
+bool IEEEFloat::getExactInverse(IEEEFloat *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.
-  APFloat reciprocal(*semantics, 1ULL);
+  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;
 
   return true;
 }
 
-bool APFloat::isSignaling() const {
+bool IEEEFloat::isSignaling() const {
   if (!isNaN())
     return false;
 
   // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
   // first bit of the trailing significand being 0.
   return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
 }
 
 /// IEEE-754R 2008 5.3.1: nextUp/nextDown.
 ///
 /// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
 /// appropriate sign switching before/after the computation.
-APFloat::opStatus APFloat::next(bool nextDown) {
+IEEEFloat::opStatus IEEEFloat::next(bool nextDown) {
   // If we are performing nextDown, swap sign so we have -x.
   if (nextDown)
     changeSign();
 
   // Compute nextUp(x)
   opStatus result = opOK;
 
   // Handle each float category separately.
IEEEFloat::opStatus IEEEFloat::next(bool nextDown) {
 
   // If we are performing nextDown, swap sign so we have -nextUp(-x)
   if (nextDown)
     changeSign();
 
   return result;
 }
 
-void
-APFloat::makeInf(bool Negative) {
+void IEEEFloat::makeInf(bool Negative) {
   category = fcInfinity;
   sign = Negative;
   exponent = semantics->maxExponent + 1;
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
-void
-APFloat::makeZero(bool Negative) {
+void IEEEFloat::makeZero(bool Negative) {
   category = fcZero;
   sign = Negative;
   exponent = semantics->minExponent-1;
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
-void APFloat::makeQuiet() {
+void IEEEFloat::makeQuiet() {
   assert(isNaN());
   APInt::tcSetBit(significandParts(), semantics->precision - 2);
 }
 
-int llvm::ilogb(const APFloat &Arg) {
+int ilogb(const IEEEFloat &Arg) {
   if (Arg.isNaN())
-    return APFloat::IEK_NaN;
+    return IEEEFloat::IEK_NaN;
   if (Arg.isZero())
-    return APFloat::IEK_Zero;
+    return IEEEFloat::IEK_Zero;
   if (Arg.isInfinity())
-    return APFloat::IEK_Inf;
+    return IEEEFloat::IEK_Inf;
   if (!Arg.isDenormal())
     return Arg.exponent;
 
-  APFloat Normalized(Arg);
+  IEEEFloat Normalized(Arg);
   int SignificandBits = Arg.getSemantics().precision - 1;
 
   Normalized.exponent += SignificandBits;
-  Normalized.normalize(APFloat::rmNearestTiesToEven, lfExactlyZero);
+  Normalized.normalize(IEEEFloat::rmNearestTiesToEven, lfExactlyZero);
   return Normalized.exponent - SignificandBits;
 }
 
-APFloat llvm::scalbn(APFloat X, int Exp, APFloat::roundingMode RoundingMode) {
+IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode RoundingMode) {
   auto MaxExp = X.getSemantics().maxExponent;
   auto MinExp = X.getSemantics().minExponent;
 
   // If Exp is wildly out-of-scale, simply adding it to X.exponent will
   // overflow; clamp it to a safe range before adding, but ensure that the range
   // is large enough that the clamp does not change the result. The range we
   // need to support is the difference between the largest possible exponent and
   // the normalized exponent of half the smallest denormal.
 
   int SignificandBits = X.getSemantics().precision - 1;
   int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
 
   // Clamp to one past the range ends to let normalize handle overlflow.
   X.exponent += std::min(std::max(Exp, -MaxIncrement - 1), MaxIncrement);
   X.normalize(RoundingMode, lfExactlyZero);
   if (X.isNaN())
     X.makeQuiet();
   return X;
 }
 
-APFloat llvm::frexp(const APFloat &Val, int &Exp, APFloat::roundingMode RM) {
+IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM) {
   Exp = ilogb(Val);
 
   // Quiet signalling nans.
-  if (Exp == APFloat::IEK_NaN) {
-    APFloat Quiet(Val);
+  if (Exp == IEEEFloat::IEK_NaN) {
+    IEEEFloat Quiet(Val);
     Quiet.makeQuiet();
     return Quiet;
   }
 
-  if (Exp == APFloat::IEK_Inf)
+  if (Exp == IEEEFloat::IEK_Inf)
     return Val;
 
   // 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 == APFloat::IEK_Zero ? 0 : Exp + 1;
+  Exp = Exp == IEEEFloat::IEK_Zero ? 0 : Exp + 1;
   return scalbn(Val, -Exp, RM);
 }
+
+} // End detail namespace
+
+APFloat::opStatus APFloat::convertFromString(StringRef Str, roundingMode RM) {
+  return IEEE.convertFromString(Str, RM);
+}
+
+hash_code hash_value(const APFloat &Arg) { return hash_value(Arg.IEEE); }
+
+APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
+    : APFloat(IEEEFloat(Semantics, S)) {}
+
+} // End llvm namespace