LCOV - code coverage report
Current view: top level - include/llvm/ADT - APFloat.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 236 246 95.9 %
Date: 2017-09-14 15:23:50 Functions: 63 67 94.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : ///
      10             : /// \file
      11             : /// \brief
      12             : /// This file declares a class to represent arbitrary precision floating point
      13             : /// values and provide a variety of arithmetic operations on them.
      14             : ///
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #ifndef LLVM_ADT_APFLOAT_H
      18             : #define LLVM_ADT_APFLOAT_H
      19             : 
      20             : #include "llvm/ADT/APInt.h"
      21             : #include "llvm/ADT/ArrayRef.h"
      22             : #include "llvm/Support/ErrorHandling.h"
      23             : #include <memory>
      24             : 
      25             : #define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)                             \
      26             :   do {                                                                         \
      27             :     if (usesLayout<IEEEFloat>(getSemantics()))                                 \
      28             :       return U.IEEE.METHOD_CALL;                                               \
      29             :     if (usesLayout<DoubleAPFloat>(getSemantics()))                             \
      30             :       return U.Double.METHOD_CALL;                                             \
      31             :     llvm_unreachable("Unexpected semantics");                                  \
      32             :   } while (false)
      33             : 
      34             : namespace llvm {
      35             : 
      36             : struct fltSemantics;
      37             : class APSInt;
      38             : class StringRef;
      39             : class APFloat;
      40             : class raw_ostream;
      41             : 
      42             : template <typename T> class SmallVectorImpl;
      43             : 
      44             : /// Enum that represents what fraction of the LSB truncated bits of an fp number
      45             : /// represent.
      46             : ///
      47             : /// This essentially combines the roles of guard and sticky bits.
      48             : enum lostFraction { // Example of truncated bits:
      49             :   lfExactlyZero,    // 000000
      50             :   lfLessThanHalf,   // 0xxxxx  x's not all zero
      51             :   lfExactlyHalf,    // 100000
      52             :   lfMoreThanHalf    // 1xxxxx  x's not all zero
      53             : };
      54             : 
      55             : /// A self-contained host- and target-independent arbitrary-precision
      56             : /// floating-point software implementation.
      57             : ///
      58             : /// APFloat uses bignum integer arithmetic as provided by static functions in
      59             : /// the APInt class.  The library will work with bignum integers whose parts are
      60             : /// any unsigned type at least 16 bits wide, but 64 bits is recommended.
      61             : ///
      62             : /// Written for clarity rather than speed, in particular with a view to use in
      63             : /// the front-end of a cross compiler so that target arithmetic can be correctly
      64             : /// performed on the host.  Performance should nonetheless be reasonable,
      65             : /// particularly for its intended use.  It may be useful as a base
      66             : /// implementation for a run-time library during development of a faster
      67             : /// target-specific one.
      68             : ///
      69             : /// All 5 rounding modes in the IEEE-754R draft are handled correctly for all
      70             : /// implemented operations.  Currently implemented operations are add, subtract,
      71             : /// multiply, divide, fused-multiply-add, conversion-to-float,
      72             : /// conversion-to-integer and conversion-from-integer.  New rounding modes
      73             : /// (e.g. away from zero) can be added with three or four lines of code.
      74             : ///
      75             : /// Four formats are built-in: IEEE single precision, double precision,
      76             : /// quadruple precision, and x87 80-bit extended double (when operating with
      77             : /// full extended precision).  Adding a new format that obeys IEEE semantics
      78             : /// only requires adding two lines of code: a declaration and definition of the
      79             : /// format.
      80             : ///
      81             : /// All operations return the status of that operation as an exception bit-mask,
      82             : /// so multiple operations can be done consecutively with their results or-ed
      83             : /// together.  The returned status can be useful for compiler diagnostics; e.g.,
      84             : /// inexact, underflow and overflow can be easily diagnosed on constant folding,
      85             : /// and compiler optimizers can determine what exceptions would be raised by
      86             : /// folding operations and optimize, or perhaps not optimize, accordingly.
      87             : ///
      88             : /// At present, underflow tininess is detected after rounding; it should be
      89             : /// straight forward to add support for the before-rounding case too.
      90             : ///
      91             : /// The library reads hexadecimal floating point numbers as per C99, and
      92             : /// correctly rounds if necessary according to the specified rounding mode.
      93             : /// Syntax is required to have been validated by the caller.  It also converts
      94             : /// floating point numbers to hexadecimal text as per the C99 %a and %A
      95             : /// conversions.  The output precision (or alternatively the natural minimal
      96             : /// precision) can be specified; if the requested precision is less than the
      97             : /// natural precision the output is correctly rounded for the specified rounding
      98             : /// mode.
      99             : ///
     100             : /// It also reads decimal floating point numbers and correctly rounds according
     101             : /// to the specified rounding mode.
     102             : ///
     103             : /// Conversion to decimal text is not currently implemented.
     104             : ///
     105             : /// Non-zero finite numbers are represented internally as a sign bit, a 16-bit
     106             : /// signed exponent, and the significand as an array of integer parts.  After
     107             : /// normalization of a number of precision P the exponent is within the range of
     108             : /// the format, and if the number is not denormal the P-th bit of the
     109             : /// significand is set as an explicit integer bit.  For denormals the most
     110             : /// significant bit is shifted right so that the exponent is maintained at the
     111             : /// format's minimum, so that the smallest denormal has just the least
     112             : /// significant bit of the significand set.  The sign of zeroes and infinities
     113             : /// is significant; the exponent and significand of such numbers is not stored,
     114             : /// but has a known implicit (deterministic) value: 0 for the significands, 0
     115             : /// for zero exponent, all 1 bits for infinity exponent.  For NaNs the sign and
     116             : /// significand are deterministic, although not really meaningful, and preserved
     117             : /// in non-conversion operations.  The exponent is implicitly all 1 bits.
     118             : ///
     119             : /// APFloat does not provide any exception handling beyond default exception
     120             : /// handling. We represent Signaling NaNs via IEEE-754R 2008 6.2.1 should clause
     121             : /// by encoding Signaling NaNs with the first bit of its trailing significand as
     122             : /// 0.
     123             : ///
     124             : /// TODO
     125             : /// ====
     126             : ///
     127             : /// Some features that may or may not be worth adding:
     128             : ///
     129             : /// Binary to decimal conversion (hard).
     130             : ///
     131             : /// Optional ability to detect underflow tininess before rounding.
     132             : ///
     133             : /// New formats: x87 in single and double precision mode (IEEE apart from
     134             : /// extended exponent range) (hard).
     135             : ///
     136             : /// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward.
     137             : ///
     138             : 
     139             : // This is the common type definitions shared by APFloat and its internal
     140             : // implementation classes. This struct should not define any non-static data
     141             : // members.
     142             : struct APFloatBase {
     143             :   typedef APInt::WordType integerPart;
     144             :   static const unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD;
     145             : 
     146             :   /// A signed type to represent a floating point numbers unbiased exponent.
     147             :   typedef signed short ExponentType;
     148             : 
     149             :   /// \name Floating Point Semantics.
     150             :   /// @{
     151             : 
     152             :   static const fltSemantics &IEEEhalf() LLVM_READNONE;
     153             :   static const fltSemantics &IEEEsingle() LLVM_READNONE;
     154             :   static const fltSemantics &IEEEdouble() LLVM_READNONE;
     155             :   static const fltSemantics &IEEEquad() LLVM_READNONE;
     156             :   static const fltSemantics &PPCDoubleDouble() LLVM_READNONE;
     157             :   static const fltSemantics &x87DoubleExtended() LLVM_READNONE;
     158             : 
     159             :   /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with
     160             :   /// anything real.
     161             :   static const fltSemantics &Bogus() LLVM_READNONE;
     162             : 
     163             :   /// @}
     164             : 
     165             :   /// IEEE-754R 5.11: Floating Point Comparison Relations.
     166             :   enum cmpResult {
     167             :     cmpLessThan,
     168             :     cmpEqual,
     169             :     cmpGreaterThan,
     170             :     cmpUnordered
     171             :   };
     172             : 
     173             :   /// IEEE-754R 4.3: Rounding-direction attributes.
     174             :   enum roundingMode {
     175             :     rmNearestTiesToEven,
     176             :     rmTowardPositive,
     177             :     rmTowardNegative,
     178             :     rmTowardZero,
     179             :     rmNearestTiesToAway
     180             :   };
     181             : 
     182             :   /// IEEE-754R 7: Default exception handling.
     183             :   ///
     184             :   /// opUnderflow or opOverflow are always returned or-ed with opInexact.
     185             :   enum opStatus {
     186             :     opOK = 0x00,
     187             :     opInvalidOp = 0x01,
     188             :     opDivByZero = 0x02,
     189             :     opOverflow = 0x04,
     190             :     opUnderflow = 0x08,
     191             :     opInexact = 0x10
     192             :   };
     193             : 
     194             :   /// Category of internally-represented number.
     195             :   enum fltCategory {
     196             :     fcInfinity,
     197             :     fcNaN,
     198             :     fcNormal,
     199             :     fcZero
     200             :   };
     201             : 
     202             :   /// Convenience enum used to construct an uninitialized APFloat.
     203             :   enum uninitializedTag {
     204             :     uninitialized
     205             :   };
     206             : 
     207             :   /// Enumeration of \c ilogb error results.
     208             :   enum IlogbErrorKinds {
     209             :     IEK_Zero = INT_MIN + 1,
     210             :     IEK_NaN = INT_MIN,
     211             :     IEK_Inf = INT_MAX
     212             :   };
     213             : 
     214             :   static unsigned int semanticsPrecision(const fltSemantics &);
     215             :   static ExponentType semanticsMinExponent(const fltSemantics &);
     216             :   static ExponentType semanticsMaxExponent(const fltSemantics &);
     217             :   static unsigned int semanticsSizeInBits(const fltSemantics &);
     218             : 
     219             :   /// Returns the size of the floating point number (in bits) in the given
     220             :   /// semantics.
     221             :   static unsigned getSizeInBits(const fltSemantics &Sem);
     222             : };
     223             : 
     224             : namespace detail {
     225             : 
     226             : class IEEEFloat final : public APFloatBase {
     227             : public:
     228             :   /// \name Constructors
     229             :   /// @{
     230             : 
     231             :   IEEEFloat(const fltSemantics &); // Default construct to 0.0
     232             :   IEEEFloat(const fltSemantics &, integerPart);
     233             :   IEEEFloat(const fltSemantics &, uninitializedTag);
     234             :   IEEEFloat(const fltSemantics &, const APInt &);
     235             :   explicit IEEEFloat(double d);
     236             :   explicit IEEEFloat(float f);
     237             :   IEEEFloat(const IEEEFloat &);
     238             :   IEEEFloat(IEEEFloat &&);
     239             :   ~IEEEFloat();
     240             : 
     241             :   /// @}
     242             : 
     243             :   /// Returns whether this instance allocated memory.
     244    10094662 :   bool needsCleanup() const { return partCount() > 1; }
     245             : 
     246             :   /// \name Convenience "constructors"
     247             :   /// @{
     248             : 
     249             :   /// @}
     250             : 
     251             :   /// \name Arithmetic
     252             :   /// @{
     253             : 
     254             :   opStatus add(const IEEEFloat &, roundingMode);
     255             :   opStatus subtract(const IEEEFloat &, roundingMode);
     256             :   opStatus multiply(const IEEEFloat &, roundingMode);
     257             :   opStatus divide(const IEEEFloat &, roundingMode);
     258             :   /// IEEE remainder.
     259             :   opStatus remainder(const IEEEFloat &);
     260             :   /// C fmod, or llvm frem.
     261             :   opStatus mod(const IEEEFloat &);
     262             :   opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode);
     263             :   opStatus roundToIntegral(roundingMode);
     264             :   /// IEEE-754R 5.3.1: nextUp/nextDown.
     265             :   opStatus next(bool nextDown);
     266             : 
     267             :   /// @}
     268             : 
     269             :   /// \name Sign operations.
     270             :   /// @{
     271             : 
     272             :   void changeSign();
     273             : 
     274             :   /// @}
     275             : 
     276             :   /// \name Conversions
     277             :   /// @{
     278             : 
     279             :   opStatus convert(const fltSemantics &, roundingMode, bool *);
     280             :   opStatus convertToInteger(MutableArrayRef<integerPart>, unsigned int, bool,
     281             :                             roundingMode, bool *) const;
     282             :   opStatus convertFromAPInt(const APInt &, bool, roundingMode);
     283             :   opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int,
     284             :                                           bool, roundingMode);
     285             :   opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int,
     286             :                                           bool, roundingMode);
     287             :   opStatus convertFromString(StringRef, roundingMode);
     288             :   APInt bitcastToAPInt() const;
     289             :   double convertToDouble() const;
     290             :   float convertToFloat() const;
     291             : 
     292             :   /// @}
     293             : 
     294             :   /// The definition of equality is not straightforward for floating point, so
     295             :   /// we won't use operator==.  Use one of the following, or write whatever it
     296             :   /// is you really mean.
     297             :   bool operator==(const IEEEFloat &) const = delete;
     298             : 
     299             :   /// IEEE comparison with another floating point number (NaNs compare
     300             :   /// unordered, 0==-0).
     301             :   cmpResult compare(const IEEEFloat &) const;
     302             : 
     303             :   /// Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
     304             :   bool bitwiseIsEqual(const IEEEFloat &) const;
     305             : 
     306             :   /// Write out a hexadecimal representation of the floating point value to DST,
     307             :   /// which must be of sufficient size, in the C99 form [-]0xh.hhhhp[+-]d.
     308             :   /// Return the number of characters written, excluding the terminating NUL.
     309             :   unsigned int convertToHexString(char *dst, unsigned int hexDigits,
     310             :                                   bool upperCase, roundingMode) const;
     311             : 
     312             :   /// \name IEEE-754R 5.7.2 General operations.
     313             :   /// @{
     314             : 
     315             :   /// IEEE-754R isSignMinus: Returns true if and only if the current value is
     316             :   /// negative.
     317             :   ///
     318             :   /// This applies to zeros and NaNs as well.
     319       56750 :   bool isNegative() const { return sign; }
     320             : 
     321             :   /// IEEE-754R isNormal: Returns true if and only if the current value is normal.
     322             :   ///
     323             :   /// This implies that the current value of the float is not zero, subnormal,
     324             :   /// infinite, or NaN following the definition of normality from IEEE-754R.
     325             :   bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
     326             : 
     327             :   /// Returns true if and only if the current value is zero, subnormal, or
     328             :   /// normal.
     329             :   ///
     330             :   /// This means that the value is not infinite or NaN.
     331     2344169 :   bool isFinite() const { return !isNaN() && !isInfinity(); }
     332             : 
     333             :   /// Returns true if and only if the float is plus or minus zero.
     334           2 :   bool isZero() const { return category == fcZero; }
     335             : 
     336             :   /// IEEE-754R isSubnormal(): Returns true if and only if the float is a
     337             :   /// denormal.
     338             :   bool isDenormal() const;
     339             : 
     340             :   /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
     341             :   bool isInfinity() const { return category == fcInfinity; }
     342             : 
     343             :   /// Returns true if and only if the float is a quiet or signaling NaN.
     344     1638605 :   bool isNaN() const { return category == fcNaN; }
     345             : 
     346             :   /// Returns true if and only if the float is a signaling NaN.
     347             :   bool isSignaling() const;
     348             : 
     349             :   /// @}
     350             : 
     351             :   /// \name Simple Queries
     352             :   /// @{
     353             : 
     354       88394 :   fltCategory getCategory() const { return category; }
     355             :   const fltSemantics &getSemantics() const { return *semantics; }
     356          44 :   bool isNonZero() const { return category != fcZero; }
     357     2319779 :   bool isFiniteNonZero() const { return isFinite() && !isZero(); }
     358             :   bool isPosZero() const { return isZero() && !isNegative(); }
     359             :   bool isNegZero() const { return isZero() && isNegative(); }
     360             : 
     361             :   /// Returns true if and only if the number has the smallest possible non-zero
     362             :   /// magnitude in the current semantics.
     363             :   bool isSmallest() const;
     364             : 
     365             :   /// Returns true if and only if the number has the largest possible finite
     366             :   /// magnitude in the current semantics.
     367             :   bool isLargest() const;
     368             : 
     369             :   /// Returns true if and only if the number is an exact integer.
     370             :   bool isInteger() const;
     371             : 
     372             :   /// @}
     373             : 
     374             :   IEEEFloat &operator=(const IEEEFloat &);
     375             :   IEEEFloat &operator=(IEEEFloat &&);
     376             : 
     377             :   /// Overload to compute a hash code for an APFloat value.
     378             :   ///
     379             :   /// Note that the use of hash codes for floating point values is in general
     380             :   /// frought with peril. Equality is hard to define for these values. For
     381             :   /// example, should negative and positive zero hash to different codes? Are
     382             :   /// they equal or not? This hash value implementation specifically
     383             :   /// emphasizes producing different codes for different inputs in order to
     384             :   /// be used in canonicalization and memoization. As such, equality is
     385             :   /// bitwiseIsEqual, and 0 != -0.
     386             :   friend hash_code hash_value(const IEEEFloat &Arg);
     387             : 
     388             :   /// Converts this value into a decimal string.
     389             :   ///
     390             :   /// \param FormatPrecision The maximum number of digits of
     391             :   ///   precision to output.  If there are fewer digits available,
     392             :   ///   zero padding will not be used unless the value is
     393             :   ///   integral and small enough to be expressed in
     394             :   ///   FormatPrecision digits.  0 means to use the natural
     395             :   ///   precision of the number.
     396             :   /// \param FormatMaxPadding The maximum number of zeros to
     397             :   ///   consider inserting before falling back to scientific
     398             :   ///   notation.  0 means to always use scientific notation.
     399             :   ///
     400             :   /// \param TruncateZero Indicate whether to remove the trailing zero in
     401             :   ///   fraction part or not. Also setting this parameter to false forcing
     402             :   ///   producing of output more similar to default printf behavior.
     403             :   ///   Specifically the lower e is used as exponent delimiter and exponent
     404             :   ///   always contains no less than two digits.
     405             :   ///
     406             :   /// Number       Precision    MaxPadding      Result
     407             :   /// ------       ---------    ----------      ------
     408             :   /// 1.01E+4              5             2       10100
     409             :   /// 1.01E+4              4             2       1.01E+4
     410             :   /// 1.01E+4              5             1       1.01E+4
     411             :   /// 1.01E-2              5             2       0.0101
     412             :   /// 1.01E-2              4             2       0.0101
     413             :   /// 1.01E-2              4             1       1.01E-2
     414             :   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
     415             :                 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const;
     416             : 
     417             :   /// If this value has an exact multiplicative inverse, store it in inv and
     418             :   /// return true.
     419             :   bool getExactInverse(APFloat *inv) const;
     420             : 
     421             :   /// Returns the exponent of the internal representation of the APFloat.
     422             :   ///
     423             :   /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
     424             :   /// For special APFloat values, this returns special error codes:
     425             :   ///
     426             :   ///   NaN -> \c IEK_NaN
     427             :   ///   0   -> \c IEK_Zero
     428             :   ///   Inf -> \c IEK_Inf
     429             :   ///
     430             :   friend int ilogb(const IEEEFloat &Arg);
     431             : 
     432             :   /// Returns: X * 2^Exp for integral exponents.
     433             :   friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);
     434             : 
     435             :   friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode);
     436             : 
     437             :   /// \name Special value setters.
     438             :   /// @{
     439             : 
     440             :   void makeLargest(bool Neg = false);
     441             :   void makeSmallest(bool Neg = false);
     442             :   void makeNaN(bool SNaN = false, bool Neg = false,
     443             :                const APInt *fill = nullptr);
     444             :   void makeInf(bool Neg = false);
     445             :   void makeZero(bool Neg = false);
     446             :   void makeQuiet();
     447             : 
     448             :   /// Returns the smallest (by magnitude) normalized finite number in the given
     449             :   /// semantics.
     450             :   ///
     451             :   /// \param Negative - True iff the number should be negative
     452             :   void makeSmallestNormalized(bool Negative = false);
     453             : 
     454             :   /// @}
     455             : 
     456             :   cmpResult compareAbsoluteValue(const IEEEFloat &) const;
     457             : 
     458             : private:
     459             :   /// \name Simple Queries
     460             :   /// @{
     461             : 
     462             :   integerPart *significandParts();
     463             :   const integerPart *significandParts() const;
     464             :   unsigned int partCount() const;
     465             : 
     466             :   /// @}
     467             : 
     468             :   /// \name Significand operations.
     469             :   /// @{
     470             : 
     471             :   integerPart addSignificand(const IEEEFloat &);
     472             :   integerPart subtractSignificand(const IEEEFloat &, integerPart);
     473             :   lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract);
     474             :   lostFraction multiplySignificand(const IEEEFloat &, const IEEEFloat *);
     475             :   lostFraction divideSignificand(const IEEEFloat &);
     476             :   void incrementSignificand();
     477             :   void initialize(const fltSemantics *);
     478             :   void shiftSignificandLeft(unsigned int);
     479             :   lostFraction shiftSignificandRight(unsigned int);
     480             :   unsigned int significandLSB() const;
     481             :   unsigned int significandMSB() const;
     482             :   void zeroSignificand();
     483             :   /// Return true if the significand excluding the integral bit is all ones.
     484             :   bool isSignificandAllOnes() const;
     485             :   /// Return true if the significand excluding the integral bit is all zeros.
     486             :   bool isSignificandAllZeros() const;
     487             : 
     488             :   /// @}
     489             : 
     490             :   /// \name Arithmetic on special values.
     491             :   /// @{
     492             : 
     493             :   opStatus addOrSubtractSpecials(const IEEEFloat &, bool subtract);
     494             :   opStatus divideSpecials(const IEEEFloat &);
     495             :   opStatus multiplySpecials(const IEEEFloat &);
     496             :   opStatus modSpecials(const IEEEFloat &);
     497             : 
     498             :   /// @}
     499             : 
     500             :   /// \name Miscellany
     501             :   /// @{
     502             : 
     503             :   bool convertFromStringSpecials(StringRef str);
     504             :   opStatus normalize(roundingMode, lostFraction);
     505             :   opStatus addOrSubtract(const IEEEFloat &, roundingMode, bool subtract);
     506             :   opStatus handleOverflow(roundingMode);
     507             :   bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const;
     508             :   opStatus convertToSignExtendedInteger(MutableArrayRef<integerPart>,
     509             :                                         unsigned int, bool, roundingMode,
     510             :                                         bool *) const;
     511             :   opStatus convertFromUnsignedParts(const integerPart *, unsigned int,
     512             :                                     roundingMode);
     513             :   opStatus convertFromHexadecimalString(StringRef, roundingMode);
     514             :   opStatus convertFromDecimalString(StringRef, roundingMode);
     515             :   char *convertNormalToHexString(char *, unsigned int, bool,
     516             :                                  roundingMode) const;
     517             :   opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int,
     518             :                                         roundingMode);
     519             : 
     520             :   /// @}
     521             : 
     522             :   APInt convertHalfAPFloatToAPInt() const;
     523             :   APInt convertFloatAPFloatToAPInt() const;
     524             :   APInt convertDoubleAPFloatToAPInt() const;
     525             :   APInt convertQuadrupleAPFloatToAPInt() const;
     526             :   APInt convertF80LongDoubleAPFloatToAPInt() const;
     527             :   APInt convertPPCDoubleDoubleAPFloatToAPInt() const;
     528             :   void initFromAPInt(const fltSemantics *Sem, const APInt &api);
     529             :   void initFromHalfAPInt(const APInt &api);
     530             :   void initFromFloatAPInt(const APInt &api);
     531             :   void initFromDoubleAPInt(const APInt &api);
     532             :   void initFromQuadrupleAPInt(const APInt &api);
     533             :   void initFromF80LongDoubleAPInt(const APInt &api);
     534             :   void initFromPPCDoubleDoubleAPInt(const APInt &api);
     535             : 
     536             :   void assign(const IEEEFloat &);
     537             :   void copySignificand(const IEEEFloat &);
     538             :   void freeSignificand();
     539             : 
     540             :   /// Note: this must be the first data member.
     541             :   /// The semantics that this value obeys.
     542             :   const fltSemantics *semantics;
     543             : 
     544             :   /// A binary fraction with an explicit integer bit.
     545             :   ///
     546             :   /// The significand must be at least one bit wider than the target precision.
     547             :   union Significand {
     548             :     integerPart part;
     549             :     integerPart *parts;
     550             :   } significand;
     551             : 
     552             :   /// The signed unbiased exponent of the value.
     553             :   ExponentType exponent;
     554             : 
     555             :   /// What kind of floating point number this is.
     556             :   ///
     557             :   /// Only 2 bits are required, but VisualStudio incorrectly sign extends it.
     558             :   /// Using the extra bit keeps it from failing under VisualStudio.
     559             :   fltCategory category : 3;
     560             : 
     561             :   /// Sign bit of the number.
     562             :   unsigned int sign : 1;
     563             : };
     564             : 
     565             : hash_code hash_value(const IEEEFloat &Arg);
     566             : int ilogb(const IEEEFloat &Arg);
     567             : IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
     568             : IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
     569             : 
     570             : // This mode implements more precise float in terms of two APFloats.
     571             : // The interface and layout is designed for arbitray underlying semantics,
     572             : // though currently only PPCDoubleDouble semantics are supported, whose
     573             : // corresponding underlying semantics are IEEEdouble.
     574        1648 : class DoubleAPFloat final : public APFloatBase {
     575             :   // Note: this must be the first data member.
     576             :   const fltSemantics *Semantics;
     577             :   std::unique_ptr<APFloat[]> Floats;
     578             : 
     579             :   opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c,
     580             :                    const APFloat &cc, roundingMode RM);
     581             : 
     582             :   opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS,
     583             :                           DoubleAPFloat &Out, roundingMode RM);
     584             : 
     585             : public:
     586             :   DoubleAPFloat(const fltSemantics &S);
     587             :   DoubleAPFloat(const fltSemantics &S, uninitializedTag);
     588             :   DoubleAPFloat(const fltSemantics &S, integerPart);
     589             :   DoubleAPFloat(const fltSemantics &S, const APInt &I);
     590             :   DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second);
     591             :   DoubleAPFloat(const DoubleAPFloat &RHS);
     592             :   DoubleAPFloat(DoubleAPFloat &&RHS);
     593             : 
     594             :   DoubleAPFloat &operator=(const DoubleAPFloat &RHS);
     595             : 
     596          89 :   DoubleAPFloat &operator=(DoubleAPFloat &&RHS) {
     597          89 :     if (this != &RHS) {
     598          89 :       this->~DoubleAPFloat();
     599          89 :       new (this) DoubleAPFloat(std::move(RHS));
     600             :     }
     601          89 :     return *this;
     602             :   }
     603             : 
     604           6 :   bool needsCleanup() const { return Floats != nullptr; }
     605             : 
     606           8 :   APFloat &getFirst() { return Floats[0]; }
     607      108512 :   const APFloat &getFirst() const { return Floats[0]; }
     608             :   APFloat &getSecond() { return Floats[1]; }
     609             :   const APFloat &getSecond() const { return Floats[1]; }
     610             : 
     611             :   opStatus add(const DoubleAPFloat &RHS, roundingMode RM);
     612             :   opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM);
     613             :   opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM);
     614             :   opStatus divide(const DoubleAPFloat &RHS, roundingMode RM);
     615             :   opStatus remainder(const DoubleAPFloat &RHS);
     616             :   opStatus mod(const DoubleAPFloat &RHS);
     617             :   opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
     618             :                             const DoubleAPFloat &Addend, roundingMode RM);
     619             :   opStatus roundToIntegral(roundingMode RM);
     620             :   void changeSign();
     621             :   cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const;
     622             : 
     623             :   fltCategory getCategory() const;
     624             :   bool isNegative() const;
     625             : 
     626             :   void makeInf(bool Neg);
     627             :   void makeZero(bool Neg);
     628             :   void makeLargest(bool Neg);
     629             :   void makeSmallest(bool Neg);
     630             :   void makeSmallestNormalized(bool Neg);
     631             :   void makeNaN(bool SNaN, bool Neg, const APInt *fill);
     632             : 
     633             :   cmpResult compare(const DoubleAPFloat &RHS) const;
     634             :   bool bitwiseIsEqual(const DoubleAPFloat &RHS) const;
     635             :   APInt bitcastToAPInt() const;
     636             :   opStatus convertFromString(StringRef, roundingMode);
     637             :   opStatus next(bool nextDown);
     638             : 
     639             :   opStatus convertToInteger(MutableArrayRef<integerPart> Input,
     640             :                             unsigned int Width, bool IsSigned, roundingMode RM,
     641             :                             bool *IsExact) const;
     642             :   opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM);
     643             :   opStatus convertFromSignExtendedInteger(const integerPart *Input,
     644             :                                           unsigned int InputSize, bool IsSigned,
     645             :                                           roundingMode RM);
     646             :   opStatus convertFromZeroExtendedInteger(const integerPart *Input,
     647             :                                           unsigned int InputSize, bool IsSigned,
     648             :                                           roundingMode RM);
     649             :   unsigned int convertToHexString(char *DST, unsigned int HexDigits,
     650             :                                   bool UpperCase, roundingMode RM) const;
     651             : 
     652             :   bool isDenormal() const;
     653             :   bool isSmallest() const;
     654             :   bool isLargest() const;
     655             :   bool isInteger() const;
     656             : 
     657             :   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
     658             :                 unsigned FormatMaxPadding, bool TruncateZero = true) const;
     659             : 
     660             :   bool getExactInverse(APFloat *inv) const;
     661             : 
     662             :   friend int ilogb(const DoubleAPFloat &Arg);
     663             :   friend DoubleAPFloat scalbn(DoubleAPFloat X, int Exp, roundingMode);
     664             :   friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode);
     665             :   friend hash_code hash_value(const DoubleAPFloat &Arg);
     666             : };
     667             : 
     668             : hash_code hash_value(const DoubleAPFloat &Arg);
     669             : 
     670             : } // End detail namespace
     671             : 
     672             : // This is a interface class that is currently forwarding functionalities from
     673             : // detail::IEEEFloat.
     674      153916 : class APFloat : public APFloatBase {
     675             :   typedef detail::IEEEFloat IEEEFloat;
     676             :   typedef detail::DoubleAPFloat DoubleAPFloat;
     677             : 
     678             :   static_assert(std::is_standard_layout<IEEEFloat>::value, "");
     679             : 
     680             :   union Storage {
     681             :     const fltSemantics *semantics;
     682             :     IEEEFloat IEEE;
     683             :     DoubleAPFloat Double;
     684             : 
     685             :     explicit Storage(IEEEFloat F, const fltSemantics &S);
     686             :     explicit Storage(DoubleAPFloat F, const fltSemantics &S)
     687           4 :         : Double(std::move(F)) {
     688             :       assert(&S == &PPCDoubleDouble());
     689             :     }
     690             : 
     691             :     template <typename... ArgTypes>
     692      392143 :     Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
     693      392143 :       if (usesLayout<IEEEFloat>(Semantics)) {
     694      391780 :         new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
     695             :         return;
     696             :       }
     697         363 :       if (usesLayout<DoubleAPFloat>(Semantics)) {
     698         363 :         new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
     699             :         return;
     700             :       }
     701             :       llvm_unreachable("Unexpected semantics");
     702             :     }
     703             : 
     704     7831962 :     ~Storage() {
     705     7831962 :       if (usesLayout<IEEEFloat>(*semantics)) {
     706     3915312 :         IEEE.~IEEEFloat();
     707     3915312 :         return;
     708             :       }
     709         669 :       if (usesLayout<DoubleAPFloat>(*semantics)) {
     710         669 :         Double.~DoubleAPFloat();
     711             :         return;
     712             :       }
     713             :       llvm_unreachable("Unexpected semantics");
     714     3915981 :     }
     715             : 
     716      545605 :     Storage(const Storage &RHS) {
     717     1091210 :       if (usesLayout<IEEEFloat>(*RHS.semantics)) {
     718      545250 :         new (this) IEEEFloat(RHS.IEEE);
     719             :         return;
     720             :       }
     721         355 :       if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
     722         355 :         new (this) DoubleAPFloat(RHS.Double);
     723             :         return;
     724             :       }
     725             :       llvm_unreachable("Unexpected semantics");
     726             :     }
     727             : 
     728       11435 :     Storage(Storage &&RHS) {
     729       22870 :       if (usesLayout<IEEEFloat>(*RHS.semantics)) {
     730       11350 :         new (this) IEEEFloat(std::move(RHS.IEEE));
     731             :         return;
     732             :       }
     733          85 :       if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
     734          85 :         new (this) DoubleAPFloat(std::move(RHS.Double));
     735             :         return;
     736             :       }
     737             :       llvm_unreachable("Unexpected semantics");
     738             :     }
     739             : 
     740       77292 :     Storage &operator=(const Storage &RHS) {
     741      231802 :       if (usesLayout<IEEEFloat>(*semantics) &&
     742       77218 :           usesLayout<IEEEFloat>(*RHS.semantics)) {
     743       77071 :         IEEE = RHS.IEEE;
     744         295 :       } else if (usesLayout<DoubleAPFloat>(*semantics) &&
     745          74 :                  usesLayout<DoubleAPFloat>(*RHS.semantics)) {
     746           0 :         Double = RHS.Double;
     747         221 :       } else if (this != &RHS) {
     748         221 :         this->~Storage();
     749         221 :         new (this) Storage(RHS);
     750             :       }
     751       77292 :       return *this;
     752             :     }
     753             : 
     754       76624 :     Storage &operator=(Storage &&RHS) {
     755      229824 :       if (usesLayout<IEEEFloat>(*semantics) &&
     756       76576 :           usesLayout<IEEEFloat>(*RHS.semantics)) {
     757       76499 :         IEEE = std::move(RHS.IEEE);
     758         173 :       } else if (usesLayout<DoubleAPFloat>(*semantics) &&
     759          48 :                  usesLayout<DoubleAPFloat>(*RHS.semantics)) {
     760          38 :         Double = std::move(RHS.Double);
     761          87 :       } else if (this != &RHS) {
     762          87 :         this->~Storage();
     763          87 :         new (this) Storage(std::move(RHS));
     764             :       }
     765       76624 :       return *this;
     766             :     }
     767             :   } U;
     768             : 
     769             :   template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
     770             :     static_assert(std::is_same<T, IEEEFloat>::value ||
     771             :                   std::is_same<T, DoubleAPFloat>::value, "");
     772             :     if (std::is_same<T, DoubleAPFloat>::value) {
     773             :       return &Semantics == &PPCDoubleDouble();
     774             :     }
     775     9329644 :     return &Semantics != &PPCDoubleDouble();
     776             :   }
     777             : 
     778             :   IEEEFloat &getIEEE() {
     779           4 :     if (usesLayout<IEEEFloat>(*U.semantics))
     780           0 :       return U.IEEE;
     781           4 :     if (usesLayout<DoubleAPFloat>(*U.semantics))
     782           8 :       return U.Double.getFirst().U.IEEE;
     783             :     llvm_unreachable("Unexpected semantics");
     784             :   }
     785             : 
     786             :   const IEEEFloat &getIEEE() const {
     787      287064 :     if (usesLayout<IEEEFloat>(*U.semantics))
     788      115071 :       return U.IEEE;
     789       54256 :     if (usesLayout<DoubleAPFloat>(*U.semantics))
     790      108512 :       return U.Double.getFirst().U.IEEE;
     791             :     llvm_unreachable("Unexpected semantics");
     792             :   }
     793             : 
     794       28562 :   void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); }
     795             : 
     796        1036 :   void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); }
     797             : 
     798         657 :   void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
     799        1314 :     APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill));
     800             :   }
     801             : 
     802         163 :   void makeLargest(bool Neg) {
     803         326 :     APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg));
     804             :   }
     805             : 
     806          42 :   void makeSmallest(bool Neg) {
     807          84 :     APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
     808             :   }
     809             : 
     810         116 :   void makeSmallestNormalized(bool Neg) {
     811         232 :     APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg));
     812             :   }
     813             : 
     814             :   // FIXME: This is due to clang 3.3 (or older version) always checks for the
     815             :   // default constructor in an array aggregate initialization, even if no
     816             :   // elements in the array is default initialized.
     817             :   APFloat() : U(IEEEdouble()) {
     818             :     llvm_unreachable("This is a workaround for old clang.");
     819             :   }
     820             : 
     821         228 :   explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {}
     822           4 :   explicit APFloat(DoubleAPFloat F, const fltSemantics &S)
     823          12 :       : U(std::move(F), S) {}
     824             : 
     825           6 :   cmpResult compareAbsoluteValue(const APFloat &RHS) const {
     826             :     assert(&getSemantics() == &RHS.getSemantics() &&
     827             :            "Should only compare APFloats with the same semantics");
     828          12 :     if (usesLayout<IEEEFloat>(getSemantics()))
     829           6 :       return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
     830           0 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     831           0 :       return U.Double.compareAbsoluteValue(RHS.U.Double);
     832             :     llvm_unreachable("Unexpected semantics");
     833             :   }
     834             : 
     835             : public:
     836       74034 :   APFloat(const fltSemantics &Semantics) : U(Semantics) {}
     837             :   APFloat(const fltSemantics &Semantics, StringRef S);
     838      230402 :   APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
     839             :   // TODO: Remove this constructor. This isn't faster than the first one.
     840          56 :   APFloat(const fltSemantics &Semantics, uninitializedTag)
     841       15790 :       : U(Semantics, uninitialized) {}
     842       71917 :   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
     843     2957998 :   explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
     844       17596 :   explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
     845      545384 :   APFloat(const APFloat &RHS) = default;
     846       11348 :   APFloat(APFloat &&RHS) = default;
     847             : 
     848     3915622 :   ~APFloat() = default;
     849             : 
     850         795 :   bool needsCleanup() const { APFLOAT_DISPATCH_ON_SEMANTICS(needsCleanup()); }
     851             : 
     852             :   /// Factory for Positive and Negative Zero.
     853             :   ///
     854             :   /// \param Negative True iff the number should be negative.
     855             :   static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
     856       14227 :     APFloat Val(Sem, uninitialized);
     857       14227 :     Val.makeZero(Negative);
     858             :     return Val;
     859             :   }
     860             : 
     861             :   /// Factory for Positive and Negative Infinity.
     862             :   ///
     863             :   /// \param Negative True iff the number should be negative.
     864             :   static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
     865         518 :     APFloat Val(Sem, uninitialized);
     866         518 :     Val.makeInf(Negative);
     867             :     return Val;
     868             :   }
     869             : 
     870             :   /// Factory for NaN values.
     871             :   ///
     872             :   /// \param Negative - True iff the NaN generated should be negative.
     873             :   /// \param type - The unspecified fill bits for creating the NaN, 0 by
     874             :   /// default.  The value is truncated as necessary.
     875          27 :   static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
     876             :                         unsigned type = 0) {
     877          27 :     if (type) {
     878           6 :       APInt fill(64, type);
     879           4 :       return getQNaN(Sem, Negative, &fill);
     880             :     } else {
     881          25 :       return getQNaN(Sem, Negative, nullptr);
     882             :     }
     883             :   }
     884             : 
     885             :   /// Factory for QNaN values.
     886             :   static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
     887             :                          const APInt *payload = nullptr) {
     888         378 :     APFloat Val(Sem, uninitialized);
     889         378 :     Val.makeNaN(false, Negative, payload);
     890             :     return Val;
     891             :   }
     892             : 
     893             :   /// Factory for SNaN values.
     894             :   static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
     895             :                          const APInt *payload = nullptr) {
     896         277 :     APFloat Val(Sem, uninitialized);
     897         277 :     Val.makeNaN(true, Negative, payload);
     898             :     return Val;
     899             :   }
     900             : 
     901             :   /// Returns the largest finite number in the given semantics.
     902             :   ///
     903             :   /// \param Negative - True iff the number should be negative
     904             :   static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) {
     905         163 :     APFloat Val(Sem, uninitialized);
     906         163 :     Val.makeLargest(Negative);
     907             :     return Val;
     908             :   }
     909             : 
     910             :   /// Returns the smallest (by magnitude) finite number in the given semantics.
     911             :   /// Might be denormalized, which implies a relative loss of precision.
     912             :   ///
     913             :   /// \param Negative - True iff the number should be negative
     914             :   static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) {
     915          37 :     APFloat Val(Sem, uninitialized);
     916          37 :     Val.makeSmallest(Negative);
     917             :     return Val;
     918             :   }
     919             : 
     920             :   /// Returns the smallest (by magnitude) normalized finite number in the given
     921             :   /// semantics.
     922             :   ///
     923             :   /// \param Negative - True iff the number should be negative
     924             :   static APFloat getSmallestNormalized(const fltSemantics &Sem,
     925             :                                        bool Negative = false) {
     926         116 :     APFloat Val(Sem, uninitialized);
     927         116 :     Val.makeSmallestNormalized(Negative);
     928             :     return Val;
     929             :   }
     930             : 
     931             :   /// Returns a float which is bitcasted from an all one value int.
     932             :   ///
     933             :   /// \param BitWidth - Select float type
     934             :   /// \param isIEEE   - If 128 bit number, select between PPC and IEEE
     935             :   static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false);
     936             : 
     937             :   /// Used to insert APFloat objects, or objects that contain APFloat objects,
     938             :   /// into FoldingSets.
     939             :   void Profile(FoldingSetNodeID &NID) const;
     940             : 
     941        1798 :   opStatus add(const APFloat &RHS, roundingMode RM) {
     942             :     assert(&getSemantics() == &RHS.getSemantics() &&
     943             :            "Should only call on two APFloats with the same semantics");
     944        3596 :     if (usesLayout<IEEEFloat>(getSemantics()))
     945        1775 :       return U.IEEE.add(RHS.U.IEEE, RM);
     946          23 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     947          23 :       return U.Double.add(RHS.U.Double, RM);
     948             :     llvm_unreachable("Unexpected semantics");
     949             :   }
     950         730 :   opStatus subtract(const APFloat &RHS, roundingMode RM) {
     951             :     assert(&getSemantics() == &RHS.getSemantics() &&
     952             :            "Should only call on two APFloats with the same semantics");
     953        1460 :     if (usesLayout<IEEEFloat>(getSemantics()))
     954         722 :       return U.IEEE.subtract(RHS.U.IEEE, RM);
     955           8 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     956           8 :       return U.Double.subtract(RHS.U.Double, RM);
     957             :     llvm_unreachable("Unexpected semantics");
     958             :   }
     959        1565 :   opStatus multiply(const APFloat &RHS, roundingMode RM) {
     960             :     assert(&getSemantics() == &RHS.getSemantics() &&
     961             :            "Should only call on two APFloats with the same semantics");
     962        3130 :     if (usesLayout<IEEEFloat>(getSemantics()))
     963        1525 :       return U.IEEE.multiply(RHS.U.IEEE, RM);
     964          40 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     965          40 :       return U.Double.multiply(RHS.U.Double, RM);
     966             :     llvm_unreachable("Unexpected semantics");
     967             :   }
     968        1164 :   opStatus divide(const APFloat &RHS, roundingMode RM) {
     969             :     assert(&getSemantics() == &RHS.getSemantics() &&
     970             :            "Should only call on two APFloats with the same semantics");
     971        2328 :     if (usesLayout<IEEEFloat>(getSemantics()))
     972        1162 :       return U.IEEE.divide(RHS.U.IEEE, RM);
     973           2 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     974           2 :       return U.Double.divide(RHS.U.Double, RM);
     975             :     llvm_unreachable("Unexpected semantics");
     976             :   }
     977           4 :   opStatus remainder(const APFloat &RHS) {
     978             :     assert(&getSemantics() == &RHS.getSemantics() &&
     979             :            "Should only call on two APFloats with the same semantics");
     980           8 :     if (usesLayout<IEEEFloat>(getSemantics()))
     981           2 :       return U.IEEE.remainder(RHS.U.IEEE);
     982           2 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     983           2 :       return U.Double.remainder(RHS.U.Double);
     984             :     llvm_unreachable("Unexpected semantics");
     985             :   }
     986          99 :   opStatus mod(const APFloat &RHS) {
     987             :     assert(&getSemantics() == &RHS.getSemantics() &&
     988             :            "Should only call on two APFloats with the same semantics");
     989         198 :     if (usesLayout<IEEEFloat>(getSemantics()))
     990          97 :       return U.IEEE.mod(RHS.U.IEEE);
     991           2 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
     992           2 :       return U.Double.mod(RHS.U.Double);
     993             :     llvm_unreachable("Unexpected semantics");
     994             :   }
     995          58 :   opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
     996             :                             roundingMode RM) {
     997             :     assert(&getSemantics() == &Multiplicand.getSemantics() &&
     998             :            "Should only call on APFloats with the same semantics");
     999             :     assert(&getSemantics() == &Addend.getSemantics() &&
    1000             :            "Should only call on APFloats with the same semantics");
    1001         116 :     if (usesLayout<IEEEFloat>(getSemantics()))
    1002          57 :       return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM);
    1003           1 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
    1004           1 :       return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double,
    1005           1 :                                        RM);
    1006             :     llvm_unreachable("Unexpected semantics");
    1007             :   }
    1008         215 :   opStatus roundToIntegral(roundingMode RM) {
    1009         430 :     APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM));
    1010             :   }
    1011             : 
    1012             :   // TODO: bool parameters are not readable and a source of bugs.
    1013             :   // Do something.
    1014          44 :   opStatus next(bool nextDown) {
    1015          88 :     APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown));
    1016             :   }
    1017             : 
    1018             :   /// Add two APFloats, rounding ties to the nearest even.
    1019             :   /// No error checking.
    1020             :   APFloat operator+(const APFloat &RHS) const {
    1021         107 :     APFloat Result(*this);
    1022         107 :     (void)Result.add(RHS, rmNearestTiesToEven);
    1023             :     return Result;
    1024             :   }
    1025             : 
    1026             :   /// Subtract two APFloats, rounding ties to the nearest even.
    1027             :   /// No error checking.
    1028             :   APFloat operator-(const APFloat &RHS) const {
    1029          79 :     APFloat Result(*this);
    1030          79 :     (void)Result.subtract(RHS, rmNearestTiesToEven);
    1031             :     return Result;
    1032             :   }
    1033             : 
    1034             :   /// Multiply two APFloats, rounding ties to the nearest even.
    1035             :   /// No error checking.
    1036             :   APFloat operator*(const APFloat &RHS) const {
    1037         548 :     APFloat Result(*this);
    1038         548 :     (void)Result.multiply(RHS, rmNearestTiesToEven);
    1039             :     return Result;
    1040             :   }
    1041             : 
    1042             :   /// Divide the first APFloat by the second, rounding ties to the nearest even.
    1043             :   /// No error checking.
    1044             :   APFloat operator/(const APFloat &RHS) const {
    1045         105 :     APFloat Result(*this);
    1046         105 :     (void)Result.divide(RHS, rmNearestTiesToEven);
    1047             :     return Result;
    1048             :   }
    1049             : 
    1050       42464 :   void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); }
    1051         100 :   void clearSign() {
    1052         100 :     if (isNegative())
    1053          18 :       changeSign();
    1054         100 :   }
    1055          76 :   void copySign(const APFloat &RHS) {
    1056         152 :     if (isNegative() != RHS.isNegative())
    1057          15 :       changeSign();
    1058          76 :   }
    1059             : 
    1060             :   /// A static helper to produce a copy of an APFloat value with its sign
    1061             :   /// copied from some other APFloat.
    1062             :   static APFloat copySign(APFloat Value, const APFloat &Sign) {
    1063          62 :     Value.copySign(Sign);
    1064          62 :     return Value;
    1065             :   }
    1066             : 
    1067             :   opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
    1068             :                    bool *losesInfo);
    1069        2766 :   opStatus convertToInteger(MutableArrayRef<integerPart> Input,
    1070             :                             unsigned int Width, bool IsSigned, roundingMode RM,
    1071             :                             bool *IsExact) const {
    1072        5532 :     APFLOAT_DISPATCH_ON_SEMANTICS(
    1073             :         convertToInteger(Input, Width, IsSigned, RM, IsExact));
    1074             :   }
    1075             :   opStatus convertToInteger(APSInt &Result, roundingMode RM,
    1076             :                             bool *IsExact) const;
    1077        6698 :   opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
    1078             :                             roundingMode RM) {
    1079       13396 :     APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM));
    1080             :   }
    1081           0 :   opStatus convertFromSignExtendedInteger(const integerPart *Input,
    1082             :                                           unsigned int InputSize, bool IsSigned,
    1083             :                                           roundingMode RM) {
    1084           0 :     APFLOAT_DISPATCH_ON_SEMANTICS(
    1085             :         convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM));
    1086             :   }
    1087           0 :   opStatus convertFromZeroExtendedInteger(const integerPart *Input,
    1088             :                                           unsigned int InputSize, bool IsSigned,
    1089             :                                           roundingMode RM) {
    1090           0 :     APFLOAT_DISPATCH_ON_SEMANTICS(
    1091             :         convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
    1092             :   }
    1093             :   opStatus convertFromString(StringRef, roundingMode);
    1094      128941 :   APInt bitcastToAPInt() const {
    1095      257882 :     APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt());
    1096             :   }
    1097       33458 :   double convertToDouble() const { return getIEEE().convertToDouble(); }
    1098       15930 :   float convertToFloat() const { return getIEEE().convertToFloat(); }
    1099             : 
    1100             :   bool operator==(const APFloat &) const = delete;
    1101             : 
    1102        1605 :   cmpResult compare(const APFloat &RHS) const {
    1103             :     assert(&getSemantics() == &RHS.getSemantics() &&
    1104             :            "Should only compare APFloats with the same semantics");
    1105        3210 :     if (usesLayout<IEEEFloat>(getSemantics()))
    1106        1593 :       return U.IEEE.compare(RHS.U.IEEE);
    1107          12 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
    1108          12 :       return U.Double.compare(RHS.U.Double);
    1109             :     llvm_unreachable("Unexpected semantics");
    1110             :   }
    1111             : 
    1112      839952 :   bool bitwiseIsEqual(const APFloat &RHS) const {
    1113      839952 :     if (&getSemantics() != &RHS.getSemantics())
    1114             :       return false;
    1115     1499898 :     if (usesLayout<IEEEFloat>(getSemantics()))
    1116      749874 :       return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
    1117          75 :     if (usesLayout<DoubleAPFloat>(getSemantics()))
    1118          75 :       return U.Double.bitwiseIsEqual(RHS.U.Double);
    1119             :     llvm_unreachable("Unexpected semantics");
    1120             :   }
    1121             : 
    1122           0 :   unsigned int convertToHexString(char *DST, unsigned int HexDigits,
    1123             :                                   bool UpperCase, roundingMode RM) const {
    1124           0 :     APFLOAT_DISPATCH_ON_SEMANTICS(
    1125             :         convertToHexString(DST, HexDigits, UpperCase, RM));
    1126             :   }
    1127             : 
    1128       66429 :   bool isZero() const { return getCategory() == fcZero; }
    1129       18363 :   bool isInfinity() const { return getCategory() == fcInfinity; }
    1130       24045 :   bool isNaN() const { return getCategory() == fcNaN; }
    1131             : 
    1132       66836 :   bool isNegative() const { return getIEEE().isNegative(); }
    1133         538 :   bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); }
    1134        5688 :   bool isSignaling() const { return getIEEE().isSignaling(); }
    1135             : 
    1136          86 :   bool isNormal() const { return !isDenormal() && isFiniteNonZero(); }
    1137        1729 :   bool isFinite() const { return !isNaN() && !isInfinity(); }
    1138             : 
    1139      198401 :   fltCategory getCategory() const { return getIEEE().getCategory(); }
    1140             :   const fltSemantics &getSemantics() const { return *U.semantics; }
    1141             :   bool isNonZero() const { return !isZero(); }
    1142        1902 :   bool isFiniteNonZero() const { return isFinite() && !isZero(); }
    1143        2055 :   bool isPosZero() const { return isZero() && !isNegative(); }
    1144       10421 :   bool isNegZero() const { return isZero() && isNegative(); }
    1145           2 :   bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); }
    1146           2 :   bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); }
    1147          38 :   bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); }
    1148             : 
    1149             :   APFloat &operator=(const APFloat &RHS) = default;
    1150             :   APFloat &operator=(APFloat &&RHS) = default;
    1151             : 
    1152       23187 :   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
    1153             :                 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const {
    1154       46374 :     APFLOAT_DISPATCH_ON_SEMANTICS(
    1155             :         toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero));
    1156             :   }
    1157             : 
    1158             :   void print(raw_ostream &) const;
    1159             :   void dump() const;
    1160             : 
    1161          38 :   bool getExactInverse(APFloat *inv) const {
    1162          76 :     APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
    1163             :   }
    1164             : 
    1165             :   friend hash_code hash_value(const APFloat &Arg);
    1166         186 :   friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
    1167             :   friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
    1168             :   friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
    1169             :   friend IEEEFloat;
    1170             :   friend DoubleAPFloat;
    1171             : };
    1172             : 
    1173             : /// See friend declarations above.
    1174             : ///
    1175             : /// These additional declarations are required in order to compile LLVM with IBM
    1176             : /// xlC compiler.
    1177             : hash_code hash_value(const APFloat &Arg);
    1178         158 : inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
    1179         316 :   if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
    1180         156 :     return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
    1181           2 :   if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
    1182           6 :     return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
    1183             :   llvm_unreachable("Unexpected semantics");
    1184             : }
    1185             : 
    1186             : /// Equivalent of C standard library function.
    1187             : ///
    1188             : /// While the C standard says Exp is an unspecified value for infinity and nan,
    1189             : /// this returns INT_MAX for infinities, and INT_MIN for NaNs.
    1190          61 : inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
    1191         122 :   if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
    1192          59 :     return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics());
    1193           2 :   if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
    1194           4 :     return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics());
    1195             :   llvm_unreachable("Unexpected semantics");
    1196             : }
    1197             : /// Returns the absolute value of the argument.
    1198             : inline APFloat abs(APFloat X) {
    1199          75 :   X.clearSign();
    1200          75 :   return X;
    1201             : }
    1202             : 
    1203             : /// \brief Returns the negated value of the argument.
    1204             : inline APFloat neg(APFloat X) {
    1205         140 :   X.changeSign();
    1206         140 :   return X;
    1207             : }
    1208             : 
    1209             : /// Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if
    1210             : /// both are not NaN. If either argument is a NaN, returns the other argument.
    1211             : LLVM_READONLY
    1212          47 : inline APFloat minnum(const APFloat &A, const APFloat &B) {
    1213          47 :   if (A.isNaN())
    1214             :     return B;
    1215          35 :   if (B.isNaN())
    1216             :     return A;
    1217          29 :   return (B.compare(A) == APFloat::cmpLessThan) ? B : A;
    1218             : }
    1219             : 
    1220             : /// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if
    1221             : /// both are not NaN. If either argument is a NaN, returns the other argument.
    1222             : LLVM_READONLY
    1223          81 : inline APFloat maxnum(const APFloat &A, const APFloat &B) {
    1224          81 :   if (A.isNaN())
    1225             :     return B;
    1226          68 :   if (B.isNaN())
    1227             :     return A;
    1228          63 :   return (A.compare(B) == APFloat::cmpLessThan) ? B : A;
    1229             : }
    1230             : 
    1231             : } // namespace llvm
    1232             : 
    1233             : #undef APFLOAT_DISPATCH_ON_SEMANTICS
    1234             : #endif // LLVM_ADT_APFLOAT_H

Generated by: LCOV version 1.13