]>
Commit | Line | Data |
---|---|---|
1a4d82fc | 1 | //===- llvm/ADT/APFloat.h - Arbitrary Precision Floating Point ---*- C++ -*-==// |
223e47cc LB |
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 | //===----------------------------------------------------------------------===// | |
1a4d82fc JJ |
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 | /// | |
223e47cc LB |
15 | //===----------------------------------------------------------------------===// |
16 | ||
970d7e83 LB |
17 | #ifndef LLVM_ADT_APFLOAT_H |
18 | #define LLVM_ADT_APFLOAT_H | |
223e47cc | 19 | |
223e47cc LB |
20 | #include "llvm/ADT/APInt.h" |
21 | ||
22 | namespace llvm { | |
23 | ||
1a4d82fc JJ |
24 | struct fltSemantics; |
25 | class APSInt; | |
26 | class StringRef; | |
27 | ||
28 | /// Enum that represents what fraction of the LSB truncated bits of an fp number | |
29 | /// represent. | |
30 | /// | |
31 | /// This essentially combines the roles of guard and sticky bits. | |
32 | enum lostFraction { // Example of truncated bits: | |
33 | lfExactlyZero, // 000000 | |
34 | lfLessThanHalf, // 0xxxxx x's not all zero | |
35 | lfExactlyHalf, // 100000 | |
36 | lfMoreThanHalf // 1xxxxx x's not all zero | |
37 | }; | |
38 | ||
39 | /// \brief A self-contained host- and target-independent arbitrary-precision | |
40 | /// floating-point software implementation. | |
41 | /// | |
42 | /// APFloat uses bignum integer arithmetic as provided by static functions in | |
43 | /// the APInt class. The library will work with bignum integers whose parts are | |
44 | /// any unsigned type at least 16 bits wide, but 64 bits is recommended. | |
45 | /// | |
46 | /// Written for clarity rather than speed, in particular with a view to use in | |
47 | /// the front-end of a cross compiler so that target arithmetic can be correctly | |
48 | /// performed on the host. Performance should nonetheless be reasonable, | |
49 | /// particularly for its intended use. It may be useful as a base | |
50 | /// implementation for a run-time library during development of a faster | |
51 | /// target-specific one. | |
52 | /// | |
53 | /// All 5 rounding modes in the IEEE-754R draft are handled correctly for all | |
54 | /// implemented operations. Currently implemented operations are add, subtract, | |
55 | /// multiply, divide, fused-multiply-add, conversion-to-float, | |
56 | /// conversion-to-integer and conversion-from-integer. New rounding modes | |
57 | /// (e.g. away from zero) can be added with three or four lines of code. | |
58 | /// | |
59 | /// Four formats are built-in: IEEE single precision, double precision, | |
60 | /// quadruple precision, and x87 80-bit extended double (when operating with | |
61 | /// full extended precision). Adding a new format that obeys IEEE semantics | |
62 | /// only requires adding two lines of code: a declaration and definition of the | |
63 | /// format. | |
64 | /// | |
65 | /// All operations return the status of that operation as an exception bit-mask, | |
66 | /// so multiple operations can be done consecutively with their results or-ed | |
67 | /// together. The returned status can be useful for compiler diagnostics; e.g., | |
68 | /// inexact, underflow and overflow can be easily diagnosed on constant folding, | |
69 | /// and compiler optimizers can determine what exceptions would be raised by | |
70 | /// folding operations and optimize, or perhaps not optimize, accordingly. | |
71 | /// | |
72 | /// At present, underflow tininess is detected after rounding; it should be | |
73 | /// straight forward to add support for the before-rounding case too. | |
74 | /// | |
75 | /// The library reads hexadecimal floating point numbers as per C99, and | |
76 | /// correctly rounds if necessary according to the specified rounding mode. | |
77 | /// Syntax is required to have been validated by the caller. It also converts | |
78 | /// floating point numbers to hexadecimal text as per the C99 %a and %A | |
79 | /// conversions. The output precision (or alternatively the natural minimal | |
80 | /// precision) can be specified; if the requested precision is less than the | |
81 | /// natural precision the output is correctly rounded for the specified rounding | |
82 | /// mode. | |
83 | /// | |
84 | /// It also reads decimal floating point numbers and correctly rounds according | |
85 | /// to the specified rounding mode. | |
86 | /// | |
87 | /// Conversion to decimal text is not currently implemented. | |
88 | /// | |
89 | /// Non-zero finite numbers are represented internally as a sign bit, a 16-bit | |
90 | /// signed exponent, and the significand as an array of integer parts. After | |
91 | /// normalization of a number of precision P the exponent is within the range of | |
92 | /// the format, and if the number is not denormal the P-th bit of the | |
93 | /// significand is set as an explicit integer bit. For denormals the most | |
94 | /// significant bit is shifted right so that the exponent is maintained at the | |
95 | /// format's minimum, so that the smallest denormal has just the least | |
96 | /// significant bit of the significand set. The sign of zeroes and infinities | |
97 | /// is significant; the exponent and significand of such numbers is not stored, | |
98 | /// but has a known implicit (deterministic) value: 0 for the significands, 0 | |
99 | /// for zero exponent, all 1 bits for infinity exponent. For NaNs the sign and | |
100 | /// significand are deterministic, although not really meaningful, and preserved | |
101 | /// in non-conversion operations. The exponent is implicitly all 1 bits. | |
102 | /// | |
103 | /// APFloat does not provide any exception handling beyond default exception | |
104 | /// handling. We represent Signaling NaNs via IEEE-754R 2008 6.2.1 should clause | |
105 | /// by encoding Signaling NaNs with the first bit of its trailing significand as | |
106 | /// 0. | |
107 | /// | |
108 | /// TODO | |
109 | /// ==== | |
110 | /// | |
111 | /// Some features that may or may not be worth adding: | |
112 | /// | |
113 | /// Binary to decimal conversion (hard). | |
114 | /// | |
115 | /// Optional ability to detect underflow tininess before rounding. | |
116 | /// | |
117 | /// New formats: x87 in single and double precision mode (IEEE apart from | |
118 | /// extended exponent range) (hard). | |
119 | /// | |
120 | /// New operations: sqrt, IEEE remainder, C90 fmod, nexttoward. | |
121 | /// | |
122 | class APFloat { | |
123 | public: | |
124 | ||
125 | /// A signed type to represent a floating point numbers unbiased exponent. | |
126 | typedef signed short ExponentType; | |
127 | ||
128 | /// \name Floating Point Semantics. | |
129 | /// @{ | |
130 | ||
131 | static const fltSemantics IEEEhalf; | |
132 | static const fltSemantics IEEEsingle; | |
133 | static const fltSemantics IEEEdouble; | |
134 | static const fltSemantics IEEEquad; | |
135 | static const fltSemantics PPCDoubleDouble; | |
136 | static const fltSemantics x87DoubleExtended; | |
137 | ||
138 | /// A Pseudo fltsemantic used to construct APFloats that cannot conflict with | |
139 | /// anything real. | |
140 | static const fltSemantics Bogus; | |
141 | ||
142 | /// @} | |
143 | ||
144 | static unsigned int semanticsPrecision(const fltSemantics &); | |
145 | ||
146 | /// IEEE-754R 5.11: Floating Point Comparison Relations. | |
147 | enum cmpResult { | |
148 | cmpLessThan, | |
149 | cmpEqual, | |
150 | cmpGreaterThan, | |
151 | cmpUnordered | |
223e47cc LB |
152 | }; |
153 | ||
1a4d82fc JJ |
154 | /// IEEE-754R 4.3: Rounding-direction attributes. |
155 | enum roundingMode { | |
156 | rmNearestTiesToEven, | |
157 | rmTowardPositive, | |
158 | rmTowardNegative, | |
159 | rmTowardZero, | |
160 | rmNearestTiesToAway | |
161 | }; | |
223e47cc | 162 | |
1a4d82fc JJ |
163 | /// IEEE-754R 7: Default exception handling. |
164 | /// | |
165 | /// opUnderflow or opOverflow are always returned or-ed with opInexact. | |
166 | enum opStatus { | |
167 | opOK = 0x00, | |
168 | opInvalidOp = 0x01, | |
169 | opDivByZero = 0x02, | |
170 | opOverflow = 0x04, | |
171 | opUnderflow = 0x08, | |
172 | opInexact = 0x10 | |
173 | }; | |
223e47cc | 174 | |
1a4d82fc JJ |
175 | /// Category of internally-represented number. |
176 | enum fltCategory { | |
177 | fcInfinity, | |
178 | fcNaN, | |
179 | fcNormal, | |
180 | fcZero | |
223e47cc | 181 | }; |
970d7e83 | 182 | |
1a4d82fc JJ |
183 | /// Convenience enum used to construct an uninitialized APFloat. |
184 | enum uninitializedTag { | |
185 | uninitialized | |
186 | }; | |
223e47cc | 187 | |
1a4d82fc JJ |
188 | /// \name Constructors |
189 | /// @{ | |
190 | ||
191 | APFloat(const fltSemantics &); // Default construct to 0.0 | |
192 | APFloat(const fltSemantics &, StringRef); | |
193 | APFloat(const fltSemantics &, integerPart); | |
194 | APFloat(const fltSemantics &, uninitializedTag); | |
195 | APFloat(const fltSemantics &, const APInt &); | |
196 | explicit APFloat(double d); | |
197 | explicit APFloat(float f); | |
198 | APFloat(const APFloat &); | |
199 | APFloat(APFloat &&); | |
200 | ~APFloat(); | |
201 | ||
202 | /// @} | |
203 | ||
204 | /// \brief Returns whether this instance allocated memory. | |
205 | bool needsCleanup() const { return partCount() > 1; } | |
206 | ||
207 | /// \name Convenience "constructors" | |
208 | /// @{ | |
209 | ||
210 | /// Factory for Positive and Negative Zero. | |
211 | /// | |
212 | /// \param Negative True iff the number should be negative. | |
213 | static APFloat getZero(const fltSemantics &Sem, bool Negative = false) { | |
214 | APFloat Val(Sem, uninitialized); | |
215 | Val.makeZero(Negative); | |
216 | return Val; | |
217 | } | |
218 | ||
219 | /// Factory for Positive and Negative Infinity. | |
220 | /// | |
221 | /// \param Negative True iff the number should be negative. | |
222 | static APFloat getInf(const fltSemantics &Sem, bool Negative = false) { | |
223 | APFloat Val(Sem, uninitialized); | |
224 | Val.makeInf(Negative); | |
225 | return Val; | |
226 | } | |
227 | ||
228 | /// Factory for QNaN values. | |
229 | /// | |
230 | /// \param Negative - True iff the NaN generated should be negative. | |
231 | /// \param type - The unspecified fill bits for creating the NaN, 0 by | |
232 | /// default. The value is truncated as necessary. | |
233 | static APFloat getNaN(const fltSemantics &Sem, bool Negative = false, | |
234 | unsigned type = 0) { | |
235 | if (type) { | |
236 | APInt fill(64, type); | |
237 | return getQNaN(Sem, Negative, &fill); | |
238 | } else { | |
239 | return getQNaN(Sem, Negative, nullptr); | |
240 | } | |
241 | } | |
242 | ||
243 | /// Factory for QNaN values. | |
244 | static APFloat getQNaN(const fltSemantics &Sem, bool Negative = false, | |
245 | const APInt *payload = nullptr) { | |
246 | return makeNaN(Sem, false, Negative, payload); | |
247 | } | |
248 | ||
249 | /// Factory for SNaN values. | |
250 | static APFloat getSNaN(const fltSemantics &Sem, bool Negative = false, | |
251 | const APInt *payload = nullptr) { | |
252 | return makeNaN(Sem, true, Negative, payload); | |
253 | } | |
254 | ||
255 | /// Returns the largest finite number in the given semantics. | |
256 | /// | |
257 | /// \param Negative - True iff the number should be negative | |
258 | static APFloat getLargest(const fltSemantics &Sem, bool Negative = false); | |
259 | ||
260 | /// Returns the smallest (by magnitude) finite number in the given semantics. | |
261 | /// Might be denormalized, which implies a relative loss of precision. | |
262 | /// | |
263 | /// \param Negative - True iff the number should be negative | |
264 | static APFloat getSmallest(const fltSemantics &Sem, bool Negative = false); | |
265 | ||
266 | /// Returns the smallest (by magnitude) normalized finite number in the given | |
267 | /// semantics. | |
268 | /// | |
269 | /// \param Negative - True iff the number should be negative | |
270 | static APFloat getSmallestNormalized(const fltSemantics &Sem, | |
271 | bool Negative = false); | |
272 | ||
273 | /// Returns a float which is bitcasted from an all one value int. | |
274 | /// | |
275 | /// \param BitWidth - Select float type | |
276 | /// \param isIEEE - If 128 bit number, select between PPC and IEEE | |
277 | static APFloat getAllOnesValue(unsigned BitWidth, bool isIEEE = false); | |
278 | ||
279 | /// @} | |
280 | ||
281 | /// Used to insert APFloat objects, or objects that contain APFloat objects, | |
282 | /// into FoldingSets. | |
283 | void Profile(FoldingSetNodeID &NID) const; | |
284 | ||
285 | /// \brief Used by the Bitcode serializer to emit APInts to Bitcode. | |
286 | void Emit(Serializer &S) const; | |
287 | ||
288 | /// \brief Used by the Bitcode deserializer to deserialize APInts. | |
289 | static APFloat ReadVal(Deserializer &D); | |
290 | ||
291 | /// \name Arithmetic | |
292 | /// @{ | |
293 | ||
294 | opStatus add(const APFloat &, roundingMode); | |
295 | opStatus subtract(const APFloat &, roundingMode); | |
296 | opStatus multiply(const APFloat &, roundingMode); | |
297 | opStatus divide(const APFloat &, roundingMode); | |
298 | /// IEEE remainder. | |
299 | opStatus remainder(const APFloat &); | |
300 | /// C fmod, or llvm frem. | |
301 | opStatus mod(const APFloat &, roundingMode); | |
302 | opStatus fusedMultiplyAdd(const APFloat &, const APFloat &, roundingMode); | |
303 | opStatus roundToIntegral(roundingMode); | |
304 | /// IEEE-754R 5.3.1: nextUp/nextDown. | |
305 | opStatus next(bool nextDown); | |
306 | ||
307 | /// @} | |
308 | ||
309 | /// \name Sign operations. | |
310 | /// @{ | |
311 | ||
312 | void changeSign(); | |
313 | void clearSign(); | |
314 | void copySign(const APFloat &); | |
315 | ||
316 | /// @} | |
317 | ||
318 | /// \name Conversions | |
319 | /// @{ | |
320 | ||
321 | opStatus convert(const fltSemantics &, roundingMode, bool *); | |
322 | opStatus convertToInteger(integerPart *, unsigned int, bool, roundingMode, | |
323 | bool *) const; | |
324 | opStatus convertToInteger(APSInt &, roundingMode, bool *) const; | |
325 | opStatus convertFromAPInt(const APInt &, bool, roundingMode); | |
326 | opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int, | |
327 | bool, roundingMode); | |
328 | opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, | |
329 | bool, roundingMode); | |
330 | opStatus convertFromString(StringRef, roundingMode); | |
331 | APInt bitcastToAPInt() const; | |
332 | double convertToDouble() const; | |
333 | float convertToFloat() const; | |
334 | ||
335 | /// @} | |
336 | ||
337 | /// The definition of equality is not straightforward for floating point, so | |
338 | /// we won't use operator==. Use one of the following, or write whatever it | |
339 | /// is you really mean. | |
340 | bool operator==(const APFloat &) const LLVM_DELETED_FUNCTION; | |
341 | ||
342 | /// IEEE comparison with another floating point number (NaNs compare | |
343 | /// unordered, 0==-0). | |
344 | cmpResult compare(const APFloat &) const; | |
345 | ||
346 | /// Bitwise comparison for equality (QNaNs compare equal, 0!=-0). | |
347 | bool bitwiseIsEqual(const APFloat &) const; | |
348 | ||
349 | /// Write out a hexadecimal representation of the floating point value to DST, | |
350 | /// which must be of sufficient size, in the C99 form [-]0xh.hhhhp[+-]d. | |
351 | /// Return the number of characters written, excluding the terminating NUL. | |
352 | unsigned int convertToHexString(char *dst, unsigned int hexDigits, | |
353 | bool upperCase, roundingMode) const; | |
354 | ||
355 | /// \name IEEE-754R 5.7.2 General operations. | |
356 | /// @{ | |
357 | ||
358 | /// IEEE-754R isSignMinus: Returns true if and only if the current value is | |
359 | /// negative. | |
360 | /// | |
361 | /// This applies to zeros and NaNs as well. | |
362 | bool isNegative() const { return sign; } | |
363 | ||
364 | /// IEEE-754R isNormal: Returns true if and only if the current value is normal. | |
365 | /// | |
366 | /// This implies that the current value of the float is not zero, subnormal, | |
367 | /// infinite, or NaN following the definition of normality from IEEE-754R. | |
368 | bool isNormal() const { return !isDenormal() && isFiniteNonZero(); } | |
369 | ||
370 | /// Returns true if and only if the current value is zero, subnormal, or | |
371 | /// normal. | |
372 | /// | |
373 | /// This means that the value is not infinite or NaN. | |
374 | bool isFinite() const { return !isNaN() && !isInfinity(); } | |
375 | ||
376 | /// Returns true if and only if the float is plus or minus zero. | |
377 | bool isZero() const { return category == fcZero; } | |
378 | ||
379 | /// IEEE-754R isSubnormal(): Returns true if and only if the float is a | |
380 | /// denormal. | |
381 | bool isDenormal() const; | |
382 | ||
383 | /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity. | |
384 | bool isInfinity() const { return category == fcInfinity; } | |
385 | ||
386 | /// Returns true if and only if the float is a quiet or signaling NaN. | |
387 | bool isNaN() const { return category == fcNaN; } | |
388 | ||
389 | /// Returns true if and only if the float is a signaling NaN. | |
390 | bool isSignaling() const; | |
391 | ||
392 | /// @} | |
393 | ||
394 | /// \name Simple Queries | |
395 | /// @{ | |
396 | ||
397 | fltCategory getCategory() const { return category; } | |
398 | const fltSemantics &getSemantics() const { return *semantics; } | |
399 | bool isNonZero() const { return category != fcZero; } | |
400 | bool isFiniteNonZero() const { return isFinite() && !isZero(); } | |
401 | bool isPosZero() const { return isZero() && !isNegative(); } | |
402 | bool isNegZero() const { return isZero() && isNegative(); } | |
403 | ||
404 | /// Returns true if and only if the number has the smallest possible non-zero | |
405 | /// magnitude in the current semantics. | |
406 | bool isSmallest() const; | |
407 | ||
408 | /// Returns true if and only if the number has the largest possible finite | |
409 | /// magnitude in the current semantics. | |
410 | bool isLargest() const; | |
411 | ||
412 | /// @} | |
413 | ||
414 | APFloat &operator=(const APFloat &); | |
415 | APFloat &operator=(APFloat &&); | |
416 | ||
417 | /// \brief Overload to compute a hash code for an APFloat value. | |
418 | /// | |
419 | /// Note that the use of hash codes for floating point values is in general | |
420 | /// frought with peril. Equality is hard to define for these values. For | |
421 | /// example, should negative and positive zero hash to different codes? Are | |
422 | /// they equal or not? This hash value implementation specifically | |
423 | /// emphasizes producing different codes for different inputs in order to | |
424 | /// be used in canonicalization and memoization. As such, equality is | |
425 | /// bitwiseIsEqual, and 0 != -0. | |
426 | friend hash_code hash_value(const APFloat &Arg); | |
427 | ||
428 | /// Converts this value into a decimal string. | |
429 | /// | |
430 | /// \param FormatPrecision The maximum number of digits of | |
431 | /// precision to output. If there are fewer digits available, | |
432 | /// zero padding will not be used unless the value is | |
433 | /// integral and small enough to be expressed in | |
434 | /// FormatPrecision digits. 0 means to use the natural | |
435 | /// precision of the number. | |
436 | /// \param FormatMaxPadding The maximum number of zeros to | |
437 | /// consider inserting before falling back to scientific | |
438 | /// notation. 0 means to always use scientific notation. | |
439 | /// | |
440 | /// Number Precision MaxPadding Result | |
441 | /// ------ --------- ---------- ------ | |
442 | /// 1.01E+4 5 2 10100 | |
443 | /// 1.01E+4 4 2 1.01E+4 | |
444 | /// 1.01E+4 5 1 1.01E+4 | |
445 | /// 1.01E-2 5 2 0.0101 | |
446 | /// 1.01E-2 4 2 0.0101 | |
447 | /// 1.01E-2 4 1 1.01E-2 | |
448 | void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0, | |
449 | unsigned FormatMaxPadding = 3) const; | |
450 | ||
451 | /// If this value has an exact multiplicative inverse, store it in inv and | |
452 | /// return true. | |
453 | bool getExactInverse(APFloat *inv) const; | |
454 | ||
455 | private: | |
456 | ||
457 | /// \name Simple Queries | |
458 | /// @{ | |
459 | ||
460 | integerPart *significandParts(); | |
461 | const integerPart *significandParts() const; | |
462 | unsigned int partCount() const; | |
463 | ||
464 | /// @} | |
465 | ||
466 | /// \name Significand operations. | |
467 | /// @{ | |
468 | ||
469 | integerPart addSignificand(const APFloat &); | |
470 | integerPart subtractSignificand(const APFloat &, integerPart); | |
471 | lostFraction addOrSubtractSignificand(const APFloat &, bool subtract); | |
472 | lostFraction multiplySignificand(const APFloat &, const APFloat *); | |
473 | lostFraction divideSignificand(const APFloat &); | |
474 | void incrementSignificand(); | |
475 | void initialize(const fltSemantics *); | |
476 | void shiftSignificandLeft(unsigned int); | |
477 | lostFraction shiftSignificandRight(unsigned int); | |
478 | unsigned int significandLSB() const; | |
479 | unsigned int significandMSB() const; | |
480 | void zeroSignificand(); | |
481 | /// Return true if the significand excluding the integral bit is all ones. | |
482 | bool isSignificandAllOnes() const; | |
483 | /// Return true if the significand excluding the integral bit is all zeros. | |
484 | bool isSignificandAllZeros() const; | |
485 | ||
486 | /// @} | |
487 | ||
488 | /// \name Arithmetic on special values. | |
489 | /// @{ | |
490 | ||
491 | opStatus addOrSubtractSpecials(const APFloat &, bool subtract); | |
492 | opStatus divideSpecials(const APFloat &); | |
493 | opStatus multiplySpecials(const APFloat &); | |
494 | opStatus modSpecials(const APFloat &); | |
495 | ||
496 | /// @} | |
497 | ||
498 | /// \name Special value setters. | |
499 | /// @{ | |
500 | ||
501 | void makeLargest(bool Neg = false); | |
502 | void makeSmallest(bool Neg = false); | |
503 | void makeNaN(bool SNaN = false, bool Neg = false, | |
504 | const APInt *fill = nullptr); | |
505 | static APFloat makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative, | |
506 | const APInt *fill); | |
507 | void makeInf(bool Neg = false); | |
508 | void makeZero(bool Neg = false); | |
509 | ||
510 | /// @} | |
511 | ||
512 | /// \name Miscellany | |
513 | /// @{ | |
514 | ||
515 | bool convertFromStringSpecials(StringRef str); | |
516 | opStatus normalize(roundingMode, lostFraction); | |
517 | opStatus addOrSubtract(const APFloat &, roundingMode, bool subtract); | |
518 | cmpResult compareAbsoluteValue(const APFloat &) const; | |
519 | opStatus handleOverflow(roundingMode); | |
520 | bool roundAwayFromZero(roundingMode, lostFraction, unsigned int) const; | |
521 | opStatus convertToSignExtendedInteger(integerPart *, unsigned int, bool, | |
522 | roundingMode, bool *) const; | |
523 | opStatus convertFromUnsignedParts(const integerPart *, unsigned int, | |
524 | roundingMode); | |
525 | opStatus convertFromHexadecimalString(StringRef, roundingMode); | |
526 | opStatus convertFromDecimalString(StringRef, roundingMode); | |
527 | char *convertNormalToHexString(char *, unsigned int, bool, | |
528 | roundingMode) const; | |
529 | opStatus roundSignificandWithExponent(const integerPart *, unsigned int, int, | |
530 | roundingMode); | |
531 | ||
532 | /// @} | |
533 | ||
534 | APInt convertHalfAPFloatToAPInt() const; | |
535 | APInt convertFloatAPFloatToAPInt() const; | |
536 | APInt convertDoubleAPFloatToAPInt() const; | |
537 | APInt convertQuadrupleAPFloatToAPInt() const; | |
538 | APInt convertF80LongDoubleAPFloatToAPInt() const; | |
539 | APInt convertPPCDoubleDoubleAPFloatToAPInt() const; | |
540 | void initFromAPInt(const fltSemantics *Sem, const APInt &api); | |
541 | void initFromHalfAPInt(const APInt &api); | |
542 | void initFromFloatAPInt(const APInt &api); | |
543 | void initFromDoubleAPInt(const APInt &api); | |
544 | void initFromQuadrupleAPInt(const APInt &api); | |
545 | void initFromF80LongDoubleAPInt(const APInt &api); | |
546 | void initFromPPCDoubleDoubleAPInt(const APInt &api); | |
547 | ||
548 | void assign(const APFloat &); | |
549 | void copySignificand(const APFloat &); | |
550 | void freeSignificand(); | |
551 | ||
552 | /// The semantics that this value obeys. | |
553 | const fltSemantics *semantics; | |
554 | ||
555 | /// A binary fraction with an explicit integer bit. | |
556 | /// | |
557 | /// The significand must be at least one bit wider than the target precision. | |
558 | union Significand { | |
559 | integerPart part; | |
560 | integerPart *parts; | |
561 | } significand; | |
562 | ||
563 | /// The signed unbiased exponent of the value. | |
564 | ExponentType exponent; | |
565 | ||
566 | /// What kind of floating point number this is. | |
567 | /// | |
568 | /// Only 2 bits are required, but VisualStudio incorrectly sign extends it. | |
569 | /// Using the extra bit keeps it from failing under VisualStudio. | |
570 | fltCategory category : 3; | |
571 | ||
572 | /// Sign bit of the number. | |
573 | unsigned int sign : 1; | |
574 | }; | |
575 | ||
576 | /// See friend declaration above. | |
577 | /// | |
578 | /// This additional declaration is required in order to compile LLVM with IBM | |
579 | /// xlC compiler. | |
580 | hash_code hash_value(const APFloat &Arg); | |
581 | } // namespace llvm | |
582 | ||
583 | #endif // LLVM_ADT_APFLOAT_H |