1 //===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// This file declares a class to represent arbitrary precision floating point 11 /// values and provide a variety of arithmetic operations on them. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_ADT_APFLOAT_H 16 #define LLVM_ADT_APFLOAT_H 17 18 #include "llvm/ADT/APInt.h" 19 #include "llvm/ADT/ArrayRef.h" 20 #include "llvm/ADT/FloatingPointMode.h" 21 #include "llvm/Support/ErrorHandling.h" 22 #include <memory> 23 24 #define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \ 25 do { \ 26 if (usesLayout<IEEEFloat>(getSemantics())) \ 27 return U.IEEE.METHOD_CALL; \ 28 if (usesLayout<DoubleAPFloat>(getSemantics())) \ 29 return U.Double.METHOD_CALL; \ 30 llvm_unreachable("Unexpected semantics"); \ 31 } while (false) 32 33 namespace llvm { 34 35 struct fltSemantics; 36 class APSInt; 37 class StringRef; 38 class APFloat; 39 class raw_ostream; 40 41 template <typename T> class Expected; 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 constexpr unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD; 145 146 /// A signed type to represent a floating point numbers unbiased exponent. 147 typedef int32_t ExponentType; 148 149 /// \name Floating Point Semantics. 150 /// @{ 151 enum Semantics { 152 S_IEEEhalf, 153 S_BFloat, 154 S_IEEEsingle, 155 S_IEEEdouble, 156 S_x87DoubleExtended, 157 S_IEEEquad, 158 S_PPCDoubleDouble, 159 S_MaxSemantics = S_PPCDoubleDouble 160 }; 161 162 static const llvm::fltSemantics &EnumToSemantics(Semantics S); 163 static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem); 164 165 static const fltSemantics &IEEEhalf() LLVM_READNONE; 166 static const fltSemantics &BFloat() LLVM_READNONE; 167 static const fltSemantics &IEEEsingle() LLVM_READNONE; 168 static const fltSemantics &IEEEdouble() LLVM_READNONE; 169 static const fltSemantics &IEEEquad() LLVM_READNONE; 170 static const fltSemantics &PPCDoubleDouble() LLVM_READNONE; 171 static const fltSemantics &x87DoubleExtended() LLVM_READNONE; 172 173 /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with 174 /// anything real. 175 static const fltSemantics &Bogus() LLVM_READNONE; 176 177 /// @} 178 179 /// IEEE-754R 5.11: Floating Point Comparison Relations. 180 enum cmpResult { 181 cmpLessThan, 182 cmpEqual, 183 cmpGreaterThan, 184 cmpUnordered 185 }; 186 187 /// IEEE-754R 4.3: Rounding-direction attributes. 188 using roundingMode = llvm::RoundingMode; 189 190 static constexpr roundingMode rmNearestTiesToEven = 191 RoundingMode::NearestTiesToEven; 192 static constexpr roundingMode rmTowardPositive = RoundingMode::TowardPositive; 193 static constexpr roundingMode rmTowardNegative = RoundingMode::TowardNegative; 194 static constexpr roundingMode rmTowardZero = RoundingMode::TowardZero; 195 static constexpr roundingMode rmNearestTiesToAway = 196 RoundingMode::NearestTiesToAway; 197 198 /// IEEE-754R 7: Default exception handling. 199 /// 200 /// opUnderflow or opOverflow are always returned or-ed with opInexact. 201 /// 202 /// APFloat models this behavior specified by IEEE-754: 203 /// "For operations producing results in floating-point format, the default 204 /// result of an operation that signals the invalid operation exception 205 /// shall be a quiet NaN." 206 enum opStatus { 207 opOK = 0x00, 208 opInvalidOp = 0x01, 209 opDivByZero = 0x02, 210 opOverflow = 0x04, 211 opUnderflow = 0x08, 212 opInexact = 0x10 213 }; 214 215 /// Category of internally-represented number. 216 enum fltCategory { 217 fcInfinity, 218 fcNaN, 219 fcNormal, 220 fcZero 221 }; 222 223 /// Convenience enum used to construct an uninitialized APFloat. 224 enum uninitializedTag { 225 uninitialized 226 }; 227 228 /// Enumeration of \c ilogb error results. 229 enum IlogbErrorKinds { 230 IEK_Zero = INT_MIN + 1, 231 IEK_NaN = INT_MIN, 232 IEK_Inf = INT_MAX 233 }; 234 235 static unsigned int semanticsPrecision(const fltSemantics &); 236 static ExponentType semanticsMinExponent(const fltSemantics &); 237 static ExponentType semanticsMaxExponent(const fltSemantics &); 238 static unsigned int semanticsSizeInBits(const fltSemantics &); 239 240 /// Returns the size of the floating point number (in bits) in the given 241 /// semantics. 242 static unsigned getSizeInBits(const fltSemantics &Sem); 243 }; 244 245 namespace detail { 246 247 class IEEEFloat final : public APFloatBase { 248 public: 249 /// \name Constructors 250 /// @{ 251 252 IEEEFloat(const fltSemantics &); // Default construct to +0.0 253 IEEEFloat(const fltSemantics &, integerPart); 254 IEEEFloat(const fltSemantics &, uninitializedTag); 255 IEEEFloat(const fltSemantics &, const APInt &); 256 explicit IEEEFloat(double d); 257 explicit IEEEFloat(float f); 258 IEEEFloat(const IEEEFloat &); 259 IEEEFloat(IEEEFloat &&); 260 ~IEEEFloat(); 261 262 /// @} 263 264 /// Returns whether this instance allocated memory. 265 bool needsCleanup() const { return partCount() > 1; } 266 267 /// \name Convenience "constructors" 268 /// @{ 269 270 /// @} 271 272 /// \name Arithmetic 273 /// @{ 274 275 opStatus add(const IEEEFloat &, roundingMode); 276 opStatus subtract(const IEEEFloat &, roundingMode); 277 opStatus multiply(const IEEEFloat &, roundingMode); 278 opStatus divide(const IEEEFloat &, roundingMode); 279 /// IEEE remainder. 280 opStatus remainder(const IEEEFloat &); 281 /// C fmod, or llvm frem. 282 opStatus mod(const IEEEFloat &); 283 opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode); 284 opStatus roundToIntegral(roundingMode); 285 /// IEEE-754R 5.3.1: nextUp/nextDown. 286 opStatus next(bool nextDown); 287 288 /// @} 289 290 /// \name Sign operations. 291 /// @{ 292 293 void changeSign(); 294 295 /// @} 296 297 /// \name Conversions 298 /// @{ 299 300 opStatus convert(const fltSemantics &, roundingMode, bool *); 301 opStatus convertToInteger(MutableArrayRef<integerPart>, unsigned int, bool, 302 roundingMode, bool *) const; 303 opStatus convertFromAPInt(const APInt &, bool, roundingMode); 304 opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int, 305 bool, roundingMode); 306 opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, 307 bool, roundingMode); 308 Expected<opStatus> convertFromString(StringRef, roundingMode); 309 APInt bitcastToAPInt() const; 310 double convertToDouble() const; 311 float convertToFloat() const; 312 313 /// @} 314 315 /// The definition of equality is not straightforward for floating point, so 316 /// we won't use operator==. Use one of the following, or write whatever it 317 /// is you really mean. 318 bool operator==(const IEEEFloat &) const = delete; 319 320 /// IEEE comparison with another floating point number (NaNs compare 321 /// unordered, 0==-0). 322 cmpResult compare(const IEEEFloat &) const; 323 324 /// Bitwise comparison for equality (QNaNs compare equal, 0!=-0). 325 bool bitwiseIsEqual(const IEEEFloat &) const; 326 327 /// Write out a hexadecimal representation of the floating point value to DST, 328 /// which must be of sufficient size, in the C99 form [-]0xh.hhhhp[+-]d. 329 /// Return the number of characters written, excluding the terminating NUL. 330 unsigned int convertToHexString(char *dst, unsigned int hexDigits, 331 bool upperCase, roundingMode) const; 332 333 /// \name IEEE-754R 5.7.2 General operations. 334 /// @{ 335 336 /// IEEE-754R isSignMinus: Returns true if and only if the current value is 337 /// negative. 338 /// 339 /// This applies to zeros and NaNs as well. 340 bool isNegative() const { return sign; } 341 342 /// IEEE-754R isNormal: Returns true if and only if the current value is normal. 343 /// 344 /// This implies that the current value of the float is not zero, subnormal, 345 /// infinite, or NaN following the definition of normality from IEEE-754R. 346 bool isNormal() const { return !isDenormal() && isFiniteNonZero(); } 347 348 /// Returns true if and only if the current value is zero, subnormal, or 349 /// normal. 350 /// 351 /// This means that the value is not infinite or NaN. 352 bool isFinite() const { return !isNaN() && !isInfinity(); } 353 354 /// Returns true if and only if the float is plus or minus zero. 355 bool isZero() const { return category == fcZero; } 356 357 /// IEEE-754R isSubnormal(): Returns true if and only if the float is a 358 /// denormal. 359 bool isDenormal() const; 360 361 /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity. 362 bool isInfinity() const { return category == fcInfinity; } 363 364 /// Returns true if and only if the float is a quiet or signaling NaN. 365 bool isNaN() const { return category == fcNaN; } 366 367 /// Returns true if and only if the float is a signaling NaN. 368 bool isSignaling() const; 369 370 /// @} 371 372 /// \name Simple Queries 373 /// @{ 374 375 fltCategory getCategory() const { return category; } 376 const fltSemantics &getSemantics() const { return *semantics; } 377 bool isNonZero() const { return category != fcZero; } 378 bool isFiniteNonZero() const { return isFinite() && !isZero(); } 379 bool isPosZero() const { return isZero() && !isNegative(); } 380 bool isNegZero() const { return isZero() && isNegative(); } 381 382 /// Returns true if and only if the number has the smallest possible non-zero 383 /// magnitude in the current semantics. 384 bool isSmallest() const; 385 386 /// Returns true if and only if the number has the largest possible finite 387 /// magnitude in the current semantics. 388 bool isLargest() const; 389 390 /// Returns true if and only if the number is an exact integer. 391 bool isInteger() const; 392 393 /// @} 394 395 IEEEFloat &operator=(const IEEEFloat &); 396 IEEEFloat &operator=(IEEEFloat &&); 397 398 /// Overload to compute a hash code for an APFloat value. 399 /// 400 /// Note that the use of hash codes for floating point values is in general 401 /// frought with peril. Equality is hard to define for these values. For 402 /// example, should negative and positive zero hash to different codes? Are 403 /// they equal or not? This hash value implementation specifically 404 /// emphasizes producing different codes for different inputs in order to 405 /// be used in canonicalization and memoization. As such, equality is 406 /// bitwiseIsEqual, and 0 != -0. 407 friend hash_code hash_value(const IEEEFloat &Arg); 408 409 /// Converts this value into a decimal string. 410 /// 411 /// \param FormatPrecision The maximum number of digits of 412 /// precision to output. If there are fewer digits available, 413 /// zero padding will not be used unless the value is 414 /// integral and small enough to be expressed in 415 /// FormatPrecision digits. 0 means to use the natural 416 /// precision of the number. 417 /// \param FormatMaxPadding The maximum number of zeros to 418 /// consider inserting before falling back to scientific 419 /// notation. 0 means to always use scientific notation. 420 /// 421 /// \param TruncateZero Indicate whether to remove the trailing zero in 422 /// fraction part or not. Also setting this parameter to false forcing 423 /// producing of output more similar to default printf behavior. 424 /// Specifically the lower e is used as exponent delimiter and exponent 425 /// always contains no less than two digits. 426 /// 427 /// Number Precision MaxPadding Result 428 /// ------ --------- ---------- ------ 429 /// 1.01E+4 5 2 10100 430 /// 1.01E+4 4 2 1.01E+4 431 /// 1.01E+4 5 1 1.01E+4 432 /// 1.01E-2 5 2 0.0101 433 /// 1.01E-2 4 2 0.0101 434 /// 1.01E-2 4 1 1.01E-2 435 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0, 436 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const; 437 438 /// If this value has an exact multiplicative inverse, store it in inv and 439 /// return true. 440 bool getExactInverse(APFloat *inv) const; 441 442 /// Returns the exponent of the internal representation of the APFloat. 443 /// 444 /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)). 445 /// For special APFloat values, this returns special error codes: 446 /// 447 /// NaN -> \c IEK_NaN 448 /// 0 -> \c IEK_Zero 449 /// Inf -> \c IEK_Inf 450 /// 451 friend int ilogb(const IEEEFloat &Arg); 452 453 /// Returns: X * 2^Exp for integral exponents. 454 friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode); 455 456 friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode); 457 458 /// \name Special value setters. 459 /// @{ 460 461 void makeLargest(bool Neg = false); 462 void makeSmallest(bool Neg = false); 463 void makeNaN(bool SNaN = false, bool Neg = false, 464 const APInt *fill = nullptr); 465 void makeInf(bool Neg = false); 466 void makeZero(bool Neg = false); 467 void makeQuiet(); 468 469 /// Returns the smallest (by magnitude) normalized finite number in the given 470 /// semantics. 471 /// 472 /// \param Negative - True iff the number should be negative 473 void makeSmallestNormalized(bool Negative = false); 474 475 /// @} 476 477 cmpResult compareAbsoluteValue(const IEEEFloat &) const; 478 479 private: 480 /// \name Simple Queries 481 /// @{ 482 483 integerPart *significandParts(); 484 const integerPart *significandParts() const; 485 unsigned int partCount() const; 486 487 /// @} 488 489 /// \name Significand operations. 490 /// @{ 491 492 integerPart addSignificand(const IEEEFloat &); 493 integerPart subtractSignificand(const IEEEFloat &, integerPart); 494 lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract); 495 lostFraction multiplySignificand(const IEEEFloat &, IEEEFloat); 496 lostFraction multiplySignificand(const IEEEFloat&); 497 lostFraction divideSignificand(const IEEEFloat &); 498 void incrementSignificand(); 499 void initialize(const fltSemantics *); 500 void shiftSignificandLeft(unsigned int); 501 lostFraction shiftSignificandRight(unsigned int); 502 unsigned int significandLSB() const; 503 unsigned int significandMSB() const; 504 void zeroSignificand(); 505 /// Return true if the significand excluding the integral bit is all ones. 506 bool isSignificandAllOnes() const; 507 /// Return true if the significand excluding the integral bit is all zeros. 508 bool isSignificandAllZeros() const; 509 510 /// @} 511 512 /// \name Arithmetic on special values. 513 /// @{ 514 515 opStatus addOrSubtractSpecials(const IEEEFloat &, bool subtract); 516 opStatus divideSpecials(const IEEEFloat &); 517 opStatus multiplySpecials(const IEEEFloat &); 518 opStatus modSpecials(const IEEEFloat &); 519 opStatus remainderSpecials(const IEEEFloat&); 520 521 /// @} 522 523 /// \name Miscellany 524 /// @{ 525 526 bool convertFromStringSpecials(StringRef str); 527 opStatus normalize(roundingMode, lostFraction); 528 opStatus addOrSubtract(const IEEEFloat &, roundingMode, bool subtract); 529 opStatus handleOverflow(roundingMode); 530 bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const; 531 opStatus convertToSignExtendedInteger(MutableArrayRef<integerPart>, 532 unsigned int, bool, roundingMode, 533 bool *) const; 534 opStatus convertFromUnsignedParts(const integerPart *, unsigned int, 535 roundingMode); 536 Expected<opStatus> convertFromHexadecimalString(StringRef, roundingMode); 537 Expected<opStatus> convertFromDecimalString(StringRef, roundingMode); 538 char *convertNormalToHexString(char *, unsigned int, bool, 539 roundingMode) const; 540 opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int, 541 roundingMode); 542 ExponentType exponentNaN() const; 543 ExponentType exponentInf() const; 544 ExponentType exponentZero() const; 545 546 /// @} 547 548 APInt convertHalfAPFloatToAPInt() const; 549 APInt convertBFloatAPFloatToAPInt() const; 550 APInt convertFloatAPFloatToAPInt() const; 551 APInt convertDoubleAPFloatToAPInt() const; 552 APInt convertQuadrupleAPFloatToAPInt() const; 553 APInt convertF80LongDoubleAPFloatToAPInt() const; 554 APInt convertPPCDoubleDoubleAPFloatToAPInt() const; 555 void initFromAPInt(const fltSemantics *Sem, const APInt &api); 556 void initFromHalfAPInt(const APInt &api); 557 void initFromBFloatAPInt(const APInt &api); 558 void initFromFloatAPInt(const APInt &api); 559 void initFromDoubleAPInt(const APInt &api); 560 void initFromQuadrupleAPInt(const APInt &api); 561 void initFromF80LongDoubleAPInt(const APInt &api); 562 void initFromPPCDoubleDoubleAPInt(const APInt &api); 563 564 void assign(const IEEEFloat &); 565 void copySignificand(const IEEEFloat &); 566 void freeSignificand(); 567 568 /// Note: this must be the first data member. 569 /// The semantics that this value obeys. 570 const fltSemantics *semantics; 571 572 /// A binary fraction with an explicit integer bit. 573 /// 574 /// The significand must be at least one bit wider than the target precision. 575 union Significand { 576 integerPart part; 577 integerPart *parts; 578 } significand; 579 580 /// The signed unbiased exponent of the value. 581 ExponentType exponent; 582 583 /// What kind of floating point number this is. 584 /// 585 /// Only 2 bits are required, but VisualStudio incorrectly sign extends it. 586 /// Using the extra bit keeps it from failing under VisualStudio. 587 fltCategory category : 3; 588 589 /// Sign bit of the number. 590 unsigned int sign : 1; 591 }; 592 593 hash_code hash_value(const IEEEFloat &Arg); 594 int ilogb(const IEEEFloat &Arg); 595 IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode); 596 IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM); 597 598 // This mode implements more precise float in terms of two APFloats. 599 // The interface and layout is designed for arbitrary underlying semantics, 600 // though currently only PPCDoubleDouble semantics are supported, whose 601 // corresponding underlying semantics are IEEEdouble. 602 class DoubleAPFloat final : public APFloatBase { 603 // Note: this must be the first data member. 604 const fltSemantics *Semantics; 605 std::unique_ptr<APFloat[]> Floats; 606 607 opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c, 608 const APFloat &cc, roundingMode RM); 609 610 opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS, 611 DoubleAPFloat &Out, roundingMode RM); 612 613 public: 614 DoubleAPFloat(const fltSemantics &S); 615 DoubleAPFloat(const fltSemantics &S, uninitializedTag); 616 DoubleAPFloat(const fltSemantics &S, integerPart); 617 DoubleAPFloat(const fltSemantics &S, const APInt &I); 618 DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second); 619 DoubleAPFloat(const DoubleAPFloat &RHS); 620 DoubleAPFloat(DoubleAPFloat &&RHS); 621 622 DoubleAPFloat &operator=(const DoubleAPFloat &RHS); 623 624 DoubleAPFloat &operator=(DoubleAPFloat &&RHS) { 625 if (this != &RHS) { 626 this->~DoubleAPFloat(); 627 new (this) DoubleAPFloat(std::move(RHS)); 628 } 629 return *this; 630 } 631 632 bool needsCleanup() const { return Floats != nullptr; } 633 634 APFloat &getFirst() { return Floats[0]; } 635 const APFloat &getFirst() const { return Floats[0]; } 636 APFloat &getSecond() { return Floats[1]; } 637 const APFloat &getSecond() const { return Floats[1]; } 638 639 opStatus add(const DoubleAPFloat &RHS, roundingMode RM); 640 opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM); 641 opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM); 642 opStatus divide(const DoubleAPFloat &RHS, roundingMode RM); 643 opStatus remainder(const DoubleAPFloat &RHS); 644 opStatus mod(const DoubleAPFloat &RHS); 645 opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand, 646 const DoubleAPFloat &Addend, roundingMode RM); 647 opStatus roundToIntegral(roundingMode RM); 648 void changeSign(); 649 cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const; 650 651 fltCategory getCategory() const; 652 bool isNegative() const; 653 654 void makeInf(bool Neg); 655 void makeZero(bool Neg); 656 void makeLargest(bool Neg); 657 void makeSmallest(bool Neg); 658 void makeSmallestNormalized(bool Neg); 659 void makeNaN(bool SNaN, bool Neg, const APInt *fill); 660 661 cmpResult compare(const DoubleAPFloat &RHS) const; 662 bool bitwiseIsEqual(const DoubleAPFloat &RHS) const; 663 APInt bitcastToAPInt() const; 664 Expected<opStatus> convertFromString(StringRef, roundingMode); 665 opStatus next(bool nextDown); 666 667 opStatus convertToInteger(MutableArrayRef<integerPart> Input, 668 unsigned int Width, bool IsSigned, roundingMode RM, 669 bool *IsExact) const; 670 opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM); 671 opStatus convertFromSignExtendedInteger(const integerPart *Input, 672 unsigned int InputSize, bool IsSigned, 673 roundingMode RM); 674 opStatus convertFromZeroExtendedInteger(const integerPart *Input, 675 unsigned int InputSize, bool IsSigned, 676 roundingMode RM); 677 unsigned int convertToHexString(char *DST, unsigned int HexDigits, 678 bool UpperCase, roundingMode RM) const; 679 680 bool isDenormal() const; 681 bool isSmallest() const; 682 bool isLargest() const; 683 bool isInteger() const; 684 685 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision, 686 unsigned FormatMaxPadding, bool TruncateZero = true) const; 687 688 bool getExactInverse(APFloat *inv) const; 689 690 friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode); 691 friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode); 692 friend hash_code hash_value(const DoubleAPFloat &Arg); 693 }; 694 695 hash_code hash_value(const DoubleAPFloat &Arg); 696 697 } // End detail namespace 698 699 // This is a interface class that is currently forwarding functionalities from 700 // detail::IEEEFloat. 701 class APFloat : public APFloatBase { 702 typedef detail::IEEEFloat IEEEFloat; 703 typedef detail::DoubleAPFloat DoubleAPFloat; 704 705 static_assert(std::is_standard_layout<IEEEFloat>::value, ""); 706 707 union Storage { 708 const fltSemantics *semantics; 709 IEEEFloat IEEE; 710 DoubleAPFloat Double; 711 712 explicit Storage(IEEEFloat F, const fltSemantics &S); 713 explicit Storage(DoubleAPFloat F, const fltSemantics &S) 714 : Double(std::move(F)) { 715 assert(&S == &PPCDoubleDouble()); 716 } 717 718 template <typename... ArgTypes> 719 Storage(const fltSemantics &Semantics, ArgTypes &&... Args) { 720 if (usesLayout<IEEEFloat>(Semantics)) { 721 new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...); 722 return; 723 } 724 if (usesLayout<DoubleAPFloat>(Semantics)) { 725 new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...); 726 return; 727 } 728 llvm_unreachable("Unexpected semantics"); 729 } 730 731 ~Storage() { 732 if (usesLayout<IEEEFloat>(*semantics)) { 733 IEEE.~IEEEFloat(); 734 return; 735 } 736 if (usesLayout<DoubleAPFloat>(*semantics)) { 737 Double.~DoubleAPFloat(); 738 return; 739 } 740 llvm_unreachable("Unexpected semantics"); 741 } 742 743 Storage(const Storage &RHS) { 744 if (usesLayout<IEEEFloat>(*RHS.semantics)) { 745 new (this) IEEEFloat(RHS.IEEE); 746 return; 747 } 748 if (usesLayout<DoubleAPFloat>(*RHS.semantics)) { 749 new (this) DoubleAPFloat(RHS.Double); 750 return; 751 } 752 llvm_unreachable("Unexpected semantics"); 753 } 754 755 Storage(Storage &&RHS) { 756 if (usesLayout<IEEEFloat>(*RHS.semantics)) { 757 new (this) IEEEFloat(std::move(RHS.IEEE)); 758 return; 759 } 760 if (usesLayout<DoubleAPFloat>(*RHS.semantics)) { 761 new (this) DoubleAPFloat(std::move(RHS.Double)); 762 return; 763 } 764 llvm_unreachable("Unexpected semantics"); 765 } 766 767 Storage &operator=(const Storage &RHS) { 768 if (usesLayout<IEEEFloat>(*semantics) && 769 usesLayout<IEEEFloat>(*RHS.semantics)) { 770 IEEE = RHS.IEEE; 771 } else if (usesLayout<DoubleAPFloat>(*semantics) && 772 usesLayout<DoubleAPFloat>(*RHS.semantics)) { 773 Double = RHS.Double; 774 } else if (this != &RHS) { 775 this->~Storage(); 776 new (this) Storage(RHS); 777 } 778 return *this; 779 } 780 781 Storage &operator=(Storage &&RHS) { 782 if (usesLayout<IEEEFloat>(*semantics) && 783 usesLayout<IEEEFloat>(*RHS.semantics)) { 784 IEEE = std::move(RHS.IEEE); 785 } else if (usesLayout<DoubleAPFloat>(*semantics) && 786 usesLayout<DoubleAPFloat>(*RHS.semantics)) { 787 Double = std::move(RHS.Double); 788 } else if (this != &RHS) { 789 this->~Storage(); 790 new (this) Storage(std::move(RHS)); 791 } 792 return *this; 793 } 794 } U; 795 796 template <typename T> static bool usesLayout(const fltSemantics &Semantics) { 797 static_assert(std::is_same<T, IEEEFloat>::value || 798 std::is_same<T, DoubleAPFloat>::value, ""); 799 if (std::is_same<T, DoubleAPFloat>::value) { 800 return &Semantics == &PPCDoubleDouble(); 801 } 802 return &Semantics != &PPCDoubleDouble(); 803 } 804 805 IEEEFloat &getIEEE() { 806 if (usesLayout<IEEEFloat>(*U.semantics)) 807 return U.IEEE; 808 if (usesLayout<DoubleAPFloat>(*U.semantics)) 809 return U.Double.getFirst().U.IEEE; 810 llvm_unreachable("Unexpected semantics"); 811 } 812 813 const IEEEFloat &getIEEE() const { 814 if (usesLayout<IEEEFloat>(*U.semantics)) 815 return U.IEEE; 816 if (usesLayout<DoubleAPFloat>(*U.semantics)) 817 return U.Double.getFirst().U.IEEE; 818 llvm_unreachable("Unexpected semantics"); 819 } 820 821 void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); } 822 823 void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); } 824 825 void makeNaN(bool SNaN, bool Neg, const APInt *fill) { 826 APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill)); 827 } 828 829 void makeLargest(bool Neg) { 830 APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg)); 831 } 832 833 void makeSmallest(bool Neg) { 834 APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg)); 835 } 836 837 void makeSmallestNormalized(bool Neg) { 838 APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg)); 839 } 840 841 // FIXME: This is due to clang 3.3 (or older version) always checks for the 842 // default constructor in an array aggregate initialization, even if no 843 // elements in the array is default initialized. 844 APFloat() : U(IEEEdouble()) { 845 llvm_unreachable("This is a workaround for old clang."); 846 } 847 848 explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {} 849 explicit APFloat(DoubleAPFloat F, const fltSemantics &S) 850 : U(std::move(F), S) {} 851 852 cmpResult compareAbsoluteValue(const APFloat &RHS) const { 853 assert(&getSemantics() == &RHS.getSemantics() && 854 "Should only compare APFloats with the same semantics"); 855 if (usesLayout<IEEEFloat>(getSemantics())) 856 return U.IEEE.compareAbsoluteValue(RHS.U.IEEE); 857 if (usesLayout<DoubleAPFloat>(getSemantics())) 858 return U.Double.compareAbsoluteValue(RHS.U.Double); 859 llvm_unreachable("Unexpected semantics"); 860 } 861 862 public: 863 APFloat(const fltSemantics &Semantics) : U(Semantics) {} 864 APFloat(const fltSemantics &Semantics, StringRef S); 865 APFloat(const fltSemantics &Semantics, integerPart I) : U(Semantics, I) {} 866 template <typename T, 867 typename = std::enable_if_t<std::is_floating_point<T>::value>> 868 APFloat(const fltSemantics &Semantics, T V) = delete; 869 // TODO: Remove this constructor. This isn't faster than the first one. 870 APFloat(const fltSemantics &Semantics, uninitializedTag) 871 : U(Semantics, uninitialized) {} 872 APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {} 873 explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {} 874 explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {} 875 APFloat(const APFloat &RHS) = default; 876 APFloat(APFloat &&RHS) = default; 877 878 ~APFloat() = default; 879 880 bool needsCleanup() const { APFLOAT_DISPATCH_ON_SEMANTICS(needsCleanup()); } 881 882 /// Factory for Positive and Negative Zero. 883 /// 884 /// \param Negative True iff the number should be negative. 885 static APFloat getZero(const fltSemantics &Sem, bool Negative = false) { 886 APFloat Val(Sem, uninitialized); 887 Val.makeZero(Negative); 888 return Val; 889 } 890 891 /// Factory for Positive and Negative Infinity. 892 /// 893 /// \param Negative True iff the number should be negative. 894 static APFloat getInf(const fltSemantics &Sem, bool Negative = false) { 895 APFloat Val(Sem, uninitialized); 896 Val.makeInf(Negative); 897 return Val; 898 } 899 900 /// Factory for NaN values. 901 /// 902 /// \param Negative - True iff the NaN generated should be negative. 903 /// \param payload - The unspecified fill bits for creating the NaN, 0 by 904 /// default. The value is truncated as necessary. 905 static APFloat getNaN(const fltSemantics &Sem, bool Negative = false, 906 uint64_t payload = 0) { 907 if (payload) { 908 APInt intPayload(64, payload); 909 return getQNaN(Sem, Negative, &intPayload); 910 } else { 911 return getQNaN(Sem, Negative, nullptr); 912 } 913 } 914 915 /// Factory for QNaN values. 916 static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false, 917 const APInt *payload = nullptr) { 918 APFloat Val(Sem, uninitialized); 919 Val.makeNaN(false, Negative, payload); 920 return Val; 921 } 922 923 /// Factory for SNaN values. 924 static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false, 925 const APInt *payload = nullptr) { 926 APFloat Val(Sem, uninitialized); 927 Val.makeNaN(true, Negative, payload); 928 return Val; 929 } 930 931 /// Returns the largest finite number in the given semantics. 932 /// 933 /// \param Negative - True iff the number should be negative 934 static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) { 935 APFloat Val(Sem, uninitialized); 936 Val.makeLargest(Negative); 937 return Val; 938 } 939 940 /// Returns the smallest (by magnitude) finite number in the given semantics. 941 /// Might be denormalized, which implies a relative loss of precision. 942 /// 943 /// \param Negative - True iff the number should be negative 944 static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) { 945 APFloat Val(Sem, uninitialized); 946 Val.makeSmallest(Negative); 947 return Val; 948 } 949 950 /// Returns the smallest (by magnitude) normalized finite number in the given 951 /// semantics. 952 /// 953 /// \param Negative - True iff the number should be negative 954 static APFloat getSmallestNormalized(const fltSemantics &Sem, 955 bool Negative = false) { 956 APFloat Val(Sem, uninitialized); 957 Val.makeSmallestNormalized(Negative); 958 return Val; 959 } 960 961 /// Returns a float which is bitcasted from an all one value int. 962 /// 963 /// \param Semantics - type float semantics 964 static APFloat getAllOnesValue(const fltSemantics &Semantics); 965 966 /// Used to insert APFloat objects, or objects that contain APFloat objects, 967 /// into FoldingSets. 968 void Profile(FoldingSetNodeID &NID) const; 969 970 opStatus add(const APFloat &RHS, roundingMode RM) { 971 assert(&getSemantics() == &RHS.getSemantics() && 972 "Should only call on two APFloats with the same semantics"); 973 if (usesLayout<IEEEFloat>(getSemantics())) 974 return U.IEEE.add(RHS.U.IEEE, RM); 975 if (usesLayout<DoubleAPFloat>(getSemantics())) 976 return U.Double.add(RHS.U.Double, RM); 977 llvm_unreachable("Unexpected semantics"); 978 } 979 opStatus subtract(const APFloat &RHS, roundingMode RM) { 980 assert(&getSemantics() == &RHS.getSemantics() && 981 "Should only call on two APFloats with the same semantics"); 982 if (usesLayout<IEEEFloat>(getSemantics())) 983 return U.IEEE.subtract(RHS.U.IEEE, RM); 984 if (usesLayout<DoubleAPFloat>(getSemantics())) 985 return U.Double.subtract(RHS.U.Double, RM); 986 llvm_unreachable("Unexpected semantics"); 987 } 988 opStatus multiply(const APFloat &RHS, roundingMode RM) { 989 assert(&getSemantics() == &RHS.getSemantics() && 990 "Should only call on two APFloats with the same semantics"); 991 if (usesLayout<IEEEFloat>(getSemantics())) 992 return U.IEEE.multiply(RHS.U.IEEE, RM); 993 if (usesLayout<DoubleAPFloat>(getSemantics())) 994 return U.Double.multiply(RHS.U.Double, RM); 995 llvm_unreachable("Unexpected semantics"); 996 } 997 opStatus divide(const APFloat &RHS, roundingMode RM) { 998 assert(&getSemantics() == &RHS.getSemantics() && 999 "Should only call on two APFloats with the same semantics"); 1000 if (usesLayout<IEEEFloat>(getSemantics())) 1001 return U.IEEE.divide(RHS.U.IEEE, RM); 1002 if (usesLayout<DoubleAPFloat>(getSemantics())) 1003 return U.Double.divide(RHS.U.Double, RM); 1004 llvm_unreachable("Unexpected semantics"); 1005 } 1006 opStatus remainder(const APFloat &RHS) { 1007 assert(&getSemantics() == &RHS.getSemantics() && 1008 "Should only call on two APFloats with the same semantics"); 1009 if (usesLayout<IEEEFloat>(getSemantics())) 1010 return U.IEEE.remainder(RHS.U.IEEE); 1011 if (usesLayout<DoubleAPFloat>(getSemantics())) 1012 return U.Double.remainder(RHS.U.Double); 1013 llvm_unreachable("Unexpected semantics"); 1014 } 1015 opStatus mod(const APFloat &RHS) { 1016 assert(&getSemantics() == &RHS.getSemantics() && 1017 "Should only call on two APFloats with the same semantics"); 1018 if (usesLayout<IEEEFloat>(getSemantics())) 1019 return U.IEEE.mod(RHS.U.IEEE); 1020 if (usesLayout<DoubleAPFloat>(getSemantics())) 1021 return U.Double.mod(RHS.U.Double); 1022 llvm_unreachable("Unexpected semantics"); 1023 } 1024 opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, 1025 roundingMode RM) { 1026 assert(&getSemantics() == &Multiplicand.getSemantics() && 1027 "Should only call on APFloats with the same semantics"); 1028 assert(&getSemantics() == &Addend.getSemantics() && 1029 "Should only call on APFloats with the same semantics"); 1030 if (usesLayout<IEEEFloat>(getSemantics())) 1031 return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM); 1032 if (usesLayout<DoubleAPFloat>(getSemantics())) 1033 return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double, 1034 RM); 1035 llvm_unreachable("Unexpected semantics"); 1036 } 1037 opStatus roundToIntegral(roundingMode RM) { 1038 APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM)); 1039 } 1040 1041 // TODO: bool parameters are not readable and a source of bugs. 1042 // Do something. 1043 opStatus next(bool nextDown) { 1044 APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown)); 1045 } 1046 1047 /// Negate an APFloat. 1048 APFloat operator-() const { 1049 APFloat Result(*this); 1050 Result.changeSign(); 1051 return Result; 1052 } 1053 1054 /// Add two APFloats, rounding ties to the nearest even. 1055 /// No error checking. 1056 APFloat operator+(const APFloat &RHS) const { 1057 APFloat Result(*this); 1058 (void)Result.add(RHS, rmNearestTiesToEven); 1059 return Result; 1060 } 1061 1062 /// Subtract two APFloats, rounding ties to the nearest even. 1063 /// No error checking. 1064 APFloat operator-(const APFloat &RHS) const { 1065 APFloat Result(*this); 1066 (void)Result.subtract(RHS, rmNearestTiesToEven); 1067 return Result; 1068 } 1069 1070 /// Multiply two APFloats, rounding ties to the nearest even. 1071 /// No error checking. 1072 APFloat operator*(const APFloat &RHS) const { 1073 APFloat Result(*this); 1074 (void)Result.multiply(RHS, rmNearestTiesToEven); 1075 return Result; 1076 } 1077 1078 /// Divide the first APFloat by the second, rounding ties to the nearest even. 1079 /// No error checking. 1080 APFloat operator/(const APFloat &RHS) const { 1081 APFloat Result(*this); 1082 (void)Result.divide(RHS, rmNearestTiesToEven); 1083 return Result; 1084 } 1085 1086 void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); } 1087 void clearSign() { 1088 if (isNegative()) 1089 changeSign(); 1090 } 1091 void copySign(const APFloat &RHS) { 1092 if (isNegative() != RHS.isNegative()) 1093 changeSign(); 1094 } 1095 1096 /// A static helper to produce a copy of an APFloat value with its sign 1097 /// copied from some other APFloat. 1098 static APFloat copySign(APFloat Value, const APFloat &Sign) { 1099 Value.copySign(Sign); 1100 return Value; 1101 } 1102 1103 opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, 1104 bool *losesInfo); 1105 opStatus convertToInteger(MutableArrayRef<integerPart> Input, 1106 unsigned int Width, bool IsSigned, roundingMode RM, 1107 bool *IsExact) const { 1108 APFLOAT_DISPATCH_ON_SEMANTICS( 1109 convertToInteger(Input, Width, IsSigned, RM, IsExact)); 1110 } 1111 opStatus convertToInteger(APSInt &Result, roundingMode RM, 1112 bool *IsExact) const; 1113 opStatus convertFromAPInt(const APInt &Input, bool IsSigned, 1114 roundingMode RM) { 1115 APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM)); 1116 } 1117 opStatus convertFromSignExtendedInteger(const integerPart *Input, 1118 unsigned int InputSize, bool IsSigned, 1119 roundingMode RM) { 1120 APFLOAT_DISPATCH_ON_SEMANTICS( 1121 convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM)); 1122 } 1123 opStatus convertFromZeroExtendedInteger(const integerPart *Input, 1124 unsigned int InputSize, bool IsSigned, 1125 roundingMode RM) { 1126 APFLOAT_DISPATCH_ON_SEMANTICS( 1127 convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM)); 1128 } 1129 Expected<opStatus> convertFromString(StringRef, roundingMode); 1130 APInt bitcastToAPInt() const { 1131 APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt()); 1132 } 1133 1134 /// Converts this APFloat to host double value. 1135 /// 1136 /// \pre The APFloat must be built using semantics, that can be represented by 1137 /// the host double type without loss of precision. It can be IEEEdouble and 1138 /// shorter semantics, like IEEEsingle and others. 1139 double convertToDouble() const; 1140 1141 /// Converts this APFloat to host float value. 1142 /// 1143 /// \pre The APFloat must be built using semantics, that can be represented by 1144 /// the host float type without loss of precision. It can be IEEEsingle and 1145 /// shorter semantics, like IEEEhalf. 1146 float convertToFloat() const; 1147 1148 bool operator==(const APFloat &RHS) const { return compare(RHS) == cmpEqual; } 1149 1150 bool operator!=(const APFloat &RHS) const { return compare(RHS) != cmpEqual; } 1151 1152 bool operator<(const APFloat &RHS) const { 1153 return compare(RHS) == cmpLessThan; 1154 } 1155 1156 bool operator>(const APFloat &RHS) const { 1157 return compare(RHS) == cmpGreaterThan; 1158 } 1159 1160 bool operator<=(const APFloat &RHS) const { 1161 cmpResult Res = compare(RHS); 1162 return Res == cmpLessThan || Res == cmpEqual; 1163 } 1164 1165 bool operator>=(const APFloat &RHS) const { 1166 cmpResult Res = compare(RHS); 1167 return Res == cmpGreaterThan || Res == cmpEqual; 1168 } 1169 1170 cmpResult compare(const APFloat &RHS) const { 1171 assert(&getSemantics() == &RHS.getSemantics() && 1172 "Should only compare APFloats with the same semantics"); 1173 if (usesLayout<IEEEFloat>(getSemantics())) 1174 return U.IEEE.compare(RHS.U.IEEE); 1175 if (usesLayout<DoubleAPFloat>(getSemantics())) 1176 return U.Double.compare(RHS.U.Double); 1177 llvm_unreachable("Unexpected semantics"); 1178 } 1179 1180 bool bitwiseIsEqual(const APFloat &RHS) const { 1181 if (&getSemantics() != &RHS.getSemantics()) 1182 return false; 1183 if (usesLayout<IEEEFloat>(getSemantics())) 1184 return U.IEEE.bitwiseIsEqual(RHS.U.IEEE); 1185 if (usesLayout<DoubleAPFloat>(getSemantics())) 1186 return U.Double.bitwiseIsEqual(RHS.U.Double); 1187 llvm_unreachable("Unexpected semantics"); 1188 } 1189 1190 /// We don't rely on operator== working on double values, as 1191 /// it returns true for things that are clearly not equal, like -0.0 and 0.0. 1192 /// As such, this method can be used to do an exact bit-for-bit comparison of 1193 /// two floating point values. 1194 /// 1195 /// We leave the version with the double argument here because it's just so 1196 /// convenient to write "2.0" and the like. Without this function we'd 1197 /// have to duplicate its logic everywhere it's called. 1198 bool isExactlyValue(double V) const { 1199 bool ignored; 1200 APFloat Tmp(V); 1201 Tmp.convert(getSemantics(), APFloat::rmNearestTiesToEven, &ignored); 1202 return bitwiseIsEqual(Tmp); 1203 } 1204 1205 unsigned int convertToHexString(char *DST, unsigned int HexDigits, 1206 bool UpperCase, roundingMode RM) const { 1207 APFLOAT_DISPATCH_ON_SEMANTICS( 1208 convertToHexString(DST, HexDigits, UpperCase, RM)); 1209 } 1210 1211 bool isZero() const { return getCategory() == fcZero; } 1212 bool isInfinity() const { return getCategory() == fcInfinity; } 1213 bool isNaN() const { return getCategory() == fcNaN; } 1214 1215 bool isNegative() const { return getIEEE().isNegative(); } 1216 bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); } 1217 bool isSignaling() const { return getIEEE().isSignaling(); } 1218 1219 bool isNormal() const { return !isDenormal() && isFiniteNonZero(); } 1220 bool isFinite() const { return !isNaN() && !isInfinity(); } 1221 1222 fltCategory getCategory() const { return getIEEE().getCategory(); } 1223 const fltSemantics &getSemantics() const { return *U.semantics; } 1224 bool isNonZero() const { return !isZero(); } 1225 bool isFiniteNonZero() const { return isFinite() && !isZero(); } 1226 bool isPosZero() const { return isZero() && !isNegative(); } 1227 bool isNegZero() const { return isZero() && isNegative(); } 1228 bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); } 1229 bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); } 1230 bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); } 1231 bool isIEEE() const { return usesLayout<IEEEFloat>(getSemantics()); } 1232 1233 APFloat &operator=(const APFloat &RHS) = default; 1234 APFloat &operator=(APFloat &&RHS) = default; 1235 1236 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0, 1237 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const { 1238 APFLOAT_DISPATCH_ON_SEMANTICS( 1239 toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero)); 1240 } 1241 1242 void print(raw_ostream &) const; 1243 void dump() const; 1244 1245 bool getExactInverse(APFloat *inv) const { 1246 APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv)); 1247 } 1248 1249 friend hash_code hash_value(const APFloat &Arg); 1250 friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); } 1251 friend APFloat scalbn(APFloat X, int Exp, roundingMode RM); 1252 friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM); 1253 friend IEEEFloat; 1254 friend DoubleAPFloat; 1255 }; 1256 1257 /// See friend declarations above. 1258 /// 1259 /// These additional declarations are required in order to compile LLVM with IBM 1260 /// xlC compiler. 1261 hash_code hash_value(const APFloat &Arg); 1262 inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) { 1263 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) 1264 return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics()); 1265 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) 1266 return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics()); 1267 llvm_unreachable("Unexpected semantics"); 1268 } 1269 1270 /// Equivalent of C standard library function. 1271 /// 1272 /// While the C standard says Exp is an unspecified value for infinity and nan, 1273 /// this returns INT_MAX for infinities, and INT_MIN for NaNs. 1274 inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) { 1275 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) 1276 return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics()); 1277 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) 1278 return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics()); 1279 llvm_unreachable("Unexpected semantics"); 1280 } 1281 /// Returns the absolute value of the argument. 1282 inline APFloat abs(APFloat X) { 1283 X.clearSign(); 1284 return X; 1285 } 1286 1287 /// Returns the negated value of the argument. 1288 inline APFloat neg(APFloat X) { 1289 X.changeSign(); 1290 return X; 1291 } 1292 1293 /// Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if 1294 /// both are not NaN. If either argument is a NaN, returns the other argument. 1295 LLVM_READONLY 1296 inline APFloat minnum(const APFloat &A, const APFloat &B) { 1297 if (A.isNaN()) 1298 return B; 1299 if (B.isNaN()) 1300 return A; 1301 return B < A ? B : A; 1302 } 1303 1304 /// Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if 1305 /// both are not NaN. If either argument is a NaN, returns the other argument. 1306 LLVM_READONLY 1307 inline APFloat maxnum(const APFloat &A, const APFloat &B) { 1308 if (A.isNaN()) 1309 return B; 1310 if (B.isNaN()) 1311 return A; 1312 return A < B ? B : A; 1313 } 1314 1315 /// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2 1316 /// arguments, propagating NaNs and treating -0 as less than +0. 1317 LLVM_READONLY 1318 inline APFloat minimum(const APFloat &A, const APFloat &B) { 1319 if (A.isNaN()) 1320 return A; 1321 if (B.isNaN()) 1322 return B; 1323 if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative())) 1324 return A.isNegative() ? A : B; 1325 return B < A ? B : A; 1326 } 1327 1328 /// Implements IEEE 754-2018 maximum semantics. Returns the larger of 2 1329 /// arguments, propagating NaNs and treating -0 as less than +0. 1330 LLVM_READONLY 1331 inline APFloat maximum(const APFloat &A, const APFloat &B) { 1332 if (A.isNaN()) 1333 return A; 1334 if (B.isNaN()) 1335 return B; 1336 if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative())) 1337 return A.isNegative() ? B : A; 1338 return A < B ? B : A; 1339 } 1340 1341 } // namespace llvm 1342 1343 #undef APFLOAT_DISPATCH_ON_SEMANTICS 1344 #endif // LLVM_ADT_APFLOAT_H 1345