1//===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// 10/// \file 11/// \brief 12/// This file declares a class to represent arbitrary precision floating point 13/// values and provide a variety of arithmetic operations on them. 14/// 15//===----------------------------------------------------------------------===// 16 17#ifndef LLVM_ADT_APFLOAT_H 18#define LLVM_ADT_APFLOAT_H 19 20#include "llvm/ADT/APInt.h" 21#include "llvm/ADT/ArrayRef.h" 22#include "llvm/Support/ErrorHandling.h" 23#include <memory> 24 25#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \ 26 do { \ 27 if (usesLayout<IEEEFloat>(getSemantics())) \ 28 return U.IEEE.METHOD_CALL; \ 29 if (usesLayout<DoubleAPFloat>(getSemantics())) \ 30 return U.Double.METHOD_CALL; \ 31 llvm_unreachable("Unexpected semantics"); \ 32 } while (false) 33 34namespace llvm { 35 36struct fltSemantics; 37class APSInt; 38class StringRef; 39class APFloat; 40class raw_ostream; 41 42template <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. 48enum 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. 142struct 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 224namespace detail { 225 226class IEEEFloat final : public APFloatBase { 227public: 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 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 bool isNegative() const { return sign; } 320 321 /// IEEE-754R isNormal: Returns true if and only if the current value is normal. 322 /// 323 /// This implies that the current value of the float is not zero, subnormal, 324 /// infinite, or NaN following the definition of normality from IEEE-754R. 325 bool isNormal() const { return !isDenormal() && isFiniteNonZero(); } 326 327 /// Returns true if and only if the current value is zero, subnormal, or 328 /// normal. 329 /// 330 /// This means that the value is not infinite or NaN. 331 bool isFinite() const { return !isNaN() && !isInfinity(); } 332 333 /// Returns true if and only if the float is plus or minus zero. 334 bool isZero() const { return category == fcZero; } 335 336 /// IEEE-754R isSubnormal(): Returns true if and only if the float is a 337 /// denormal. 338 bool isDenormal() const; 339 340 /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity. 341 bool isInfinity() const { return category == fcInfinity; } 342 343 /// Returns true if and only if the float is a quiet or signaling NaN. 344 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 fltCategory getCategory() const { return category; } 355 const fltSemantics &getSemantics() const { return *semantics; } 356 bool isNonZero() const { return category != fcZero; } 357 bool isFiniteNonZero() const { return isFinite() && !isZero(); } 358 bool isPosZero() const { return isZero() && !isNegative(); } 359 bool isNegZero() const { return isZero() && isNegative(); } 360 361 /// Returns true if and only if the number has the smallest possible non-zero 362 /// magnitude in the current semantics. 363 bool isSmallest() const; 364 365 /// Returns true if and only if the number has the largest possible finite 366 /// magnitude in the current semantics. 367 bool isLargest() const; 368 369 /// Returns true if and only if the number is an exact integer. 370 bool isInteger() const; 371 372 /// @} 373 374 IEEEFloat &operator=(const IEEEFloat &); 375 IEEEFloat &operator=(IEEEFloat &&); 376 377 /// Overload to compute a hash code for an APFloat value. 378 /// 379 /// Note that the use of hash codes for floating point values is in general 380 /// frought with peril. Equality is hard to define for these values. For 381 /// example, should negative and positive zero hash to different codes? Are 382 /// they equal or not? This hash value implementation specifically 383 /// emphasizes producing different codes for different inputs in order to 384 /// be used in canonicalization and memoization. As such, equality is 385 /// bitwiseIsEqual, and 0 != -0. 386 friend hash_code hash_value(const IEEEFloat &Arg); 387 388 /// Converts this value into a decimal string. 389 /// 390 /// \param FormatPrecision The maximum number of digits of 391 /// precision to output. If there are fewer digits available, 392 /// zero padding will not be used unless the value is 393 /// integral and small enough to be expressed in 394 /// FormatPrecision digits. 0 means to use the natural 395 /// precision of the number. 396 /// \param FormatMaxPadding The maximum number of zeros to 397 /// consider inserting before falling back to scientific 398 /// notation. 0 means to always use scientific notation. 399 /// 400 /// \param TruncateZero Indicate whether to remove the trailing zero in 401 /// fraction part or not. Also setting this parameter to false forcing 402 /// producing of output more similar to default printf behavior. 403 /// Specifically the lower e is used as exponent delimiter and exponent 404 /// always contains no less than two digits. 405 /// 406 /// Number Precision MaxPadding Result 407 /// ------ --------- ---------- ------ 408 /// 1.01E+4 5 2 10100 409 /// 1.01E+4 4 2 1.01E+4 410 /// 1.01E+4 5 1 1.01E+4 411 /// 1.01E-2 5 2 0.0101 412 /// 1.01E-2 4 2 0.0101 413 /// 1.01E-2 4 1 1.01E-2 414 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0, 415 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const; 416 417 /// If this value has an exact multiplicative inverse, store it in inv and 418 /// return true. 419 bool getExactInverse(APFloat *inv) const; 420 421 /// Returns the exponent of the internal representation of the APFloat. 422 /// 423 /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)). 424 /// For special APFloat values, this returns special error codes: 425 /// 426 /// NaN -> \c IEK_NaN 427 /// 0 -> \c IEK_Zero 428 /// Inf -> \c IEK_Inf 429 /// 430 friend int ilogb(const IEEEFloat &Arg); 431 432 /// Returns: X * 2^Exp for integral exponents. 433 friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode); 434 435 friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode); 436 437 /// \name Special value setters. 438 /// @{ 439 440 void makeLargest(bool Neg = false); 441 void makeSmallest(bool Neg = false); 442 void makeNaN(bool SNaN = false, bool Neg = false, 443 const APInt *fill = nullptr); 444 void makeInf(bool Neg = false); 445 void makeZero(bool Neg = false); 446 void makeQuiet(); 447 448 /// Returns the smallest (by magnitude) normalized finite number in the given 449 /// semantics. 450 /// 451 /// \param Negative - True iff the number should be negative 452 void makeSmallestNormalized(bool Negative = false); 453 454 /// @} 455 456 cmpResult compareAbsoluteValue(const IEEEFloat &) const; 457 458private: 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 565hash_code hash_value(const IEEEFloat &Arg); 566int ilogb(const IEEEFloat &Arg); 567IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode); 568IEEEFloat 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. 574class 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 585public: 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 DoubleAPFloat &operator=(DoubleAPFloat &&RHS) { 597 if (this != &RHS) { 598 this->~DoubleAPFloat(); 599 new (this) DoubleAPFloat(std::move(RHS)); 600 } 601 return *this; 602 } 603 604 bool needsCleanup() const { return Floats != nullptr; } 605 606 APFloat &getFirst() { return Floats[0]; } 607 const APFloat &getFirst() const { return Floats[0]; } 608 APFloat &getSecond() { return Floats[1]; } 609 const APFloat &getSecond() const { return Floats[1]; } 610 611 opStatus add(const DoubleAPFloat &RHS, roundingMode RM); 612 opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM); 613 opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM); 614 opStatus divide(const DoubleAPFloat &RHS, roundingMode RM); 615 opStatus remainder(const DoubleAPFloat &RHS); 616 opStatus mod(const DoubleAPFloat &RHS); 617 opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand, 618 const DoubleAPFloat &Addend, roundingMode RM); 619 opStatus roundToIntegral(roundingMode RM); 620 void changeSign(); 621 cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const; 622 623 fltCategory getCategory() const; 624 bool isNegative() const; 625 626 void makeInf(bool Neg); 627 void makeZero(bool Neg); 628 void makeLargest(bool Neg); 629 void makeSmallest(bool Neg); 630 void makeSmallestNormalized(bool Neg); 631 void makeNaN(bool SNaN, bool Neg, const APInt *fill); 632 633 cmpResult compare(const DoubleAPFloat &RHS) const; 634 bool bitwiseIsEqual(const DoubleAPFloat &RHS) const; 635 APInt bitcastToAPInt() const; 636 opStatus convertFromString(StringRef, roundingMode); 637 opStatus next(bool nextDown); 638 639 opStatus convertToInteger(MutableArrayRef<integerPart> Input, 640 unsigned int Width, bool IsSigned, roundingMode RM, 641 bool *IsExact) const; 642 opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM); 643 opStatus convertFromSignExtendedInteger(const integerPart *Input, 644 unsigned int InputSize, bool IsSigned, 645 roundingMode RM); 646 opStatus convertFromZeroExtendedInteger(const integerPart *Input, 647 unsigned int InputSize, bool IsSigned, 648 roundingMode RM); 649 unsigned int convertToHexString(char *DST, unsigned int HexDigits, 650 bool UpperCase, roundingMode RM) const; 651 652 bool isDenormal() const; 653 bool isSmallest() const; 654 bool isLargest() const; 655 bool isInteger() const; 656 657 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision, 658 unsigned FormatMaxPadding, bool TruncateZero = true) const; 659 660 bool getExactInverse(APFloat *inv) const; 661 662 friend int ilogb(const DoubleAPFloat &Arg); 663 friend DoubleAPFloat scalbn(DoubleAPFloat X, int Exp, roundingMode); 664 friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode); 665 friend hash_code hash_value(const DoubleAPFloat &Arg); 666}; 667 668hash_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. 674class 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 : Double(std::move(F)) { 688 assert(&S == &PPCDoubleDouble()); 689 } 690 691 template <typename... ArgTypes> 692 Storage(const fltSemantics &Semantics, ArgTypes &&... Args) { 693 if (usesLayout<IEEEFloat>(Semantics)) { 694 new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...); 695 return; 696 } 697 if (usesLayout<DoubleAPFloat>(Semantics)) { 698 new (&Double) DoubleAPFloat(Semantics, std::forward<ArgTypes>(Args)...); 699 return; 700 } 701 llvm_unreachable("Unexpected semantics"); 702 } 703 704 ~Storage() { 705 if (usesLayout<IEEEFloat>(*semantics)) { 706 IEEE.~IEEEFloat(); 707 return; 708 } 709 if (usesLayout<DoubleAPFloat>(*semantics)) { 710 Double.~DoubleAPFloat(); 711 return; 712 } 713 llvm_unreachable("Unexpected semantics"); 714 } 715 716 Storage(const Storage &RHS) { 717 if (usesLayout<IEEEFloat>(*RHS.semantics)) { 718 new (this) IEEEFloat(RHS.IEEE); 719 return; 720 } 721 if (usesLayout<DoubleAPFloat>(*RHS.semantics)) { 722 new (this) DoubleAPFloat(RHS.Double); 723 return; 724 } 725 llvm_unreachable("Unexpected semantics"); 726 } 727 728 Storage(Storage &&RHS) { 729 if (usesLayout<IEEEFloat>(*RHS.semantics)) { 730 new (this) IEEEFloat(std::move(RHS.IEEE)); 731 return; 732 } 733 if (usesLayout<DoubleAPFloat>(*RHS.semantics)) { 734 new (this) DoubleAPFloat(std::move(RHS.Double)); 735 return; 736 } 737 llvm_unreachable("Unexpected semantics"); 738 } 739 740 Storage &operator=(const Storage &RHS) { 741 if (usesLayout<IEEEFloat>(*semantics) && 742 usesLayout<IEEEFloat>(*RHS.semantics)) { 743 IEEE = RHS.IEEE; 744 } else if (usesLayout<DoubleAPFloat>(*semantics) && 745 usesLayout<DoubleAPFloat>(*RHS.semantics)) { 746 Double = RHS.Double; 747 } else if (this != &RHS) { 748 this->~Storage(); 749 new (this) Storage(RHS); 750 } 751 return *this; 752 } 753 754 Storage &operator=(Storage &&RHS) { 755 if (usesLayout<IEEEFloat>(*semantics) && 756 usesLayout<IEEEFloat>(*RHS.semantics)) { 757 IEEE = std::move(RHS.IEEE); 758 } else if (usesLayout<DoubleAPFloat>(*semantics) && 759 usesLayout<DoubleAPFloat>(*RHS.semantics)) { 760 Double = std::move(RHS.Double); 761 } else if (this != &RHS) { 762 this->~Storage(); 763 new (this) Storage(std::move(RHS)); 764 } 765 return *this; 766 } 767 } U; 768 769 template <typename T> static bool usesLayout(const fltSemantics &Semantics) { 770 static_assert(std::is_same<T, IEEEFloat>::value || 771 std::is_same<T, DoubleAPFloat>::value, ""); 772 if (std::is_same<T, DoubleAPFloat>::value) { 773 return &Semantics == &PPCDoubleDouble(); 774 } 775 return &Semantics != &PPCDoubleDouble(); 776 } 777 778 IEEEFloat &getIEEE() { 779 if (usesLayout<IEEEFloat>(*U.semantics)) 780 return U.IEEE; 781 if (usesLayout<DoubleAPFloat>(*U.semantics)) 782 return U.Double.getFirst().U.IEEE; 783 llvm_unreachable("Unexpected semantics"); 784 } 785 786 const IEEEFloat &getIEEE() const { 787 if (usesLayout<IEEEFloat>(*U.semantics)) 788 return U.IEEE; 789 if (usesLayout<DoubleAPFloat>(*U.semantics)) 790 return U.Double.getFirst().U.IEEE; 791 llvm_unreachable("Unexpected semantics"); 792 } 793 794 void makeZero(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeZero(Neg)); } 795 796 void makeInf(bool Neg) { APFLOAT_DISPATCH_ON_SEMANTICS(makeInf(Neg)); } 797 798 void makeNaN(bool SNaN, bool Neg, const APInt *fill) { 799 APFLOAT_DISPATCH_ON_SEMANTICS(makeNaN(SNaN, Neg, fill)); 800 } 801 802 void makeLargest(bool Neg) { 803 APFLOAT_DISPATCH_ON_SEMANTICS(makeLargest(Neg)); 804 } 805 806 void makeSmallest(bool Neg) { 807 APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg)); 808 } 809 810 void makeSmallestNormalized(bool Neg) { 811 APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallestNormalized(Neg)); 812 } 813 814 // FIXME: This is due to clang 3.3 (or older version) always checks for the 815 // default constructor in an array aggregate initialization, even if no 816 // elements in the array is default initialized. 817 APFloat() : U(IEEEdouble()) { 818 llvm_unreachable("This is a workaround for old clang."); 819 } 820 821 explicit APFloat(IEEEFloat F, const fltSemantics &S) : U(std::move(F), S) {} 822 explicit APFloat(DoubleAPFloat F, const fltSemantics &S) 823 : U(std::move(F), S) {} 824 825 cmpResult compareAbsoluteValue(const APFloat &RHS) const { 826 assert(&getSemantics() == &RHS.getSemantics() && 827 "Should only compare APFloats with the same semantics"); 828 if (usesLayout<IEEEFloat>(getSemantics())) 829 return U.IEEE.compareAbsoluteValue(RHS.U.IEEE); 830 if (usesLayout<DoubleAPFloat>(getSemantics())) 831 return U.Double.compareAbsoluteValue(RHS.U.Double); 832 llvm_unreachable("Unexpected semantics"); 833 } 834 835public: 836 APFloat(const fltSemantics &Semantics) : U(Semantics) {} 837 APFloat(const fltSemantics &Semantics, StringRef S); 838 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 : U(Semantics, uninitialized) {} 842 APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {} 843 explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {} 844 explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {} 845 APFloat(const APFloat &RHS) = default; 846 APFloat(APFloat &&RHS) = default; 847 848 ~APFloat() = default; 849 850 bool needsCleanup() const { APFLOAT_DISPATCH_ON_SEMANTICS(needsCleanup()); } 851 852 /// Factory for Positive and Negative Zero. 853 /// 854 /// \param Negative True iff the number should be negative. 855 static APFloat getZero(const fltSemantics &Sem, bool Negative = false) { 856 APFloat Val(Sem, uninitialized); 857 Val.makeZero(Negative); 858 return Val; 859 } 860 861 /// Factory for Positive and Negative Infinity. 862 /// 863 /// \param Negative True iff the number should be negative. 864 static APFloat getInf(const fltSemantics &Sem, bool Negative = false) { 865 APFloat Val(Sem, uninitialized); 866 Val.makeInf(Negative); 867 return Val; 868 } 869 870 /// Factory for NaN values. 871 /// 872 /// \param Negative - True iff the NaN generated should be negative. 873 /// \param type - The unspecified fill bits for creating the NaN, 0 by 874 /// default. The value is truncated as necessary. 875 static APFloat getNaN(const fltSemantics &Sem, bool Negative = false, 876 unsigned type = 0) { 877 if (type) { 878 APInt fill(64, type); 879 return getQNaN(Sem, Negative, &fill); 880 } else { 881 return getQNaN(Sem, Negative, nullptr); 882 } 883 } 884 885 /// Factory for QNaN values. 886 static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false, 887 const APInt *payload = nullptr) { 888 APFloat Val(Sem, uninitialized); 889 Val.makeNaN(false, Negative, payload); 890 return Val; 891 } 892 893 /// Factory for SNaN values. 894 static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false, 895 const APInt *payload = nullptr) { 896 APFloat Val(Sem, uninitialized); 897 Val.makeNaN(true, Negative, payload); 898 return Val; 899 } 900 901 /// Returns the largest finite number in the given semantics. 902 /// 903 /// \param Negative - True iff the number should be negative 904 static APFloat getLargest(const fltSemantics &Sem, bool Negative = false) { 905 APFloat Val(Sem, uninitialized); 906 Val.makeLargest(Negative); 907 return Val; 908 } 909 910 /// Returns the smallest (by magnitude) finite number in the given semantics. 911 /// Might be denormalized, which implies a relative loss of precision. 912 /// 913 /// \param Negative - True iff the number should be negative 914 static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false) { 915 APFloat Val(Sem, uninitialized); 916 Val.makeSmallest(Negative); 917 return Val; 918 } 919 920 /// Returns the smallest (by magnitude) normalized finite number in the given 921 /// semantics. 922 /// 923 /// \param Negative - True iff the number should be negative 924 static APFloat getSmallestNormalized(const fltSemantics &Sem, 925 bool Negative = false) { 926 APFloat Val(Sem, uninitialized); 927 Val.makeSmallestNormalized(Negative); 928 return Val; 929 } 930 931 /// Returns a float which is bitcasted from an all one value int. 932 /// 933 /// \param BitWidth - Select float type 934 /// \param isIEEE - If 128 bit number, select between PPC and IEEE 935 static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false); 936 937 /// Used to insert APFloat objects, or objects that contain APFloat objects, 938 /// into FoldingSets. 939 void Profile(FoldingSetNodeID &NID) const; 940 941 opStatus add(const APFloat &RHS, roundingMode RM) { 942 assert(&getSemantics() == &RHS.getSemantics() && 943 "Should only call on two APFloats with the same semantics"); 944 if (usesLayout<IEEEFloat>(getSemantics())) 945 return U.IEEE.add(RHS.U.IEEE, RM); 946 if (usesLayout<DoubleAPFloat>(getSemantics())) 947 return U.Double.add(RHS.U.Double, RM); 948 llvm_unreachable("Unexpected semantics"); 949 } 950 opStatus subtract(const APFloat &RHS, roundingMode RM) { 951 assert(&getSemantics() == &RHS.getSemantics() && 952 "Should only call on two APFloats with the same semantics"); 953 if (usesLayout<IEEEFloat>(getSemantics())) 954 return U.IEEE.subtract(RHS.U.IEEE, RM); 955 if (usesLayout<DoubleAPFloat>(getSemantics())) 956 return U.Double.subtract(RHS.U.Double, RM); 957 llvm_unreachable("Unexpected semantics"); 958 } 959 opStatus multiply(const APFloat &RHS, roundingMode RM) { 960 assert(&getSemantics() == &RHS.getSemantics() && 961 "Should only call on two APFloats with the same semantics"); 962 if (usesLayout<IEEEFloat>(getSemantics())) 963 return U.IEEE.multiply(RHS.U.IEEE, RM); 964 if (usesLayout<DoubleAPFloat>(getSemantics())) 965 return U.Double.multiply(RHS.U.Double, RM); 966 llvm_unreachable("Unexpected semantics"); 967 } 968 opStatus divide(const APFloat &RHS, roundingMode RM) { 969 assert(&getSemantics() == &RHS.getSemantics() && 970 "Should only call on two APFloats with the same semantics"); 971 if (usesLayout<IEEEFloat>(getSemantics())) 972 return U.IEEE.divide(RHS.U.IEEE, RM); 973 if (usesLayout<DoubleAPFloat>(getSemantics())) 974 return U.Double.divide(RHS.U.Double, RM); 975 llvm_unreachable("Unexpected semantics"); 976 } 977 opStatus remainder(const APFloat &RHS) { 978 assert(&getSemantics() == &RHS.getSemantics() && 979 "Should only call on two APFloats with the same semantics"); 980 if (usesLayout<IEEEFloat>(getSemantics())) 981 return U.IEEE.remainder(RHS.U.IEEE); 982 if (usesLayout<DoubleAPFloat>(getSemantics())) 983 return U.Double.remainder(RHS.U.Double); 984 llvm_unreachable("Unexpected semantics"); 985 } 986 opStatus mod(const APFloat &RHS) { 987 assert(&getSemantics() == &RHS.getSemantics() && 988 "Should only call on two APFloats with the same semantics"); 989 if (usesLayout<IEEEFloat>(getSemantics())) 990 return U.IEEE.mod(RHS.U.IEEE); 991 if (usesLayout<DoubleAPFloat>(getSemantics())) 992 return U.Double.mod(RHS.U.Double); 993 llvm_unreachable("Unexpected semantics"); 994 } 995 opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, 996 roundingMode RM) { 997 assert(&getSemantics() == &Multiplicand.getSemantics() && 998 "Should only call on APFloats with the same semantics"); 999 assert(&getSemantics() == &Addend.getSemantics() && 1000 "Should only call on APFloats with the same semantics"); 1001 if (usesLayout<IEEEFloat>(getSemantics())) 1002 return U.IEEE.fusedMultiplyAdd(Multiplicand.U.IEEE, Addend.U.IEEE, RM); 1003 if (usesLayout<DoubleAPFloat>(getSemantics())) 1004 return U.Double.fusedMultiplyAdd(Multiplicand.U.Double, Addend.U.Double, 1005 RM); 1006 llvm_unreachable("Unexpected semantics"); 1007 } 1008 opStatus roundToIntegral(roundingMode RM) { 1009 APFLOAT_DISPATCH_ON_SEMANTICS(roundToIntegral(RM)); 1010 } 1011 1012 // TODO: bool parameters are not readable and a source of bugs. 1013 // Do something. 1014 opStatus next(bool nextDown) { 1015 APFLOAT_DISPATCH_ON_SEMANTICS(next(nextDown)); 1016 } 1017 1018 /// Add two APFloats, rounding ties to the nearest even. 1019 /// No error checking. 1020 APFloat operator+(const APFloat &RHS) const { 1021 APFloat Result(*this); 1022 (void)Result.add(RHS, rmNearestTiesToEven); 1023 return Result; 1024 } 1025 1026 /// Subtract two APFloats, rounding ties to the nearest even. 1027 /// No error checking. 1028 APFloat operator-(const APFloat &RHS) const { 1029 APFloat Result(*this); 1030 (void)Result.subtract(RHS, rmNearestTiesToEven); 1031 return Result; 1032 } 1033 1034 /// Multiply two APFloats, rounding ties to the nearest even. 1035 /// No error checking. 1036 APFloat operator*(const APFloat &RHS) const { 1037 APFloat Result(*this); 1038 (void)Result.multiply(RHS, rmNearestTiesToEven); 1039 return Result; 1040 } 1041 1042 /// Divide the first APFloat by the second, rounding ties to the nearest even. 1043 /// No error checking. 1044 APFloat operator/(const APFloat &RHS) const { 1045 APFloat Result(*this); 1046 (void)Result.divide(RHS, rmNearestTiesToEven); 1047 return Result; 1048 } 1049 1050 void changeSign() { APFLOAT_DISPATCH_ON_SEMANTICS(changeSign()); } 1051 void clearSign() { 1052 if (isNegative()) 1053 changeSign(); 1054 } 1055 void copySign(const APFloat &RHS) { 1056 if (isNegative() != RHS.isNegative()) 1057 changeSign(); 1058 } 1059 1060 /// A static helper to produce a copy of an APFloat value with its sign 1061 /// copied from some other APFloat. 1062 static APFloat copySign(APFloat Value, const APFloat &Sign) { 1063 Value.copySign(Sign); 1064 return Value; 1065 } 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 bool *IsExact) const { 1072 APFLOAT_DISPATCH_ON_SEMANTICS( 1073 convertToInteger(Input, Width, IsSigned, RM, IsExact)); 1074 } 1075 opStatus convertToInteger(APSInt &Result, roundingMode RM, 1076 bool *IsExact) const; 1077 opStatus convertFromAPInt(const APInt &Input, bool IsSigned, 1078 roundingMode RM) { 1079 APFLOAT_DISPATCH_ON_SEMANTICS(convertFromAPInt(Input, IsSigned, RM)); 1080 } 1081 opStatus convertFromSignExtendedInteger(const integerPart *Input, 1082 unsigned int InputSize, bool IsSigned, 1083 roundingMode RM) { 1084 APFLOAT_DISPATCH_ON_SEMANTICS( 1085 convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM)); 1086 } 1087 opStatus convertFromZeroExtendedInteger(const integerPart *Input, 1088 unsigned int InputSize, bool IsSigned, 1089 roundingMode RM) { 1090 APFLOAT_DISPATCH_ON_SEMANTICS( 1091 convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM)); 1092 } 1093 opStatus convertFromString(StringRef, roundingMode); 1094 APInt bitcastToAPInt() const { 1095 APFLOAT_DISPATCH_ON_SEMANTICS(bitcastToAPInt()); 1096 } 1097 double convertToDouble() const { return getIEEE().convertToDouble(); } 1098 float convertToFloat() const { return getIEEE().convertToFloat(); } 1099 1100 bool operator==(const APFloat &) const = delete; 1101 1102 cmpResult compare(const APFloat &RHS) const { 1103 assert(&getSemantics() == &RHS.getSemantics() && 1104 "Should only compare APFloats with the same semantics"); 1105 if (usesLayout<IEEEFloat>(getSemantics())) 1106 return U.IEEE.compare(RHS.U.IEEE); 1107 if (usesLayout<DoubleAPFloat>(getSemantics())) 1108 return U.Double.compare(RHS.U.Double); 1109 llvm_unreachable("Unexpected semantics"); 1110 } 1111 1112 bool bitwiseIsEqual(const APFloat &RHS) const { 1113 if (&getSemantics() != &RHS.getSemantics()) 1114 return false; 1115 if (usesLayout<IEEEFloat>(getSemantics())) 1116 return U.IEEE.bitwiseIsEqual(RHS.U.IEEE); 1117 if (usesLayout<DoubleAPFloat>(getSemantics())) 1118 return U.Double.bitwiseIsEqual(RHS.U.Double); 1119 llvm_unreachable("Unexpected semantics"); 1120 } 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 bool isExactlyValue(double V) const { 1131 bool ignored; 1132 APFloat Tmp(V); 1133 Tmp.convert(getSemantics(), APFloat::rmNearestTiesToEven, &ignored); 1134 return bitwiseIsEqual(Tmp); 1135 } 1136 1137 unsigned int convertToHexString(char *DST, unsigned int HexDigits, 1138 bool UpperCase, roundingMode RM) const { 1139 APFLOAT_DISPATCH_ON_SEMANTICS( 1140 convertToHexString(DST, HexDigits, UpperCase, RM)); 1141 } 1142 1143 bool isZero() const { return getCategory() == fcZero; } 1144 bool isInfinity() const { return getCategory() == fcInfinity; } 1145 bool isNaN() const { return getCategory() == fcNaN; } 1146 1147 bool isNegative() const { return getIEEE().isNegative(); } 1148 bool isDenormal() const { APFLOAT_DISPATCH_ON_SEMANTICS(isDenormal()); } 1149 bool isSignaling() const { return getIEEE().isSignaling(); } 1150 1151 bool isNormal() const { return !isDenormal() && isFiniteNonZero(); } 1152 bool isFinite() const { return !isNaN() && !isInfinity(); } 1153 1154 fltCategory getCategory() const { return getIEEE().getCategory(); } 1155 const fltSemantics &getSemantics() const { return *U.semantics; } 1156 bool isNonZero() const { return !isZero(); } 1157 bool isFiniteNonZero() const { return isFinite() && !isZero(); } 1158 bool isPosZero() const { return isZero() && !isNegative(); } 1159 bool isNegZero() const { return isZero() && isNegative(); } 1160 bool isSmallest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isSmallest()); } 1161 bool isLargest() const { APFLOAT_DISPATCH_ON_SEMANTICS(isLargest()); } 1162 bool isInteger() const { APFLOAT_DISPATCH_ON_SEMANTICS(isInteger()); } 1163 1164 APFloat &operator=(const APFloat &RHS) = default; 1165 APFloat &operator=(APFloat &&RHS) = default; 1166 1167 void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0, 1168 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const { 1169 APFLOAT_DISPATCH_ON_SEMANTICS( 1170 toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero)); 1171 } 1172 1173 void print(raw_ostream &) const; 1174 void dump() const; 1175 1176 bool getExactInverse(APFloat *inv) const { 1177 APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv)); 1178 } 1179 1180 friend hash_code hash_value(const APFloat &Arg); 1181 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. 1192hash_code hash_value(const APFloat &Arg); 1193inline APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM) { 1194 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) 1195 return APFloat(scalbn(X.U.IEEE, Exp, RM), X.getSemantics()); 1196 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) 1197 return APFloat(scalbn(X.U.Double, Exp, RM), X.getSemantics()); 1198 llvm_unreachable("Unexpected semantics"); 1199} 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. 1205inline APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM) { 1206 if (APFloat::usesLayout<detail::IEEEFloat>(X.getSemantics())) 1207 return APFloat(frexp(X.U.IEEE, Exp, RM), X.getSemantics()); 1208 if (APFloat::usesLayout<detail::DoubleAPFloat>(X.getSemantics())) 1209 return APFloat(frexp(X.U.Double, Exp, RM), X.getSemantics()); 1210 llvm_unreachable("Unexpected semantics"); 1211} 1212/// Returns the absolute value of the argument. 1213inline APFloat abs(APFloat X) { 1214 X.clearSign(); 1215 return X; 1216} 1217 1218/// \brief Returns the negated value of the argument. 1219inline APFloat neg(APFloat X) { 1220 X.changeSign(); 1221 return X; 1222} 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. 1226LLVM_READONLY 1227inline APFloat minnum(const APFloat &A, const APFloat &B) { 1228 if (A.isNaN()) 1229 return B; 1230 if (B.isNaN()) 1231 return A; 1232 return (B.compare(A) == APFloat::cmpLessThan) ? B : A; 1233} 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. 1237LLVM_READONLY 1238inline APFloat maxnum(const APFloat &A, const APFloat &B) { 1239 if (A.isNaN()) 1240 return B; 1241 if (B.isNaN()) 1242 return A; 1243 return (A.compare(B) == APFloat::cmpLessThan) ? B : A; 1244} 1245 1246} // namespace llvm 1247 1248#undef APFLOAT_DISPATCH_ON_SEMANTICS 1249#endif // LLVM_ADT_APFLOAT_H 1250