Coverage Report

Created: 2018-07-12 09:57

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/APFloat.h
Line
Count
Source (jump to first uncovered line)
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
1.83M
  do {                                                                         \
27
1.83M
    if (usesLayout<IEEEFloat>(getSemantics()))                                 \
28
1.83M
      
return U.IEEE.METHOD_CALL1.83M
; \
29
1.83M
    
if (266
usesLayout<DoubleAPFloat>(getSemantics())266
) \
30
270
      return U.Double.METHOD_CALL;                                             \
31
18.4E
    llvm_unreachable("Unexpected semantics");                                  \
32
266
  } while (
false0
)
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
0
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
23.7M
  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
746k
  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
0
  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
12.3M
  bool isFinite() const { return !isNaN() && 
!isInfinity()12.3M
; }
332
333
  /// Returns true if and only if the float is plus or minus zero.
334
12.2M
  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
12.3M
  bool isInfinity() const { return category == fcInfinity; }
342
343
  /// Returns true if and only if the float is a quiet or signaling NaN.
344
12.5M
  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
4.40M
  fltCategory getCategory() const { return category; }
355
956
  const fltSemantics &getSemantics() const { return *semantics; }
356
119
  bool isNonZero() const { return category != fcZero; }
357
12.3M
  bool isFiniteNonZero() const { return isFinite() && 
!isZero()12.2M
; }
358
0
  bool isPosZero() const { return isZero() && !isNegative(); }
359
0
  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
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
90
  DoubleAPFloat &operator=(DoubleAPFloat &&RHS) {
597
90
    if (this != &RHS) {
598
90
      this->~DoubleAPFloat();
599
90
      new (this) DoubleAPFloat(std::move(RHS));
600
90
    }
601
90
    return *this;
602
90
  }
603
604
3
  bool needsCleanup() const { return Floats != nullptr; }
605
606
4
  APFloat &getFirst() { return Floats[0]; }
607
375
  const APFloat &getFirst() const { return Floats[0]; }
608
0
  APFloat &getSecond() { return Floats[1]; }
609
0
  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
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
4
      assert(&S == &PPCDoubleDouble());
689
4
    }
690
691
    template <typename... ArgTypes>
692
3.98M
    Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
693
3.98M
      if (usesLayout<IEEEFloat>(Semantics)) {
694
3.98M
        new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
695
3.98M
        return;
696
3.98M
      }
697
374
      
if (367
usesLayout<DoubleAPFloat>(Semantics)367
) {
698
374
        new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
699
374
        return;
700
374
      }
701
18.4E
      llvm_unreachable("Unexpected semantics");
702
18.4E
    }
llvm::APFloat::Storage::Storage<llvm::APInt const&>(llvm::fltSemantics const&, llvm::APInt const&&&)
Line
Count
Source
692
1.12M
    Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
693
1.12M
      if (usesLayout<IEEEFloat>(Semantics)) {
694
1.12M
        new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
695
1.12M
        return;
696
1.12M
      }
697
300
      if (usesLayout<DoubleAPFloat>(Semantics)) {
698
300
        new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
699
300
        return;
700
300
      }
701
0
      llvm_unreachable("Unexpected semantics");
702
0
    }
llvm::APFloat::Storage::Storage<>(llvm::fltSemantics const&)
Line
Count
Source
692
322k
    Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
693
322k
      if (usesLayout<IEEEFloat>(Semantics)) {
694
322k
        new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
695
322k
        return;
696
322k
      }
697
46
      if (usesLayout<DoubleAPFloat>(Semantics)) {
698
46
        new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
699
46
        return;
700
46
      }
701
0
      llvm_unreachable("Unexpected semantics");
702
0
    }
llvm::APFloat::Storage::Storage<llvm::APFloatBase::uninitializedTag>(llvm::fltSemantics const&, llvm::APFloatBase::uninitializedTag&&)
Line
Count
Source
692
84.1k
    Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
693
84.1k
      if (usesLayout<IEEEFloat>(Semantics)) {
694
84.0k
        new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
695
84.0k
        return;
696
84.0k
      }
697
28
      
if (21
usesLayout<DoubleAPFloat>(Semantics)21
) {
698
28
        new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
699
28
        return;
700
28
      }
701
18.4E
      llvm_unreachable("Unexpected semantics");
702
18.4E
    }
llvm::APFloat::Storage::Storage<unsigned long long&>(llvm::fltSemantics const&, unsigned long long&&&)
Line
Count
Source
692
2.45M
    Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
693
2.45M
      if (usesLayout<IEEEFloat>(Semantics)) {
694
2.45M
        new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
695
2.45M
        return;
696
2.45M
      }
697
0
      if (usesLayout<DoubleAPFloat>(Semantics)) {
698
0
        new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...);
699
0
        return;
700
0
      }
701
0
      llvm_unreachable("Unexpected semantics");
702
0
    }
703
704
11.0M
    ~Storage() {
705
11.0M
      if (usesLayout<IEEEFloat>(*semantics)) {
706
11.0M
        IEEE.~IEEEFloat();
707
11.0M
        return;
708
11.0M
      }
709
692
      
if (686
usesLayout<DoubleAPFloat>(*semantics)686
) {
710
692
        Double.~DoubleAPFloat();
711
692
        return;
712
692
      }
713
18.4E
      llvm_unreachable("Unexpected semantics");
714
18.4E
    }
715
716
1.88M
    Storage(const Storage &RHS) {
717
1.88M
      if (usesLayout<IEEEFloat>(*RHS.semantics)) {
718
1.88M
        new (this) IEEEFloat(RHS.IEEE);
719
1.88M
        return;
720
1.88M
      }
721
368
      
if (359
usesLayout<DoubleAPFloat>(*RHS.semantics)359
) {
722
368
        new (this) DoubleAPFloat(RHS.Double);
723
368
        return;
724
368
      }
725
18.4E
      llvm_unreachable("Unexpected semantics");
726
18.4E
    }
727
728
242k
    Storage(Storage &&RHS) {
729
242k
      if (usesLayout<IEEEFloat>(*RHS.semantics)) {
730
242k
        new (this) IEEEFloat(std::move(RHS.IEEE));
731
242k
        return;
732
242k
      }
733
102
      if (usesLayout<DoubleAPFloat>(*RHS.semantics)) {
734
102
        new (this) DoubleAPFloat(std::move(RHS.Double));
735
102
        return;
736
102
      }
737
0
      llvm_unreachable("Unexpected semantics");
738
0
    }
739
740
231k
    Storage &operator=(const Storage &RHS) {
741
231k
      if (usesLayout<IEEEFloat>(*semantics) &&
742
231k
          
usesLayout<IEEEFloat>(*RHS.semantics)231k
) {
743
231k
        IEEE = RHS.IEEE;
744
231k
      } else 
if (226
usesLayout<DoubleAPFloat>(*semantics)226
&&
745
226
                 
usesLayout<DoubleAPFloat>(*RHS.semantics)77
) {
746
2
        Double = RHS.Double;
747
224
      } else if (this != &RHS) {
748
224
        this->~Storage();
749
224
        new (this) Storage(RHS);
750
224
      }
751
231k
      return *this;
752
231k
    }
753
754
763k
    Storage &operator=(Storage &&RHS) {
755
763k
      if (usesLayout<IEEEFloat>(*semantics) &&
756
763k
          
usesLayout<IEEEFloat>(*RHS.semantics)763k
) {
757
763k
        IEEE = std::move(RHS.IEEE);
758
763k
      } else 
if (139
usesLayout<DoubleAPFloat>(*semantics)139
&&
759
139
                 
usesLayout<DoubleAPFloat>(*RHS.semantics)49
) {
760
39
        Double = std::move(RHS.Double);
761
100
      } else if (this != &RHS) {
762
100
        this->~Storage();
763
100
        new (this) Storage(std::move(RHS));
764
100
      }
765
763k
      return *this;
766
763k
    }
767
  } U;
768
769
36.9M
  template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
770
36.9M
    static_assert(std::is_same<T, IEEEFloat>::value ||
771
36.9M
                  std::is_same<T, DoubleAPFloat>::value, "");
772
36.9M
    if (std::is_same<T, DoubleAPFloat>::value) {
773
3.03k
      return &Semantics == &PPCDoubleDouble();
774
3.03k
    }
775
36.9M
    return &Semantics != &PPCDoubleDouble();
776
36.9M
  }
bool llvm::APFloat::usesLayout<llvm::detail::DoubleAPFloat>(llvm::fltSemantics const&)
Line
Count
Source
769
3.03k
  template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
770
3.03k
    static_assert(std::is_same<T, IEEEFloat>::value ||
771
3.03k
                  std::is_same<T, DoubleAPFloat>::value, "");
772
3.03k
    if (std::is_same<T, DoubleAPFloat>::value) {
773
3.03k
      return &Semantics == &PPCDoubleDouble();
774
3.03k
    }
775
0
    return &Semantics != &PPCDoubleDouble();
776
0
  }
bool llvm::APFloat::usesLayout<llvm::detail::IEEEFloat>(llvm::fltSemantics const&)
Line
Count
Source
769
36.9M
  template <typename T> static bool usesLayout(const fltSemantics &Semantics) {
770
36.9M
    static_assert(std::is_same<T, IEEEFloat>::value ||
771
36.9M
                  std::is_same<T, DoubleAPFloat>::value, "");
772
36.9M
    if (std::is_same<T, DoubleAPFloat>::value) {
773
0
      return &Semantics == &PPCDoubleDouble();
774
0
    }
775
36.9M
    return &Semantics != &PPCDoubleDouble();
776
36.9M
  }
777
778
4
  IEEEFloat &getIEEE() {
779
4
    if (usesLayout<IEEEFloat>(*U.semantics))
780
0
      return U.IEEE;
781
4
    if (usesLayout<DoubleAPFloat>(*U.semantics))
782
4
      return U.Double.getFirst().U.IEEE;
783
0
    llvm_unreachable("Unexpected semantics");
784
0
  }
785
786
5.08M
  const IEEEFloat &getIEEE() const {
787
5.08M
    if (usesLayout<IEEEFloat>(*U.semantics))
788
5.08M
      return U.IEEE;
789
375
    if (usesLayout<DoubleAPFloat>(*U.semantics))
790
375
      return U.Double.getFirst().U.IEEE;
791
0
    llvm_unreachable("Unexpected semantics");
792
0
  }
793
794
63.6k
  void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); }
795
796
14.9k
  void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); }
797
798
4.91k
  void makeNaN(bool SNaN, bool Neg, const APInt *fill) {
799
4.91k
    APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill));
800
4.91k
  }
801
802
275
  void makeLargest(bool Neg) {
803
275
    APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg));
804
275
  }
805
806
44
  void makeSmallest(bool Neg) {
807
44
    APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
808
44
  }
809
810
274
  void makeSmallestNormalized(bool Neg) {
811
274
    APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg));
812
274
  }
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
209
  explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {}
822
  explicit APFloat(DoubleAPFloat F, const fltSemantics &S)
823
4
      : U(std::move(F), S) {}
824
825
6
  cmpResult compareAbsoluteValue(const APFloat &RHS) const {
826
6
    assert(&getSemantics() == &RHS.getSemantics() &&
827
6
           "Should only compare APFloats with the same semantics");
828
6
    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
0
    llvm_unreachable("Unexpected semantics");
833
0
  }
834
835
public:
836
322k
  APFloat(const fltSemantics &Semantics) : U(Semantics) {}
837
  APFloat(const fltSemantics &Semantics, StringRef S);
838
2.45M
  APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {}
839
  // TODO: Remove this constructor. This isn't faster than the first one.
840
  APFloat(const fltSemantics &Semantics, uninitializedTag)
841
84.1k
      : U(Semantics, uninitialized) {}
842
1.12M
  APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
843
5.43M
  explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
844
22.9k
  explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
845
1.88M
  APFloat(const APFloat &RHS) = default;
846
242k
  APFloat(APFloat &&RHS) = default;
847
848
11.0M
  ~APFloat() = default;
849
850
939
  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
63.5k
  static APFloat getZero(const fltSemantics &Sem, bool Negative = false) {
856
63.5k
    APFloat Val(Sem, uninitialized);
857
63.5k
    Val.makeZero(Negative);
858
63.5k
    return Val;
859
63.5k
  }
860
861
  /// Factory for Positive and Negative Infinity.
862
  ///
863
  /// \param Negative True iff the number should be negative.
864
14.9k
  static APFloat getInf(const fltSemantics &Sem, bool Negative = false) {
865
14.9k
    APFloat Val(Sem, uninitialized);
866
14.9k
    Val.makeInf(Negative);
867
14.9k
    return Val;
868
14.9k
  }
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
  static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
876
1.81k
                        unsigned type = 0) {
877
1.81k
    if (type) {
878
2
      APInt fill(64, type);
879
2
      return getQNaN(Sem, Negative, &fill);
880
1.81k
    } else {
881
1.81k
      return getQNaN(Sem, Negative, nullptr);
882
1.81k
    }
883
1.81k
  }
884
885
  /// Factory for QNaN values.
886
  static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false,
887
3.40k
                         const APInt *payload = nullptr) {
888
3.40k
    APFloat Val(Sem, uninitialized);
889
3.40k
    Val.makeNaN(false, Negative, payload);
890
3.40k
    return Val;
891
3.40k
  }
892
893
  /// Factory for SNaN values.
894
  static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false,
895
1.51k
                         const APInt *payload = nullptr) {
896
1.51k
    APFloat Val(Sem, uninitialized);
897
1.51k
    Val.makeNaN(true, Negative, payload);
898
1.51k
    return Val;
899
1.51k
  }
900
901
  /// Returns the largest finite number in the given semantics.
902
  ///
903
  /// \param Negative - True iff the number should be negative
904
275
  static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) {
905
275
    APFloat Val(Sem, uninitialized);
906
275
    Val.makeLargest(Negative);
907
275
    return Val;
908
275
  }
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
39
  static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) {
915
39
    APFloat Val(Sem, uninitialized);
916
39
    Val.makeSmallest(Negative);
917
39
    return Val;
918
39
  }
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
274
                                       bool Negative = false) {
926
274
    APFloat Val(Sem, uninitialized);
927
274
    Val.makeSmallestNormalized(Negative);
928
274
    return Val;
929
274
  }
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
11.0k
  opStatus add(const APFloat &RHS, roundingMode RM) {
942
11.0k
    assert(&getSemantics() == &RHS.getSemantics() &&
943
11.0k
           "Should only call on two APFloats with the same semantics");
944
11.0k
    if (usesLayout<IEEEFloat>(getSemantics()))
945
11.0k
      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
0
    llvm_unreachable("Unexpected semantics");
949
0
  }
950
9.15k
  opStatus subtract(const APFloat &RHS, roundingMode RM) {
951
9.15k
    assert(&getSemantics() == &RHS.getSemantics() &&
952
9.15k
           "Should only call on two APFloats with the same semantics");
953
9.15k
    if (usesLayout<IEEEFloat>(getSemantics()))
954
9.14k
      return U.IEEE.subtract(RHS.U.IEEE, RM);
955
10
    if (usesLayout<DoubleAPFloat>(getSemantics()))
956
10
      return U.Double.subtract(RHS.U.Double, RM);
957
0
    llvm_unreachable("Unexpected semantics");
958
0
  }
959
10.8k
  opStatus multiply(const APFloat &RHS, roundingMode RM) {
960
10.8k
    assert(&getSemantics() == &RHS.getSemantics() &&
961
10.8k
           "Should only call on two APFloats with the same semantics");
962
10.8k
    if (usesLayout<IEEEFloat>(getSemantics()))
963
10.7k
      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
0
    llvm_unreachable("Unexpected semantics");
967
0
  }
968
13.6k
  opStatus divide(const APFloat &RHS, roundingMode RM) {
969
13.6k
    assert(&getSemantics() == &RHS.getSemantics() &&
970
13.6k
           "Should only call on two APFloats with the same semantics");
971
13.6k
    if (usesLayout<IEEEFloat>(getSemantics()))
972
13.6k
      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
0
    llvm_unreachable("Unexpected semantics");
976
0
  }
977
4
  opStatus remainder(const APFloat &RHS) {
978
4
    assert(&getSemantics() == &RHS.getSemantics() &&
979
4
           "Should only call on two APFloats with the same semantics");
980
4
    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
0
    llvm_unreachable("Unexpected semantics");
985
0
  }
986
148
  opStatus mod(const APFloat &RHS) {
987
148
    assert(&getSemantics() == &RHS.getSemantics() &&
988
148
           "Should only call on two APFloats with the same semantics");
989
148
    if (usesLayout<IEEEFloat>(getSemantics()))
990
146
      return U.IEEE.mod(RHS.U.IEEE);
991
2
    if (usesLayout<DoubleAPFloat>(getSemantics()))
992
2
      return U.Double.mod(RHS.U.Double);
993
0
    llvm_unreachable("Unexpected semantics");
994
0
  }
995
  opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend,
996
133
                            roundingMode RM) {
997
133
    assert(&getSemantics() == &Multiplicand.getSemantics() &&
998
133
           "Should only call on APFloats with the same semantics");
999
133
    assert(&getSemantics() == &Addend.getSemantics() &&
1000
133
           "Should only call on APFloats with the same semantics");
1001
133
    if (usesLayout<IEEEFloat>(getSemantics()))
1002
132
      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
0
    llvm_unreachable("Unexpected semantics");
1007
0
  }
1008
19.9k
  opStatus roundToIntegral(roundingMode RM) {
1009
19.9k
    APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM));
1010
19.9k
  }
1011
1012
  // TODO: bool parameters are not readable and a source of bugs.
1013
  // Do something.
1014
44
  opStatus next(bool nextDown) {
1015
44
    APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown));
1016
44
  }
1017
1018
  /// Add two APFloats, rounding ties to the nearest even.
1019
  /// No error checking.
1020
93
  APFloat operator+(const APFloat &RHS) const {
1021
93
    APFloat Result(*this);
1022
93
    (void)Result.add(RHS, rmNearestTiesToEven);
1023
93
    return Result;
1024
93
  }
1025
1026
  /// Subtract two APFloats, rounding ties to the nearest even.
1027
  /// No error checking.
1028
70
  APFloat operator-(const APFloat &RHS) const {
1029
70
    APFloat Result(*this);
1030
70
    (void)Result.subtract(RHS, rmNearestTiesToEven);
1031
70
    return Result;
1032
70
  }
1033
1034
  /// Multiply two APFloats, rounding ties to the nearest even.
1035
  /// No error checking.
1036
502
  APFloat operator*(const APFloat &RHS) const {
1037
502
    APFloat Result(*this);
1038
502
    (void)Result.multiply(RHS, rmNearestTiesToEven);
1039
502
    return Result;
1040
502
  }
1041
1042
  /// Divide the first APFloat by the second, rounding ties to the nearest even.
1043
  /// No error checking.
1044
76
  APFloat operator/(const APFloat &RHS) const {
1045
76
    APFloat Result(*this);
1046
76
    (void)Result.divide(RHS, rmNearestTiesToEven);
1047
76
    return Result;
1048
76
  }
1049
1050
92.5k
  void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); }
1051
2.37k
  void clearSign() {
1052
2.37k
    if (isNegative())
1053
113
      changeSign();
1054
2.37k
  }
1055
70
  void copySign(const APFloat &RHS) {
1056
70
    if (isNegative() != RHS.isNegative())
1057
15
      changeSign();
1058
70
  }
1059
1060
  /// A static helper to produce a copy of an APFloat value with its sign
1061
  /// copied from some other APFloat.
1062
56
  static APFloat copySign(APFloat Value, const APFloat &Sign) {
1063
56
    Value.copySign(Sign);
1064
56
    return Value;
1065
56
  }
1066
1067
  opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
1068
                   bool *losesInfo);
1069
  opStatus convertToInteger(MutableArrayRef<integerPart> Input,
1070
                            unsigned int Width, bool IsSigned, roundingMode RM,
1071
64.0k
                            bool *IsExact) const {
1072
64.0k
    APFLOAT_DISPATCH_ON_SEMANTICS(
1073
64.0k
        convertToInteger(Input, Width, IsSigned, RM, IsExact));
1074
64.0k
  }
1075
  opStatus convertToInteger(APSInt &Result, roundingMode RM,
1076
                            bool *IsExact) const;
1077
  opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
1078
50.6k
                            roundingMode RM) {
1079
50.6k
    APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM));
1080
50.6k
  }
1081
  opStatus convertFromSignExtendedInteger(const integerPart *Input,
1082
                                          unsigned int InputSize, bool IsSigned,
1083
0
                                          roundingMode RM) {
1084
0
    APFLOAT_DISPATCH_ON_SEMANTICS(
1085
0
        convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM));
1086
0
  }
1087
  opStatus convertFromZeroExtendedInteger(const integerPart *Input,
1088
                                          unsigned int InputSize, bool IsSigned,
1089
0
                                          roundingMode RM) {
1090
0
    APFLOAT_DISPATCH_ON_SEMANTICS(
1091
0
        convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM));
1092
0
  }
1093
  opStatus convertFromString(StringRef, roundingMode);
1094
1.37M
  APInt bitcastToAPInt() const {
1095
1.37M
    APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt());
1096
1.37M
  }
1097
24.8k
  double convertToDouble() const { return getIEEE().convertToDouble(); }
1098
11.6k
  float convertToFloat() const { return getIEEE().convertToFloat(); }
1099
1100
  bool operator==(const APFloat &) const = delete;
1101
1102
29.7k
  cmpResult compare(const APFloat &RHS) const {
1103
29.7k
    assert(&getSemantics() == &RHS.getSemantics() &&
1104
29.7k
           "Should only compare APFloats with the same semantics");
1105
29.7k
    if (usesLayout<IEEEFloat>(getSemantics()))
1106
29.7k
      return U.IEEE.compare(RHS.U.IEEE);
1107
12
    if (usesLayout<DoubleAPFloat>(getSemantics()))
1108
12
      return U.Double.compare(RHS.U.Double);
1109
0
    llvm_unreachable("Unexpected semantics");
1110
0
  }
1111
1112
4.62M
  bool bitwiseIsEqual(const APFloat &RHS) const {
1113
4.62M
    if (&getSemantics() != &RHS.getSemantics())
1114
1.53M
      return false;
1115
3.09M
    if (usesLayout<IEEEFloat>(getSemantics()))
1116
3.09M
      return U.IEEE.bitwiseIsEqual(RHS.U.IEEE);
1117
76
    if (usesLayout<DoubleAPFloat>(getSemantics()))
1118
76
      return U.Double.bitwiseIsEqual(RHS.U.Double);
1119
0
    llvm_unreachable("Unexpected semantics");
1120
0
  }
1121
1122
  /// We don't rely on operator== working on double values, as
1123
  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
1124
  /// As such, this method can be used to do an exact bit-for-bit comparison of
1125
  /// two floating point values.
1126
  ///
1127
  /// We leave the version with the double argument here because it's just so
1128
  /// convenient to write "2.0" and the like.  Without this function we'd
1129
  /// have to duplicate its logic everywhere it's called.
1130
108k
  bool isExactlyValue(double V) const {
1131
108k
    bool ignored;
1132
108k
    APFloat Tmp(V);
1133
108k
    Tmp.convert(getSemantics(), APFloat::rmNearestTiesToEven, &ignored);
1134
108k
    return bitwiseIsEqual(Tmp);
1135
108k
  }
1136
1137
  unsigned int convertToHexString(char *DST, unsigned int HexDigits,
1138
0
                                  bool UpperCase, roundingMode RM) const {
1139
0
    APFLOAT_DISPATCH_ON_SEMANTICS(
1140
0
        convertToHexString(DST, HexDigits, UpperCase, RM));
1141
0
  }
1142
1143
2.40M
  bool isZero() const { return getCategory() == fcZero; }
1144
378k
  bool isInfinity() const { return getCategory() == fcInfinity; }
1145
1.62M
  bool isNaN() const { return getCategory() == fcNaN; }
1146
1147
618k
  bool isNegative() const { return getIEEE().isNegative(); }
1148
638
  bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); }
1149
25.0k
  bool isSignaling() const { return getIEEE().isSignaling(); }
1150
1151
461
  bool isNormal() const { return !isDenormal() && 
isFiniteNonZero()443
; }
1152
23.1k
  bool isFinite() const { return !isNaN() && 
!isInfinity()23.0k
; }
1153
1154
4.40M
  fltCategory getCategory() const { return getIEEE().getCategory(); }
1155
18.5M
  const fltSemantics &getSemantics() const { return *U.semantics; }
1156
0
  bool isNonZero() const { return !isZero(); }
1157
1.69k
  bool isFiniteNonZero() const { return isFinite() && 
!isZero()1.66k
; }
1158
579k
  bool isPosZero() const { return isZero() && 
!isNegative()30.3k
; }
1159
687k
  bool isNegZero() const { return isZero() && 
isNegative()125k
; }
1160
  bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); }
1161
  bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); }
1162
19
  bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); }
1163
1164
231k
  APFloat &operator=(const APFloat &RHS) = default;
1165
763k
  APFloat &operator=(APFloat &&RHS) = default;
1166
1167
  void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
1168
89.0k
                unsigned FormatMaxPadding = 3, bool TruncateZero = true) const {
1169
89.0k
    APFLOAT_DISPATCH_ON_SEMANTICS(
1170
89.0k
        toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero));
1171
89.0k
  }
1172
1173
  void print(raw_ostream &) const;
1174
  void dump() const;
1175
1176
62.5k
  bool getExactInverse(APFloat *inv) const {
1177
62.5k
    APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
1178
62.5k
  }
1179
1180
  friend hash_code hash_value(const APFloat &Arg);
1181
109
  friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
1182
  friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
1183
  friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
1184
  friend IEEEFloat;
1185
  friend DoubleAPFloat;
1186
};
1187
1188
/// See friend declarations above.
1189
///
1190
/// These additional declarations are required in order to compile LLVM with IBM
1191
/// xlC compiler.
1192
hash_code hash_value(const APFloat &Arg);
1193
144
inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) {
1194
144
  if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
1195
142
    return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics());
1196
2
  if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
1197
2
    return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics());
1198
0
  llvm_unreachable("Unexpected semantics");
1199
0
}
1200
1201
/// Equivalent of C standard library function.
1202
///
1203
/// While the C standard says Exp is an unspecified value for infinity and nan,
1204
/// this returns INT_MAX for infinities, and INT_MIN for NaNs.
1205
61
inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) {
1206
61
  if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics()))
1207
59
    return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics());
1208
2
  if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics()))
1209
2
    return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics());
1210
0
  llvm_unreachable("Unexpected semantics");
1211
0
}
1212
/// Returns the absolute value of the argument.
1213
65
inline APFloat abs(APFloat X) {
1214
65
  X.clearSign();
1215
65
  return X;
1216
65
}
1217
1218
/// Returns the negated value of the argument.
1219
5.66k
inline APFloat neg(APFloat X) {
1220
5.66k
  X.changeSign();
1221
5.66k
  return X;
1222
5.66k
}
1223
1224
/// Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if
1225
/// both are not NaN. If either argument is a NaN, returns the other argument.
1226
LLVM_READONLY
1227
95
inline APFloat minnum(const APFloat &A, const APFloat &B) {
1228
95
  if (A.isNaN())
1229
54
    return B;
1230
41
  if (B.isNaN())
1231
8
    return A;
1232
33
  return (B.compare(A) == APFloat::cmpLessThan) ? 
B5
:
A28
;
1233
33
}
1234
1235
/// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if
1236
/// both are not NaN. If either argument is a NaN, returns the other argument.
1237
LLVM_READONLY
1238
120
inline APFloat maxnum(const APFloat &A, const APFloat &B) {
1239
120
  if (A.isNaN())
1240
53
    return B;
1241
67
  if (B.isNaN())
1242
5
    return A;
1243
62
  return (A.compare(B) == APFloat::cmpLessThan) ? 
B21
:
A41
;
1244
62
}
1245
1246
} // namespace llvm
1247
1248
#undef APFLOAT_DISPATCH_ON_SEMANTICS
1249
#endif // LLVM_ADT_APFLOAT_H