1 | //===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==// |
---|---|

2 | // |

3 | // The LLVM Compiler Infrastructure |

4 | // |

5 | // This file is distributed under the University of Illinois Open Source |

6 | // License. See LICENSE.TXT for details. |

7 | // |

8 | //===----------------------------------------------------------------------===// |

9 | /// |

10 | /// \file |

11 | /// \brief |

12 | /// This file declares a class to represent arbitrary precision floating point |

13 | /// values and provide a variety of arithmetic operations on them. |

14 | /// |

15 | //===----------------------------------------------------------------------===// |

16 | |

17 | #ifndef LLVM_ADT_APFLOAT_H |

18 | #define LLVM_ADT_APFLOAT_H |

19 | |

20 | #include "llvm/ADT/APInt.h" |

21 | #include "llvm/ADT/ArrayRef.h" |

22 | #include "llvm/Support/ErrorHandling.h" |

23 | #include <memory> |

24 | |

25 | #define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \ |

26 | do { \ |

27 | if (usesLayout<IEEEFloat>(getSemantics())) \ |

28 | return U.IEEE.METHOD_CALL; \ |

29 | if (usesLayout<DoubleAPFloat>(getSemantics())) \ |

30 | return U.Double.METHOD_CALL; \ |

31 | llvm_unreachable("Unexpected semantics"); \ |

32 | } while (false) |

33 | |

34 | namespace llvm { |

35 | |

36 | struct fltSemantics; |

37 | class APSInt; |

38 | class StringRef; |

39 | class APFloat; |

40 | class raw_ostream; |

41 | |

42 | template <typename T> class SmallVectorImpl; |

43 | |

44 | /// Enum that represents what fraction of the LSB truncated bits of an fp number |

45 | /// represent. |

46 | /// |

47 | /// This essentially combines the roles of guard and sticky bits. |

48 | enum lostFraction { // Example of truncated bits: |

49 | lfExactlyZero, // 000000 |

50 | lfLessThanHalf, // 0xxxxx x's not all zero |

51 | lfExactlyHalf, // 100000 |

52 | lfMoreThanHalf // 1xxxxx x's not all zero |

53 | }; |

54 | |

55 | /// A self-contained host- and target-independent arbitrary-precision |

56 | /// floating-point software implementation. |

57 | /// |

58 | /// APFloat uses bignum integer arithmetic as provided by static functions in |

59 | /// the APInt class. The library will work with bignum integers whose parts are |

60 | /// any unsigned type at least 16 bits wide, but 64 bits is recommended. |

61 | /// |

62 | /// Written for clarity rather than speed, in particular with a view to use in |

63 | /// the front-end of a cross compiler so that target arithmetic can be correctly |

64 | /// performed on the host. Performance should nonetheless be reasonable, |

65 | /// particularly for its intended use. It may be useful as a base |

66 | /// implementation for a run-time library during development of a faster |

67 | /// target-specific one. |

68 | /// |

69 | /// All 5 rounding modes in the IEEE-754R draft are handled correctly for all |

70 | /// implemented operations. Currently implemented operations are add, subtract, |

71 | /// multiply, divide, fused-multiply-add, conversion-to-float, |

72 | /// conversion-to-integer and conversion-from-integer. New rounding modes |

73 | /// (e.g. away from zero) can be added with three or four lines of code. |

74 | /// |

75 | /// Four formats are built-in: IEEE single precision, double precision, |

76 | /// quadruple precision, and x87 80-bit extended double (when operating with |

77 | /// full extended precision). Adding a new format that obeys IEEE semantics |

78 | /// only requires adding two lines of code: a declaration and definition of the |

79 | /// format. |

80 | /// |

81 | /// All operations return the status of that operation as an exception bit-mask, |

82 | /// so multiple operations can be done consecutively with their results or-ed |

83 | /// together. The returned status can be useful for compiler diagnostics; e.g., |

84 | /// inexact, underflow and overflow can be easily diagnosed on constant folding, |

85 | /// and compiler optimizers can determine what exceptions would be raised by |

86 | /// folding operations and optimize, or perhaps not optimize, accordingly. |

87 | /// |

88 | /// At present, underflow tininess is detected after rounding; it should be |

89 | /// straight forward to add support for the before-rounding case too. |

90 | /// |

91 | /// The library reads hexadecimal floating point numbers as per C99, and |

92 | /// correctly rounds if necessary according to the specified rounding mode. |

93 | /// Syntax is required to have been validated by the caller. It also converts |

94 | /// floating point numbers to hexadecimal text as per the C99 %a and %A |

95 | /// conversions. The output precision (or alternatively the natural minimal |

96 | /// precision) can be specified; if the requested precision is less than the |

97 | /// natural precision the output is correctly rounded for the specified rounding |

98 | /// mode. |

99 | /// |

100 | /// It also reads decimal floating point numbers and correctly rounds according |

101 | /// to the specified rounding mode. |

102 | /// |

103 | /// Conversion to decimal text is not currently implemented. |

104 | /// |

105 | /// Non-zero finite numbers are represented internally as a sign bit, a 16-bit |

106 | /// signed exponent, and the significand as an array of integer parts. After |

107 | /// normalization of a number of precision P the exponent is within the range of |

108 | /// the format, and if the number is not denormal the P-th bit of the |

109 | /// significand is set as an explicit integer bit. For denormals the most |

110 | /// significant bit is shifted right so that the exponent is maintained at the |

111 | /// format's minimum, so that the smallest denormal has just the least |

112 | /// significant bit of the significand set. The sign of zeroes and infinities |

113 | /// is significant; the exponent and significand of such numbers is not stored, |

114 | /// but has a known implicit (deterministic) value: 0 for the significands, 0 |

115 | /// for zero exponent, all 1 bits for infinity exponent. For NaNs the sign and |

116 | /// significand are deterministic, although not really meaningful, and preserved |

117 | /// in non-conversion operations. The exponent is implicitly all 1 bits. |

118 | /// |

119 | /// APFloat does not provide any exception handling beyond default exception |

120 | /// handling. We represent Signaling NaNs via IEEE-754R 2008 6.2.1 should clause |

121 | /// by encoding Signaling NaNs with the first bit of its trailing significand as |

122 | /// 0. |

123 | /// |

124 | /// TODO |

125 | /// ==== |

126 | /// |

127 | /// Some features that may or may not be worth adding: |

128 | /// |

129 | /// Binary to decimal conversion (hard). |

130 | /// |

131 | /// Optional ability to detect underflow tininess before rounding. |

132 | /// |

133 | /// New formats: x87 in single and double precision mode (IEEE apart from |

134 | /// extended exponent range) (hard). |

135 | /// |

136 | /// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward. |

137 | /// |

138 | |

139 | // This is the common type definitions shared by APFloat and its internal |

140 | // implementation classes. This struct should not define any non-static data |

141 | // members. |

142 | struct APFloatBase { |

143 | typedef APInt::WordType integerPart; |

144 | static const unsigned integerPartWidth = APInt::APINT_BITS_PER_WORD; |

145 | |

146 | /// A signed type to represent a floating point numbers unbiased exponent. |

147 | typedef signed short ExponentType; |

148 | |

149 | /// \name Floating Point Semantics. |

150 | /// @{ |

151 | |

152 | static const fltSemantics &IEEEhalf() LLVM_READNONE; |

153 | static const fltSemantics &IEEEsingle() LLVM_READNONE; |

154 | static const fltSemantics &IEEEdouble() LLVM_READNONE; |

155 | static const fltSemantics &IEEEquad() LLVM_READNONE; |

156 | static const fltSemantics &PPCDoubleDouble() LLVM_READNONE; |

157 | static const fltSemantics &x87DoubleExtended() LLVM_READNONE; |

158 | |

159 | /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with |

160 | /// anything real. |

161 | static const fltSemantics &Bogus() LLVM_READNONE; |

162 | |

163 | /// @} |

164 | |

165 | /// IEEE-754R 5.11: Floating Point Comparison Relations. |

166 | enum cmpResult { |

167 | cmpLessThan, |

168 | cmpEqual, |

169 | cmpGreaterThan, |

170 | cmpUnordered |

171 | }; |

172 | |

173 | /// IEEE-754R 4.3: Rounding-direction attributes. |

174 | enum roundingMode { |

175 | rmNearestTiesToEven, |

176 | rmTowardPositive, |

177 | rmTowardNegative, |

178 | rmTowardZero, |

179 | rmNearestTiesToAway |

180 | }; |

181 | |

182 | /// IEEE-754R 7: Default exception handling. |

183 | /// |

184 | /// opUnderflow or opOverflow are always returned or-ed with opInexact. |

185 | enum opStatus { |

186 | opOK = 0x00, |

187 | opInvalidOp = 0x01, |

188 | opDivByZero = 0x02, |

189 | opOverflow = 0x04, |

190 | opUnderflow = 0x08, |

191 | opInexact = 0x10 |

192 | }; |

193 | |

194 | /// Category of internally-represented number. |

195 | enum fltCategory { |

196 | fcInfinity, |

197 | fcNaN, |

198 | fcNormal, |

199 | fcZero |

200 | }; |

201 | |

202 | /// Convenience enum used to construct an uninitialized APFloat. |

203 | enum uninitializedTag { |

204 | uninitialized |

205 | }; |

206 | |

207 | /// Enumeration of \c ilogb error results. |

208 | enum IlogbErrorKinds { |

209 | IEK_Zero = INT_MIN + 1, |

210 | IEK_NaN = INT_MIN, |

211 | IEK_Inf = INT_MAX |

212 | }; |

213 | |

214 | static unsigned int semanticsPrecision(const fltSemantics &); |

215 | static ExponentType semanticsMinExponent(const fltSemantics &); |

216 | static ExponentType semanticsMaxExponent(const fltSemantics &); |

217 | static unsigned int semanticsSizeInBits(const fltSemantics &); |

218 | |

219 | /// Returns the size of the floating point number (in bits) in the given |

220 | /// semantics. |

221 | static unsigned getSizeInBits(const fltSemantics &Sem); |

222 | }; |

223 | |

224 | namespace detail { |

225 | |

226 | class IEEEFloat final : public APFloatBase { |

227 | public: |

228 | /// \name Constructors |

229 | /// @{ |

230 | |

231 | IEEEFloat(const fltSemantics &); // Default construct to 0.0 |

232 | IEEEFloat(const fltSemantics &, integerPart); |

233 | IEEEFloat(const fltSemantics &, uninitializedTag); |

234 | IEEEFloat(const fltSemantics &, const APInt &); |

235 | explicit IEEEFloat(double d); |

236 | explicit IEEEFloat(float f); |

237 | IEEEFloat(const IEEEFloat &); |

238 | IEEEFloat(IEEEFloat &&); |

239 | ~IEEEFloat(); |

240 | |

241 | /// @} |

242 | |

243 | /// Returns whether this instance allocated memory. |

244 | 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 | |

458 | private: |

459 | /// \name Simple Queries |

460 | /// @{ |

461 | |

462 | integerPart *significandParts(); |

463 | const integerPart *significandParts() const; |

464 | unsigned int partCount() const; |

465 | |

466 | /// @} |

467 | |

468 | /// \name Significand operations. |

469 | /// @{ |

470 | |

471 | integerPart addSignificand(const IEEEFloat &); |

472 | integerPart subtractSignificand(const IEEEFloat &, integerPart); |

473 | lostFraction addOrSubtractSignificand(const IEEEFloat &, bool subtract); |

474 | lostFraction multiplySignificand(const IEEEFloat &, const IEEEFloat *); |

475 | lostFraction divideSignificand(const IEEEFloat &); |

476 | void incrementSignificand(); |

477 | void initialize(const fltSemantics *); |

478 | void shiftSignificandLeft(unsigned int); |

479 | lostFraction shiftSignificandRight(unsigned int); |

480 | unsigned int significandLSB() const; |

481 | unsigned int significandMSB() const; |

482 | void zeroSignificand(); |

483 | /// Return true if the significand excluding the integral bit is all ones. |

484 | bool isSignificandAllOnes() const; |

485 | /// Return true if the significand excluding the integral bit is all zeros. |

486 | bool isSignificandAllZeros() const; |

487 | |

488 | /// @} |

489 | |

490 | /// \name Arithmetic on special values. |

491 | /// @{ |

492 | |

493 | opStatus addOrSubtractSpecials(const IEEEFloat &, bool subtract); |

494 | opStatus divideSpecials(const IEEEFloat &); |

495 | opStatus multiplySpecials(const IEEEFloat &); |

496 | opStatus modSpecials(const IEEEFloat &); |

497 | |

498 | /// @} |

499 | |

500 | /// \name Miscellany |

501 | /// @{ |

502 | |

503 | bool convertFromStringSpecials(StringRef str); |

504 | opStatus normalize(roundingMode, lostFraction); |

505 | opStatus addOrSubtract(const IEEEFloat &, roundingMode, bool subtract); |

506 | opStatus handleOverflow(roundingMode); |

507 | bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const; |

508 | opStatus convertToSignExtendedInteger(MutableArrayRef<integerPart>, |

509 | unsigned int, bool, roundingMode, |

510 | bool *) const; |

511 | opStatus convertFromUnsignedParts(const integerPart *, unsigned int, |

512 | roundingMode); |

513 | opStatus convertFromHexadecimalString(StringRef, roundingMode); |

514 | opStatus convertFromDecimalString(StringRef, roundingMode); |

515 | char *convertNormalToHexString(char *, unsigned int, bool, |

516 | roundingMode) const; |

517 | opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int, |

518 | roundingMode); |

519 | |

520 | /// @} |

521 | |

522 | APInt convertHalfAPFloatToAPInt() const; |

523 | APInt convertFloatAPFloatToAPInt() const; |

524 | APInt convertDoubleAPFloatToAPInt() const; |

525 | APInt convertQuadrupleAPFloatToAPInt() const; |

526 | APInt convertF80LongDoubleAPFloatToAPInt() const; |

527 | APInt convertPPCDoubleDoubleAPFloatToAPInt() const; |

528 | void initFromAPInt(const fltSemantics *Sem, const APInt &api); |

529 | void initFromHalfAPInt(const APInt &api); |

530 | void initFromFloatAPInt(const APInt &api); |

531 | void initFromDoubleAPInt(const APInt &api); |

532 | void initFromQuadrupleAPInt(const APInt &api); |

533 | void initFromF80LongDoubleAPInt(const APInt &api); |

534 | void initFromPPCDoubleDoubleAPInt(const APInt &api); |

535 | |

536 | void assign(const IEEEFloat &); |

537 | void copySignificand(const IEEEFloat &); |

538 | void freeSignificand(); |

539 | |

540 | /// Note: this must be the first data member. |

541 | /// The semantics that this value obeys. |

542 | const fltSemantics *semantics; |

543 | |

544 | /// A binary fraction with an explicit integer bit. |

545 | /// |

546 | /// The significand must be at least one bit wider than the target precision. |

547 | union Significand { |

548 | integerPart part; |

549 | integerPart *parts; |

550 | } significand; |

551 | |

552 | /// The signed unbiased exponent of the value. |

553 | ExponentType exponent; |

554 | |

555 | /// What kind of floating point number this is. |

556 | /// |

557 | /// Only 2 bits are required, but VisualStudio incorrectly sign extends it. |

558 | /// Using the extra bit keeps it from failing under VisualStudio. |

559 | fltCategory category : 3; |

560 | |

561 | /// Sign bit of the number. |

562 | unsigned int sign : 1; |

563 | }; |

564 | |

565 | hash_code hash_value(const IEEEFloat &Arg); |

566 | int ilogb(const IEEEFloat &Arg); |

567 | IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode); |

568 | IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM); |

569 | |

570 | // This mode implements more precise float in terms of two APFloats. |

571 | // The interface and layout is designed for arbitray underlying semantics, |

572 | // though currently only PPCDoubleDouble semantics are supported, whose |

573 | // corresponding underlying semantics are IEEEdouble. |

574 | class DoubleAPFloat final : public APFloatBase { |

575 | // Note: this must be the first data member. |

576 | const fltSemantics *Semantics; |

577 | std::unique_ptr<APFloat[]> Floats; |

578 | |

579 | opStatus addImpl(const APFloat &a, const APFloat &aa, const APFloat &c, |

580 | const APFloat &cc, roundingMode RM); |

581 | |

582 | opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS, |

583 | DoubleAPFloat &Out, roundingMode RM); |

584 | |

585 | public: |

586 | DoubleAPFloat(const fltSemantics &S); |

587 | DoubleAPFloat(const fltSemantics &S, uninitializedTag); |

588 | DoubleAPFloat(const fltSemantics &S, integerPart); |

589 | DoubleAPFloat(const fltSemantics &S, const APInt &I); |

590 | DoubleAPFloat(const fltSemantics &S, APFloat &&First, APFloat &&Second); |

591 | DoubleAPFloat(const DoubleAPFloat &RHS); |

592 | DoubleAPFloat(DoubleAPFloat &&RHS); |

593 | |

594 | DoubleAPFloat &operator=(const DoubleAPFloat &RHS); |

595 | |

596 | 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 | |

668 | hash_code hash_value(const DoubleAPFloat &Arg); |

669 | |

670 | } // End detail namespace |

671 | |

672 | // This is a interface class that is currently forwarding functionalities from |

673 | // detail::IEEEFloat. |

674 | class APFloat : public APFloatBase { |

675 | typedef detail::IEEEFloat IEEEFloat; |

676 | typedef detail::DoubleAPFloat DoubleAPFloat; |

677 | |

678 | static_assert(std::is_standard_layout<IEEEFloat>::value, ""); |

679 | |

680 | union Storage { |

681 | const fltSemantics *semantics; |

682 | IEEEFloat IEEE; |

683 | DoubleAPFloat Double; |

684 | |

685 | explicit Storage(IEEEFloat F, const fltSemantics &S); |

686 | explicit Storage(DoubleAPFloat F, const fltSemantics &S) |

687 | : 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 | |

835 | public: |

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. |

1192 | hash_code hash_value(const APFloat &Arg); |

1193 | inline 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. |

1205 | inline 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. |

1213 | inline APFloat abs(APFloat X) { |

1214 | X.clearSign(); |

1215 | return X; |

1216 | } |

1217 | |

1218 | /// Returns the negated value of the argument. |

1219 | inline 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. |

1226 | LLVM_READONLY |

1227 | inline 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. |

1237 | LLVM_READONLY |

1238 | inline 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 | /// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2 |

1247 | /// arguments, propagating NaNs and treating -0 as less than +0. |

1248 | LLVM_READONLY |

1249 | inline APFloat minimum(const APFloat &A, const APFloat &B) { |

1250 | if (A.isNaN()) |

1251 | return A; |

1252 | if (B.isNaN()) |

1253 | return B; |

1254 | if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative())) |

1255 | return A.isNegative() ? A : B; |

1256 | return (B.compare(A) == APFloat::cmpLessThan) ? B : A; |

1257 | } |

1258 | |

1259 | /// Implements IEEE 754-2018 maximum semantics. Returns the larger of 2 |

1260 | /// arguments, propagating NaNs and treating -0 as less than +0. |

1261 | LLVM_READONLY |

1262 | inline APFloat maximum(const APFloat &A, const APFloat &B) { |

1263 | if (A.isNaN()) |

1264 | return A; |

1265 | if (B.isNaN()) |

1266 | return B; |

1267 | if (A.isZero() && B.isZero() && (A.isNegative() != B.isNegative())) |

1268 | return A.isNegative() ? B : A; |

1269 | return (A.compare(B) == APFloat::cmpLessThan) ? B : A; |

1270 | } |

1271 | |

1272 | } // namespace llvm |

1273 | |

1274 | #undef APFLOAT_DISPATCH_ON_SEMANTICS |

1275 | #endif // LLVM_ADT_APFLOAT_H |

1276 |