Line data Source code
1 : //===-- APFloat.cpp - Implement APFloat class -----------------------------===//
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 : // This file implements a class to represent arbitrary precision floating
11 : // point values and provide a variety of arithmetic operations on them.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #include "llvm/ADT/APFloat.h"
16 : #include "llvm/ADT/APSInt.h"
17 : #include "llvm/ADT/ArrayRef.h"
18 : #include "llvm/ADT/FoldingSet.h"
19 : #include "llvm/ADT/Hashing.h"
20 : #include "llvm/ADT/StringExtras.h"
21 : #include "llvm/ADT/StringRef.h"
22 : #include "llvm/Config/llvm-config.h"
23 : #include "llvm/Support/Debug.h"
24 : #include "llvm/Support/ErrorHandling.h"
25 : #include "llvm/Support/MathExtras.h"
26 : #include "llvm/Support/raw_ostream.h"
27 : #include <cstring>
28 : #include <limits.h>
29 :
30 : #define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \
31 : do { \
32 : if (usesLayout<IEEEFloat>(getSemantics())) \
33 : return U.IEEE.METHOD_CALL; \
34 : if (usesLayout<DoubleAPFloat>(getSemantics())) \
35 : return U.Double.METHOD_CALL; \
36 : llvm_unreachable("Unexpected semantics"); \
37 : } while (false)
38 :
39 : using namespace llvm;
40 :
41 : /// A macro used to combine two fcCategory enums into one key which can be used
42 : /// in a switch statement to classify how the interaction of two APFloat's
43 : /// categories affects an operation.
44 : ///
45 : /// TODO: If clang source code is ever allowed to use constexpr in its own
46 : /// codebase, change this into a static inline function.
47 : #define PackCategoriesIntoKey(_lhs, _rhs) ((_lhs) * 4 + (_rhs))
48 :
49 : /* Assumed in hexadecimal significand parsing, and conversion to
50 : hexadecimal strings. */
51 : static_assert(APFloatBase::integerPartWidth % 4 == 0, "Part width must be divisible by 4!");
52 :
53 : namespace llvm {
54 : /* Represents floating point arithmetic semantics. */
55 : struct fltSemantics {
56 : /* The largest E such that 2^E is representable; this matches the
57 : definition of IEEE 754. */
58 : APFloatBase::ExponentType maxExponent;
59 :
60 : /* The smallest E such that 2^E is a normalized number; this
61 : matches the definition of IEEE 754. */
62 : APFloatBase::ExponentType minExponent;
63 :
64 : /* Number of bits in the significand. This includes the integer
65 : bit. */
66 : unsigned int precision;
67 :
68 : /* Number of bits actually used in the semantics. */
69 : unsigned int sizeInBits;
70 : };
71 :
72 : static const fltSemantics semIEEEhalf = {15, -14, 11, 16};
73 : static const fltSemantics semIEEEsingle = {127, -126, 24, 32};
74 : static const fltSemantics semIEEEdouble = {1023, -1022, 53, 64};
75 : static const fltSemantics semIEEEquad = {16383, -16382, 113, 128};
76 : static const fltSemantics semX87DoubleExtended = {16383, -16382, 64, 80};
77 : static const fltSemantics semBogus = {0, 0, 0, 0};
78 :
79 : /* The IBM double-double semantics. Such a number consists of a pair of IEEE
80 : 64-bit doubles (Hi, Lo), where |Hi| > |Lo|, and if normal,
81 : (double)(Hi + Lo) == Hi. The numeric value it's modeling is Hi + Lo.
82 : Therefore it has two 53-bit mantissa parts that aren't necessarily adjacent
83 : to each other, and two 11-bit exponents.
84 :
85 : Note: we need to make the value different from semBogus as otherwise
86 : an unsafe optimization may collapse both values to a single address,
87 : and we heavily rely on them having distinct addresses. */
88 : static const fltSemantics semPPCDoubleDouble = {-1, 0, 0, 0};
89 :
90 : /* These are legacy semantics for the fallback, inaccrurate implementation of
91 : IBM double-double, if the accurate semPPCDoubleDouble doesn't handle the
92 : operation. It's equivalent to having an IEEE number with consecutive 106
93 : bits of mantissa and 11 bits of exponent.
94 :
95 : It's not equivalent to IBM double-double. For example, a legit IBM
96 : double-double, 1 + epsilon:
97 :
98 : 1 + epsilon = 1 + (1 >> 1076)
99 :
100 : is not representable by a consecutive 106 bits of mantissa.
101 :
102 : Currently, these semantics are used in the following way:
103 :
104 : semPPCDoubleDouble -> (IEEEdouble, IEEEdouble) ->
105 : (64-bit APInt, 64-bit APInt) -> (128-bit APInt) ->
106 : semPPCDoubleDoubleLegacy -> IEEE operations
107 :
108 : We use bitcastToAPInt() to get the bit representation (in APInt) of the
109 : underlying IEEEdouble, then use the APInt constructor to construct the
110 : legacy IEEE float.
111 :
112 : TODO: Implement all operations in semPPCDoubleDouble, and delete these
113 : semantics. */
114 : static const fltSemantics semPPCDoubleDoubleLegacy = {1023, -1022 + 53,
115 : 53 + 53, 128};
116 :
117 1975921 : const fltSemantics &APFloatBase::IEEEhalf() {
118 1975921 : return semIEEEhalf;
119 : }
120 1759006 : const fltSemantics &APFloatBase::IEEEsingle() {
121 1759006 : return semIEEEsingle;
122 : }
123 6189343 : const fltSemantics &APFloatBase::IEEEdouble() {
124 6189343 : return semIEEEdouble;
125 : }
126 45109 : const fltSemantics &APFloatBase::IEEEquad() {
127 45109 : return semIEEEquad;
128 : }
129 500418 : const fltSemantics &APFloatBase::x87DoubleExtended() {
130 500418 : return semX87DoubleExtended;
131 : }
132 246407 : const fltSemantics &APFloatBase::Bogus() {
133 246407 : return semBogus;
134 : }
135 14060032 : const fltSemantics &APFloatBase::PPCDoubleDouble() {
136 14060032 : return semPPCDoubleDouble;
137 : }
138 :
139 : /* A tight upper bound on number of parts required to hold the value
140 : pow(5, power) is
141 :
142 : power * 815 / (351 * integerPartWidth) + 1
143 :
144 : However, whilst the result may require only this many parts,
145 : because we are multiplying two values to get it, the
146 : multiplication may require an extra part with the excess part
147 : being zero (consider the trivial case of 1 * 1, tcFullMultiply
148 : requires two parts to hold the single-part result). So we add an
149 : extra one to guarantee enough space whilst multiplying. */
150 : const unsigned int maxExponent = 16383;
151 : const unsigned int maxPrecision = 113;
152 : const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
153 : const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815) / (351 * APFloatBase::integerPartWidth));
154 :
155 1659 : unsigned int APFloatBase::semanticsPrecision(const fltSemantics &semantics) {
156 1659 : return semantics.precision;
157 : }
158 : APFloatBase::ExponentType
159 2 : APFloatBase::semanticsMaxExponent(const fltSemantics &semantics) {
160 2 : return semantics.maxExponent;
161 : }
162 : APFloatBase::ExponentType
163 2 : APFloatBase::semanticsMinExponent(const fltSemantics &semantics) {
164 2 : return semantics.minExponent;
165 : }
166 2 : unsigned int APFloatBase::semanticsSizeInBits(const fltSemantics &semantics) {
167 2 : return semantics.sizeInBits;
168 : }
169 :
170 0 : unsigned APFloatBase::getSizeInBits(const fltSemantics &Sem) {
171 0 : return Sem.sizeInBits;
172 : }
173 :
174 : /* A bunch of private, handy routines. */
175 :
176 : static inline unsigned int
177 : partCountForBits(unsigned int bits)
178 : {
179 43499815 : return ((bits) + APFloatBase::integerPartWidth - 1) / APFloatBase::integerPartWidth;
180 : }
181 :
182 : /* Returns 0U-9U. Return values >= 10U are not digits. */
183 : static inline unsigned int
184 : decDigitValue(unsigned int c)
185 : {
186 3219420 : return c - '0';
187 : }
188 :
189 : /* Return the value of a decimal exponent of the form
190 : [+-]ddddddd.
191 :
192 : If the exponent overflows, returns a large exponent with the
193 : appropriate sign. */
194 : static int
195 108290 : readExponent(StringRef::iterator begin, StringRef::iterator end)
196 : {
197 : bool isNegative;
198 : unsigned int absExponent;
199 : const unsigned int overlargeExponent = 24000; /* FIXME. */
200 : StringRef::iterator p = begin;
201 :
202 : assert(p != end && "Exponent has no digits");
203 :
204 108290 : isNegative = (*p == '-');
205 108290 : if (*p == '-' || *p == '+') {
206 107885 : p++;
207 : assert(p != end && "Exponent has no digits");
208 : }
209 :
210 108290 : absExponent = decDigitValue(*p++);
211 : assert(absExponent < 10U && "Invalid character in exponent");
212 :
213 255417 : for (; p != end; ++p) {
214 : unsigned int value;
215 :
216 147129 : value = decDigitValue(*p);
217 : assert(value < 10U && "Invalid character in exponent");
218 :
219 147129 : value += absExponent * 10;
220 147129 : if (absExponent >= overlargeExponent) {
221 : absExponent = overlargeExponent;
222 : p = end; /* outwit assert below */
223 : break;
224 : }
225 : absExponent = value;
226 : }
227 :
228 : assert(p == end && "Invalid exponent in exponent");
229 :
230 108290 : if (isNegative)
231 51059 : return -(int) absExponent;
232 : else
233 57231 : return (int) absExponent;
234 : }
235 :
236 : /* This is ugly and needs cleaning up, but I don't immediately see
237 : how whilst remaining safe. */
238 : static int
239 664 : totalExponent(StringRef::iterator p, StringRef::iterator end,
240 : int exponentAdjustment)
241 : {
242 : int unsignedExponent;
243 : bool negative, overflow;
244 : int exponent = 0;
245 :
246 : assert(p != end && "Exponent has no digits");
247 :
248 664 : negative = *p == '-';
249 664 : if (*p == '-' || *p == '+') {
250 535 : p++;
251 : assert(p != end && "Exponent has no digits");
252 : }
253 :
254 : unsignedExponent = 0;
255 : overflow = false;
256 2106 : for (; p != end; ++p) {
257 : unsigned int value;
258 :
259 1443 : value = decDigitValue(*p);
260 : assert(value < 10U && "Invalid character in exponent");
261 :
262 1443 : unsignedExponent = unsignedExponent * 10 + value;
263 1443 : if (unsignedExponent > 32767) {
264 : overflow = true;
265 : break;
266 : }
267 : }
268 :
269 664 : if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
270 : overflow = true;
271 :
272 664 : if (!overflow) {
273 : exponent = unsignedExponent;
274 663 : if (negative)
275 247 : exponent = -exponent;
276 663 : exponent += exponentAdjustment;
277 663 : if (exponent > 32767 || exponent < -32768)
278 : overflow = true;
279 : }
280 :
281 664 : if (overflow)
282 1 : exponent = negative ? -32768: 32767;
283 :
284 664 : return exponent;
285 : }
286 :
287 : static StringRef::iterator
288 : skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
289 : StringRef::iterator *dot)
290 : {
291 : StringRef::iterator p = begin;
292 : *dot = end;
293 342494 : while (p != end && *p == '0')
294 95284 : p++;
295 :
296 247210 : if (p != end && *p == '.') {
297 109185 : *dot = p++;
298 :
299 : assert(end - begin != 1 && "Significand has no digits");
300 :
301 281053 : while (p != end && *p == '0')
302 171868 : p++;
303 : }
304 :
305 : return p;
306 : }
307 :
308 : /* Given a normal decimal floating point number of the form
309 :
310 : dddd.dddd[eE][+-]ddd
311 :
312 : where the decimal point and exponent are optional, fill out the
313 : structure D. Exponent is appropriate if the significand is
314 : treated as an integer, and normalizedExponent if the significand
315 : is taken to have the decimal point after a single leading
316 : non-zero digit.
317 :
318 : If the value is zero, V->firstSigDigit points to a non-digit, and
319 : the return exponent is zero.
320 : */
321 : struct decimalInfo {
322 : const char *firstSigDigit;
323 : const char *lastSigDigit;
324 : int exponent;
325 : int normalizedExponent;
326 : };
327 :
328 : static void
329 246355 : interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
330 : decimalInfo *D)
331 : {
332 : StringRef::iterator dot = end;
333 : StringRef::iterator p = skipLeadingZeroesAndAnyDot (begin, end, &dot);
334 :
335 246355 : D->firstSigDigit = p;
336 246355 : D->exponent = 0;
337 246355 : D->normalizedExponent = 0;
338 :
339 1636053 : for (; p != end; ++p) {
340 1505502 : if (*p == '.') {
341 : assert(dot == end && "String contains multiple dots");
342 136994 : dot = p++;
343 136994 : if (p == end)
344 : break;
345 : }
346 1497988 : if (decDigitValue(*p) >= 10U)
347 : break;
348 : }
349 :
350 246355 : if (p != end) {
351 : assert((*p == 'e' || *p == 'E') && "Invalid character in significand");
352 : assert(p != begin && "Significand has no digits");
353 : assert((dot == end || p - begin != 1) && "Significand has no digits");
354 :
355 : /* p points to the first non-digit in the string */
356 108290 : D->exponent = readExponent(p + 1, end);
357 :
358 : /* Implied decimal point? */
359 108290 : if (dot == end)
360 : dot = p;
361 : }
362 :
363 : /* If number is all zeroes accept any exponent. */
364 246355 : if (p != D->firstSigDigit) {
365 : /* Drop insignificant trailing zeroes. */
366 186891 : if (p != begin) {
367 : do
368 : do
369 419263 : p--;
370 419263 : while (p != begin && *p == '0');
371 247963 : while (p != begin && *p == '.');
372 : }
373 :
374 : /* Adjust the exponents for any decimal point. */
375 186891 : D->exponent += static_cast<APFloat::ExponentType>((dot - p) - (dot > p));
376 186891 : D->normalizedExponent = (D->exponent +
377 373782 : static_cast<APFloat::ExponentType>((p - D->firstSigDigit)
378 297860 : - (dot > D->firstSigDigit && dot < p)));
379 : }
380 :
381 246355 : D->lastSigDigit = p;
382 246355 : }
383 :
384 : /* Return the trailing fraction of a hexadecimal number.
385 : DIGITVALUE is the first hex digit of the fraction, P points to
386 : the next digit. */
387 : static lostFraction
388 2 : trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
389 : unsigned int digitValue)
390 : {
391 : unsigned int hexDigit;
392 :
393 : /* If the first trailing digit isn't 0 or 8 we can work out the
394 : fraction immediately. */
395 2 : if (digitValue > 8)
396 : return lfMoreThanHalf;
397 2 : else if (digitValue < 8 && digitValue > 0)
398 : return lfLessThanHalf;
399 :
400 : // Otherwise we need to find the first non-zero digit.
401 7 : while (p != end && (*p == '0' || *p == '.'))
402 5 : p++;
403 :
404 : assert(p != end && "Invalid trailing hexadecimal fraction!");
405 :
406 2 : hexDigit = hexDigitValue(*p);
407 :
408 : /* If we ran off the end it is exactly zero or one-half, otherwise
409 : a little more. */
410 2 : if (hexDigit == -1U)
411 0 : return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
412 : else
413 2 : return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
414 : }
415 :
416 : /* Return the fraction lost were a bignum truncated losing the least
417 : significant BITS bits. */
418 : static lostFraction
419 676322 : lostFractionThroughTruncation(const APFloatBase::integerPart *parts,
420 : unsigned int partCount,
421 : unsigned int bits)
422 : {
423 : unsigned int lsb;
424 :
425 676322 : lsb = APInt::tcLSB(parts, partCount);
426 :
427 : /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
428 676322 : if (bits <= lsb)
429 : return lfExactlyZero;
430 398215 : if (bits == lsb + 1)
431 : return lfExactlyHalf;
432 308971 : if (bits <= partCount * APFloatBase::integerPartWidth &&
433 154351 : APInt::tcExtractBit(parts, bits - 1))
434 73246 : return lfMoreThanHalf;
435 :
436 : return lfLessThanHalf;
437 : }
438 :
439 : /* Shift DST right BITS bits noting lost fraction. */
440 : static lostFraction
441 : shiftRight(APFloatBase::integerPart *dst, unsigned int parts, unsigned int bits)
442 : {
443 : lostFraction lost_fraction;
444 :
445 345156 : lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
446 :
447 422340 : APInt::tcShiftRight(dst, parts, bits);
448 :
449 : return lost_fraction;
450 : }
451 :
452 : /* Combine the effect of two lost fractions. */
453 : static lostFraction
454 : combineLostFractions(lostFraction moreSignificant,
455 : lostFraction lessSignificant)
456 : {
457 321865 : if (lessSignificant != lfExactlyZero) {
458 145 : if (moreSignificant == lfExactlyZero)
459 : moreSignificant = lfLessThanHalf;
460 131 : else if (moreSignificant == lfExactlyHalf)
461 : moreSignificant = lfMoreThanHalf;
462 : }
463 :
464 : return moreSignificant;
465 : }
466 :
467 : /* The error from the true value, in half-ulps, on multiplying two
468 : floating point numbers, which differ from the value they
469 : approximate by at most HUE1 and HUE2 half-ulps, is strictly less
470 : than the returned value.
471 :
472 : See "How to Read Floating Point Numbers Accurately" by William D
473 : Clinger. */
474 : static unsigned int
475 : HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
476 : {
477 : assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
478 :
479 186909 : if (HUerr1 + HUerr2 == 0)
480 106373 : return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
481 : else
482 80536 : return inexactMultiply + 2 * (HUerr1 + HUerr2);
483 : }
484 :
485 : /* The number of ulps from the boundary (zero, or half if ISNEAREST)
486 : when the least significant BITS are truncated. BITS cannot be
487 : zero. */
488 : static APFloatBase::integerPart
489 186909 : ulpsFromBoundary(const APFloatBase::integerPart *parts, unsigned int bits,
490 : bool isNearest) {
491 : unsigned int count, partBits;
492 : APFloatBase::integerPart part, boundary;
493 :
494 : assert(bits != 0);
495 :
496 186909 : bits--;
497 186909 : count = bits / APFloatBase::integerPartWidth;
498 186909 : partBits = bits % APFloatBase::integerPartWidth + 1;
499 :
500 186909 : part = parts[count] & (~(APFloatBase::integerPart) 0 >> (APFloatBase::integerPartWidth - partBits));
501 :
502 186909 : if (isNearest)
503 182713 : boundary = (APFloatBase::integerPart) 1 << (partBits - 1);
504 : else
505 : boundary = 0;
506 :
507 186909 : if (count == 0) {
508 181732 : if (part - boundary <= boundary - part)
509 : return part - boundary;
510 : else
511 138071 : return boundary - part;
512 : }
513 :
514 5177 : if (part == boundary) {
515 12 : while (--count)
516 0 : if (parts[count])
517 : return ~(APFloatBase::integerPart) 0; /* A lot. */
518 :
519 12 : return parts[0];
520 5165 : } else if (part == boundary - 1) {
521 0 : while (--count)
522 0 : if (~parts[count])
523 : return ~(APFloatBase::integerPart) 0; /* A lot. */
524 :
525 0 : return -parts[0];
526 : }
527 :
528 : return ~(APFloatBase::integerPart) 0; /* A lot. */
529 : }
530 :
531 : /* Place pow(5, power) in DST, and return the number of parts used.
532 : DST must be at least one part larger than size of the answer. */
533 : static unsigned int
534 186877 : powerOf5(APFloatBase::integerPart *dst, unsigned int power) {
535 : static const APFloatBase::integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125, 15625, 78125 };
536 : APFloatBase::integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
537 186877 : pow5s[0] = 78125 * 5;
538 :
539 186877 : unsigned int partsCount[16] = { 1 };
540 : APFloatBase::integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
541 : unsigned int result;
542 : assert(power <= maxExponent);
543 :
544 : p1 = dst;
545 : p2 = scratch;
546 :
547 186877 : *p1 = firstEightPowers[power & 7];
548 186877 : power >>= 3;
549 :
550 : result = 1;
551 : pow5 = pow5s;
552 :
553 519109 : for (unsigned int n = 0; power; power >>= 1, n++) {
554 : unsigned int pc;
555 :
556 332232 : pc = partsCount[n];
557 :
558 : /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
559 332232 : if (pc == 0) {
560 266509 : pc = partsCount[n - 1];
561 266509 : APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
562 266509 : pc *= 2;
563 266509 : if (pow5[pc - 1] == 0)
564 : pc--;
565 266509 : partsCount[n] = pc;
566 : }
567 :
568 332232 : if (power & 1) {
569 : APFloatBase::integerPart *tmp;
570 :
571 175394 : APInt::tcFullMultiply(p2, p1, pow5, result, pc);
572 175394 : result += pc;
573 175394 : if (p2[result - 1] == 0)
574 : result--;
575 :
576 : /* Now result is in p1 with partsCount parts and p2 is scratch
577 : space. */
578 : tmp = p1;
579 : p1 = p2;
580 : p2 = tmp;
581 : }
582 :
583 332232 : pow5 += pc;
584 : }
585 :
586 186877 : if (p1 != dst)
587 28564 : APInt::tcAssign(dst, p1, result);
588 :
589 186877 : return result;
590 : }
591 :
592 : /* Zero at the end to avoid modular arithmetic when adding one; used
593 : when rounding up during hexadecimal output. */
594 : static const char hexDigitsLower[] = "0123456789abcdef0";
595 : static const char hexDigitsUpper[] = "0123456789ABCDEF0";
596 : static const char infinityL[] = "infinity";
597 : static const char infinityU[] = "INFINITY";
598 : static const char NaNL[] = "nan";
599 : static const char NaNU[] = "NAN";
600 :
601 : /* Write out an integerPart in hexadecimal, starting with the most
602 : significant nibble. Write out exactly COUNT hexdigits, return
603 : COUNT. */
604 : static unsigned int
605 : partAsHex (char *dst, APFloatBase::integerPart part, unsigned int count,
606 : const char *hexDigitChars)
607 : {
608 : unsigned int result = count;
609 :
610 : assert(count != 0 && count <= APFloatBase::integerPartWidth / 4);
611 :
612 176 : part >>= (APFloatBase::integerPartWidth - 4 * count);
613 763 : while (count--) {
614 587 : dst[count] = hexDigitChars[part & 0xf];
615 587 : part >>= 4;
616 : }
617 :
618 : return result;
619 : }
620 :
621 : /* Write out an unsigned decimal integer. */
622 : static char *
623 : writeUnsignedDecimal (char *dst, unsigned int n)
624 : {
625 : char buff[40], *p;
626 :
627 : p = buff;
628 : do
629 233 : *p++ = '0' + n % 10;
630 233 : while (n /= 10);
631 :
632 : do
633 233 : *dst++ = *--p;
634 233 : while (p != buff);
635 :
636 : return dst;
637 : }
638 :
639 : /* Write out a signed decimal integer. */
640 : static char *
641 176 : writeSignedDecimal (char *dst, int value)
642 : {
643 176 : if (value < 0) {
644 18 : *dst++ = '-';
645 18 : dst = writeUnsignedDecimal(dst, -(unsigned) value);
646 : } else
647 158 : dst = writeUnsignedDecimal(dst, value);
648 :
649 176 : return dst;
650 : }
651 :
652 : namespace detail {
653 : /* Constructors. */
654 7511786 : void IEEEFloat::initialize(const fltSemantics *ourSemantics) {
655 : unsigned int count;
656 :
657 7511786 : semantics = ourSemantics;
658 7511786 : count = partCount();
659 7511786 : if (count > 1)
660 271935 : significand.parts = new integerPart[count];
661 7511786 : }
662 :
663 17922495 : void IEEEFloat::freeSignificand() {
664 17922494 : if (needsCleanup())
665 280046 : delete [] significand.parts;
666 17922495 : }
667 :
668 1258581 : void IEEEFloat::assign(const IEEEFloat &rhs) {
669 : assert(semantics == rhs.semantics);
670 :
671 1258581 : sign = rhs.sign;
672 1258581 : category = rhs.category;
673 1258581 : exponent = rhs.exponent;
674 370625 : if (isFiniteNonZero() || category == fcNaN)
675 933244 : copySignificand(rhs);
676 1258581 : }
677 :
678 933543 : void IEEEFloat::copySignificand(const IEEEFloat &rhs) {
679 : assert(isFiniteNonZero() || category == fcNaN);
680 : assert(rhs.partCount() >= partCount());
681 :
682 933543 : APInt::tcAssign(significandParts(), rhs.significandParts(),
683 : partCount());
684 933543 : }
685 :
686 : /* Make this number a NaN, with an arbitrary but deterministic value
687 : for the significand. If double or longer, this is a signalling NaN,
688 : which may not be ideal. If float, this is QNaN(0). */
689 34300 : void IEEEFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill) {
690 34300 : category = fcNaN;
691 34300 : sign = Negative;
692 :
693 34300 : integerPart *significand = significandParts();
694 34300 : unsigned numParts = partCount();
695 :
696 : // Set the significand bits to the fill.
697 34300 : if (!fill || fill->getNumWords() < numParts)
698 12560 : APInt::tcSet(significand, 0, numParts);
699 34300 : if (fill) {
700 64136 : APInt::tcAssign(significand, fill->getRawData(),
701 64136 : std::min(fill->getNumWords(), numParts));
702 :
703 : // Zero out the excess bits of the significand.
704 32068 : unsigned bitsToPreserve = semantics->precision - 1;
705 32068 : unsigned part = bitsToPreserve / 64;
706 32068 : bitsToPreserve %= 64;
707 32068 : significand[part] &= ((1ULL << bitsToPreserve) - 1);
708 42394 : for (part++; part != numParts; ++part)
709 10326 : significand[part] = 0;
710 : }
711 :
712 34300 : unsigned QNaNBit = semantics->precision - 2;
713 :
714 34300 : if (SNaN) {
715 : // We always have to clear the QNaN bit to make it an SNaN.
716 15554 : APInt::tcClearBit(significand, QNaNBit);
717 :
718 : // If there are no bits set in the payload, we have to set
719 : // *something* to make it a NaN instead of an infinity;
720 : // conventionally, this is the next bit down from the QNaN bit.
721 15554 : if (APInt::tcIsZero(significand, numParts))
722 15538 : APInt::tcSetBit(significand, QNaNBit - 1);
723 : } else {
724 : // We always have to set the QNaN bit to make it a QNaN.
725 18746 : APInt::tcSetBit(significand, QNaNBit);
726 : }
727 :
728 : // For x87 extended precision, we want to make a NaN, not a
729 : // pseudo-NaN. Maybe we should expose the ability to make
730 : // pseudo-NaNs?
731 34300 : if (semantics == &semX87DoubleExtended)
732 10330 : APInt::tcSetBit(significand, QNaNBit + 1);
733 34300 : }
734 :
735 130185 : IEEEFloat &IEEEFloat::operator=(const IEEEFloat &rhs) {
736 130185 : if (this != &rhs) {
737 130147 : if (semantics != rhs.semantics) {
738 60661 : freeSignificand();
739 60661 : initialize(rhs.semantics);
740 : }
741 130147 : assign(rhs);
742 : }
743 :
744 130185 : return *this;
745 : }
746 :
747 5493280 : IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
748 5493280 : freeSignificand();
749 :
750 5493280 : semantics = rhs.semantics;
751 5493280 : significand = rhs.significand;
752 5493280 : exponent = rhs.exponent;
753 5493280 : category = rhs.category;
754 5493280 : sign = rhs.sign;
755 :
756 5493280 : rhs.semantics = &semBogus;
757 5493280 : return *this;
758 : }
759 :
760 659 : bool IEEEFloat::isDenormal() const {
761 662 : return isFiniteNonZero() && (exponent == semantics->minExponent) &&
762 120 : (APInt::tcExtractBit(significandParts(),
763 120 : semantics->precision - 1) == 0);
764 : }
765 :
766 35 : bool IEEEFloat::isSmallest() const {
767 : // The smallest number by magnitude in our format will be the smallest
768 : // denormal, i.e. the floating point number with exponent being minimum
769 : // exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
770 53 : return isFiniteNonZero() && exponent == semantics->minExponent &&
771 18 : significandMSB() == 0;
772 : }
773 :
774 15 : bool IEEEFloat::isSignificandAllOnes() const {
775 : // Test if the significand excluding the integral bit is all ones. This allows
776 : // us to test for binade boundaries.
777 15 : const integerPart *Parts = significandParts();
778 15 : const unsigned PartCount = partCount();
779 23 : for (unsigned i = 0; i < PartCount - 1; i++)
780 12 : if (~Parts[i])
781 : return false;
782 :
783 : // Set the unused high bits to all ones when we compare.
784 11 : const unsigned NumHighBits =
785 11 : PartCount*integerPartWidth - semantics->precision + 1;
786 : assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
787 : "fill than integerPartWidth");
788 11 : const integerPart HighBitFill =
789 11 : ~integerPart(0) << (integerPartWidth - NumHighBits);
790 11 : if (~(Parts[PartCount - 1] | HighBitFill))
791 3 : return false;
792 :
793 : return true;
794 : }
795 :
796 8 : bool IEEEFloat::isSignificandAllZeros() const {
797 : // Test if the significand excluding the integral bit is all zeros. This
798 : // allows us to test for binade boundaries.
799 8 : const integerPart *Parts = significandParts();
800 8 : const unsigned PartCount = partCount();
801 :
802 12 : for (unsigned i = 0; i < PartCount - 1; i++)
803 8 : if (Parts[i])
804 : return false;
805 :
806 4 : const unsigned NumHighBits =
807 4 : PartCount*integerPartWidth - semantics->precision + 1;
808 : assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
809 : "clear than integerPartWidth");
810 4 : const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
811 :
812 4 : if (Parts[PartCount - 1] & HighBitMask)
813 0 : return false;
814 :
815 : return true;
816 : }
817 :
818 33 : bool IEEEFloat::isLargest() const {
819 : // The largest number by magnitude in our format will be the floating point
820 : // number with maximum exponent and with significand that is all ones.
821 33 : return isFiniteNonZero() && exponent == semantics->maxExponent
822 4 : && isSignificandAllOnes();
823 : }
824 :
825 214 : bool IEEEFloat::isInteger() const {
826 : // This could be made more efficient; I'm going for obviously correct.
827 : if (!isFinite()) return false;
828 211 : IEEEFloat truncated = *this;
829 211 : truncated.roundToIntegral(rmTowardZero);
830 211 : return compare(truncated) == cmpEqual;
831 : }
832 :
833 1131332 : bool IEEEFloat::bitwiseIsEqual(const IEEEFloat &rhs) const {
834 1131332 : if (this == &rhs)
835 : return true;
836 1131332 : if (semantics != rhs.semantics ||
837 1131332 : category != rhs.category ||
838 : sign != rhs.sign)
839 : return false;
840 1103503 : if (category==fcZero || category==fcInfinity)
841 : return true;
842 :
843 1007343 : if (isFiniteNonZero() && exponent != rhs.exponent)
844 : return false;
845 :
846 1019951 : return std::equal(significandParts(), significandParts() + partCount(),
847 : rhs.significandParts());
848 : }
849 :
850 476335 : IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, integerPart value) {
851 476335 : initialize(&ourSemantics);
852 476335 : sign = 0;
853 476335 : category = fcNormal;
854 476335 : zeroSignificand();
855 476335 : exponent = ourSemantics.precision - 1;
856 476335 : significandParts()[0] = value;
857 476335 : normalize(rmNearestTiesToEven, lfExactlyZero);
858 476335 : }
859 :
860 723043 : IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics) {
861 723043 : initialize(&ourSemantics);
862 723043 : category = fcZero;
863 723043 : sign = false;
864 723043 : }
865 :
866 : // Delegate to the previous constructor, because later copy constructor may
867 : // actually inspects category, which can't be garbage.
868 273296 : IEEEFloat::IEEEFloat(const fltSemantics &ourSemantics, uninitializedTag tag)
869 273296 : : IEEEFloat(ourSemantics) {}
870 :
871 1127663 : IEEEFloat::IEEEFloat(const IEEEFloat &rhs) {
872 1127663 : initialize(rhs.semantics);
873 1127663 : assign(rhs);
874 1127663 : }
875 :
876 5013968 : IEEEFloat::IEEEFloat(IEEEFloat &&rhs) : semantics(&semBogus) {
877 5013968 : *this = std::move(rhs);
878 5013968 : }
879 :
880 12330878 : IEEEFloat::~IEEEFloat() { freeSignificand(); }
881 :
882 42753001 : unsigned int IEEEFloat::partCount() const {
883 85506002 : return partCountForBits(semantics->precision + 1);
884 : }
885 :
886 6381117 : const IEEEFloat::integerPart *IEEEFloat::significandParts() const {
887 6381117 : return const_cast<IEEEFloat *>(this)->significandParts();
888 : }
889 :
890 11264043 : IEEEFloat::integerPart *IEEEFloat::significandParts() {
891 11264043 : if (partCount() > 1)
892 639436 : return significand.parts;
893 : else
894 10624607 : return &significand.part;
895 : }
896 :
897 477319 : void IEEEFloat::zeroSignificand() {
898 477319 : APInt::tcSet(significandParts(), 0, partCount());
899 477319 : }
900 :
901 : /* Increment an fcNormal floating point number's significand. */
902 62700 : void IEEEFloat::incrementSignificand() {
903 : integerPart carry;
904 :
905 62700 : carry = APInt::tcIncrement(significandParts(), partCount());
906 :
907 : /* Our callers should never cause us to overflow. */
908 : assert(carry == 0);
909 : (void)carry;
910 62700 : }
911 :
912 : /* Add the significand of the RHS. Returns the carry flag. */
913 2195 : IEEEFloat::integerPart IEEEFloat::addSignificand(const IEEEFloat &rhs) {
914 : integerPart *parts;
915 :
916 2195 : parts = significandParts();
917 :
918 : assert(semantics == rhs.semantics);
919 : assert(exponent == rhs.exponent);
920 :
921 2195 : return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
922 : }
923 :
924 : /* Subtract the significand of the RHS with a borrow flag. Returns
925 : the borrow flag. */
926 1045 : IEEEFloat::integerPart IEEEFloat::subtractSignificand(const IEEEFloat &rhs,
927 : integerPart borrow) {
928 : integerPart *parts;
929 :
930 1045 : parts = significandParts();
931 :
932 : assert(semantics == rhs.semantics);
933 : assert(exponent == rhs.exponent);
934 :
935 1045 : return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
936 1045 : partCount());
937 : }
938 :
939 : /* Multiply the significand of the RHS. If ADDEND is non-NULL, add it
940 : on to the full-precision result of the multiplication. Returns the
941 : lost fraction. */
942 77246 : lostFraction IEEEFloat::multiplySignificand(const IEEEFloat &rhs,
943 : const IEEEFloat *addend) {
944 : unsigned int omsb; // One, not zero, based MSB.
945 : unsigned int partsCount, newPartsCount, precision;
946 : integerPart *lhsSignificand;
947 : integerPart scratch[4];
948 : integerPart *fullSignificand;
949 : lostFraction lost_fraction;
950 : bool ignored;
951 :
952 : assert(semantics == rhs.semantics);
953 :
954 77246 : precision = semantics->precision;
955 :
956 : // Allocate space for twice as many bits as the original significand, plus one
957 : // extra bit for the addition to overflow into.
958 77246 : newPartsCount = partCountForBits(precision * 2 + 1);
959 :
960 77246 : if (newPartsCount > 4)
961 0 : fullSignificand = new integerPart[newPartsCount];
962 : else
963 : fullSignificand = scratch;
964 :
965 77246 : lhsSignificand = significandParts();
966 77246 : partsCount = partCount();
967 :
968 77246 : APInt::tcFullMultiply(fullSignificand, lhsSignificand,
969 : rhs.significandParts(), partsCount, partsCount);
970 :
971 : lost_fraction = lfExactlyZero;
972 77246 : omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
973 77246 : exponent += rhs.exponent;
974 :
975 : // Assume the operands involved in the multiplication are single-precision
976 : // FP, and the two multiplicants are:
977 : // *this = a23 . a22 ... a0 * 2^e1
978 : // rhs = b23 . b22 ... b0 * 2^e2
979 : // the result of multiplication is:
980 : // *this = c48 c47 c46 . c45 ... c0 * 2^(e1+e2)
981 : // Note that there are three significant bits at the left-hand side of the
982 : // radix point: two for the multiplication, and an overflow bit for the
983 : // addition (that will always be zero at this point). Move the radix point
984 : // toward left by two bits, and adjust exponent accordingly.
985 77246 : exponent += 2;
986 :
987 77246 : if (addend && addend->isNonZero()) {
988 : // The intermediate result of the multiplication has "2 * precision"
989 : // signicant bit; adjust the addend to be consistent with mul result.
990 : //
991 42 : Significand savedSignificand = significand;
992 42 : const fltSemantics *savedSemantics = semantics;
993 : fltSemantics extendedSemantics;
994 : opStatus status;
995 : unsigned int extendedPrecision;
996 :
997 : // Normalize our MSB to one below the top bit to allow for overflow.
998 : extendedPrecision = 2 * precision + 1;
999 42 : if (omsb != extendedPrecision - 1) {
1000 : assert(extendedPrecision > omsb);
1001 33 : APInt::tcShiftLeft(fullSignificand, newPartsCount,
1002 33 : (extendedPrecision - 1) - omsb);
1003 33 : exponent -= (extendedPrecision - 1) - omsb;
1004 : }
1005 :
1006 : /* Create new semantics. */
1007 42 : extendedSemantics = *semantics;
1008 42 : extendedSemantics.precision = extendedPrecision;
1009 :
1010 42 : if (newPartsCount == 1)
1011 16 : significand.part = fullSignificand[0];
1012 : else
1013 26 : significand.parts = fullSignificand;
1014 42 : semantics = &extendedSemantics;
1015 :
1016 42 : IEEEFloat extendedAddend(*addend);
1017 42 : status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
1018 : assert(status == opOK);
1019 : (void)status;
1020 :
1021 : // Shift the significand of the addend right by one bit. This guarantees
1022 : // that the high bit of the significand is zero (same as fullSignificand),
1023 : // so the addition will overflow (if it does overflow at all) into the top bit.
1024 42 : lost_fraction = extendedAddend.shiftSignificandRight(1);
1025 : assert(lost_fraction == lfExactlyZero &&
1026 : "Lost precision while shifting addend for fused-multiply-add.");
1027 :
1028 42 : lost_fraction = addOrSubtractSignificand(extendedAddend, false);
1029 :
1030 : /* Restore our state. */
1031 42 : if (newPartsCount == 1)
1032 16 : fullSignificand[0] = significand.part;
1033 42 : significand = savedSignificand;
1034 42 : semantics = savedSemantics;
1035 :
1036 42 : omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1037 : }
1038 :
1039 : // Convert the result having "2 * precision" significant-bits back to the one
1040 : // having "precision" significant-bits. First, move the radix point from
1041 : // poision "2*precision - 1" to "precision - 1". The exponent need to be
1042 : // adjusted by "2*precision - 1" - "precision - 1" = "precision".
1043 77246 : exponent -= precision + 1;
1044 :
1045 : // In case MSB resides at the left-hand side of radix point, shift the
1046 : // mantissa right by some amount to make sure the MSB reside right before
1047 : // the radix point (i.e. "MSB . rest-significant-bits").
1048 : //
1049 : // Note that the result is not normalized when "omsb < precision". So, the
1050 : // caller needs to call IEEEFloat::normalize() if normalized value is
1051 : // expected.
1052 77246 : if (omsb > precision) {
1053 : unsigned int bits, significantParts;
1054 : lostFraction lf;
1055 :
1056 77184 : bits = omsb - precision;
1057 : significantParts = partCountForBits(omsb);
1058 : lf = shiftRight(fullSignificand, significantParts, bits);
1059 : lost_fraction = combineLostFractions(lf, lost_fraction);
1060 77184 : exponent += bits;
1061 : }
1062 :
1063 77246 : APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1064 :
1065 77246 : if (newPartsCount > 4)
1066 0 : delete [] fullSignificand;
1067 :
1068 77246 : return lost_fraction;
1069 : }
1070 :
1071 : /* Multiply the significands of LHS and RHS to DST. */
1072 112961 : lostFraction IEEEFloat::divideSignificand(const IEEEFloat &rhs) {
1073 : unsigned int bit, i, partsCount;
1074 : const integerPart *rhsSignificand;
1075 : integerPart *lhsSignificand, *dividend, *divisor;
1076 : integerPart scratch[4];
1077 : lostFraction lost_fraction;
1078 :
1079 : assert(semantics == rhs.semantics);
1080 :
1081 112961 : lhsSignificand = significandParts();
1082 112961 : rhsSignificand = rhs.significandParts();
1083 112961 : partsCount = partCount();
1084 :
1085 112961 : if (partsCount > 2)
1086 0 : dividend = new integerPart[partsCount * 2];
1087 : else
1088 : dividend = scratch;
1089 :
1090 112961 : divisor = dividend + partsCount;
1091 :
1092 : /* Copy the dividend and divisor as they will be modified in-place. */
1093 241857 : for (i = 0; i < partsCount; i++) {
1094 128896 : dividend[i] = lhsSignificand[i];
1095 128896 : divisor[i] = rhsSignificand[i];
1096 128896 : lhsSignificand[i] = 0;
1097 : }
1098 :
1099 112961 : exponent -= rhs.exponent;
1100 :
1101 112961 : unsigned int precision = semantics->precision;
1102 :
1103 : /* Normalize the divisor. */
1104 112961 : bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1105 112961 : if (bit) {
1106 16 : exponent += bit;
1107 16 : APInt::tcShiftLeft(divisor, partsCount, bit);
1108 : }
1109 :
1110 : /* Normalize the dividend. */
1111 112961 : bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1112 112961 : if (bit) {
1113 16 : exponent -= bit;
1114 16 : APInt::tcShiftLeft(dividend, partsCount, bit);
1115 : }
1116 :
1117 : /* Ensure the dividend >= divisor initially for the loop below.
1118 : Incidentally, this means that the division loop below is
1119 : guaranteed to set the integer bit to one. */
1120 112961 : if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1121 30786 : exponent--;
1122 30786 : APInt::tcShiftLeft(dividend, partsCount, 1);
1123 : assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1124 : }
1125 :
1126 : /* Long division. */
1127 8192816 : for (bit = precision; bit; bit -= 1) {
1128 8079855 : if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1129 2389958 : APInt::tcSubtract(dividend, divisor, 0, partsCount);
1130 2389958 : APInt::tcSetBit(lhsSignificand, bit - 1);
1131 : }
1132 :
1133 8079855 : APInt::tcShiftLeft(dividend, partsCount, 1);
1134 : }
1135 :
1136 : /* Figure out the lost fraction. */
1137 112961 : int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1138 :
1139 112961 : if (cmp > 0)
1140 : lost_fraction = lfMoreThanHalf;
1141 70882 : else if (cmp == 0)
1142 : lost_fraction = lfExactlyHalf;
1143 70882 : else if (APInt::tcIsZero(dividend, partsCount))
1144 : lost_fraction = lfExactlyZero;
1145 : else
1146 : lost_fraction = lfLessThanHalf;
1147 :
1148 112961 : if (partsCount > 2)
1149 0 : delete [] dividend;
1150 :
1151 112961 : return lost_fraction;
1152 : }
1153 :
1154 1373112 : unsigned int IEEEFloat::significandMSB() const {
1155 1373112 : return APInt::tcMSB(significandParts(), partCount());
1156 : }
1157 :
1158 301 : unsigned int IEEEFloat::significandLSB() const {
1159 301 : return APInt::tcLSB(significandParts(), partCount());
1160 : }
1161 :
1162 : /* Note that a zero result is NOT normalized to fcZero. */
1163 247565 : lostFraction IEEEFloat::shiftSignificandRight(unsigned int bits) {
1164 : /* Our exponent should not overflow. */
1165 : assert((ExponentType) (exponent + bits) >= exponent);
1166 :
1167 247565 : exponent += bits;
1168 :
1169 247565 : return shiftRight(significandParts(), partCount(), bits);
1170 : }
1171 :
1172 : /* Shift the significand left BITS bits, subtract BITS from its exponent. */
1173 383831 : void IEEEFloat::shiftSignificandLeft(unsigned int bits) {
1174 : assert(bits < semantics->precision);
1175 :
1176 383831 : if (bits) {
1177 383831 : unsigned int partsCount = partCount();
1178 :
1179 383831 : APInt::tcShiftLeft(significandParts(), partsCount, bits);
1180 383831 : exponent -= bits;
1181 :
1182 : assert(!APInt::tcIsZero(significandParts(), partsCount));
1183 : }
1184 383831 : }
1185 :
1186 : IEEEFloat::cmpResult
1187 3062 : IEEEFloat::compareAbsoluteValue(const IEEEFloat &rhs) const {
1188 : int compare;
1189 :
1190 : assert(semantics == rhs.semantics);
1191 : assert(isFiniteNonZero());
1192 : assert(rhs.isFiniteNonZero());
1193 :
1194 3062 : compare = exponent - rhs.exponent;
1195 :
1196 : /* If exponents are equal, do an unsigned bignum comparison of the
1197 : significands. */
1198 3062 : if (compare == 0)
1199 2277 : compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1200 : partCount());
1201 :
1202 3062 : if (compare > 0)
1203 : return cmpGreaterThan;
1204 2242 : else if (compare < 0)
1205 : return cmpLessThan;
1206 : else
1207 1629 : return cmpEqual;
1208 : }
1209 :
1210 : /* Handle overflow. Sign is preserved. We either become infinity or
1211 : the largest finite number. */
1212 203890 : IEEEFloat::opStatus IEEEFloat::handleOverflow(roundingMode rounding_mode) {
1213 : /* Infinity? */
1214 407780 : if (rounding_mode == rmNearestTiesToEven ||
1215 203890 : rounding_mode == rmNearestTiesToAway ||
1216 0 : (rounding_mode == rmTowardPositive && !sign) ||
1217 0 : (rounding_mode == rmTowardNegative && sign)) {
1218 203890 : category = fcInfinity;
1219 203890 : return (opStatus) (opOverflow | opInexact);
1220 : }
1221 :
1222 : /* Otherwise we become the largest finite number. */
1223 0 : category = fcNormal;
1224 0 : exponent = semantics->maxExponent;
1225 0 : APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1226 0 : semantics->precision);
1227 :
1228 0 : return opInexact;
1229 : }
1230 :
1231 : /* Returns TRUE if, when truncating the current number, with BIT the
1232 : new LSB, with the given lost fraction and rounding mode, the result
1233 : would need to be rounded away from zero (i.e., by increasing the
1234 : signficand). This routine must work for fcZero of both signs, and
1235 : fcNormal numbers. */
1236 382700 : bool IEEEFloat::roundAwayFromZero(roundingMode rounding_mode,
1237 : lostFraction lost_fraction,
1238 : unsigned int bit) const {
1239 : /* NaNs and infinities should not have lost fractions. */
1240 : assert(isFiniteNonZero() || category == fcZero);
1241 :
1242 : /* Current callers never pass this so we don't handle it. */
1243 : assert(lost_fraction != lfExactlyZero);
1244 :
1245 382700 : switch (rounding_mode) {
1246 19 : case rmNearestTiesToAway:
1247 19 : return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
1248 :
1249 381235 : case rmNearestTiesToEven:
1250 381235 : if (lost_fraction == lfMoreThanHalf)
1251 : return true;
1252 :
1253 : /* Our zeroes don't have a significand to test. */
1254 318605 : if (lost_fraction == lfExactlyHalf && category != fcZero)
1255 243249 : return APInt::tcExtractBit(significandParts(), bit);
1256 :
1257 : return false;
1258 :
1259 : case rmTowardZero:
1260 : return false;
1261 :
1262 38 : case rmTowardPositive:
1263 38 : return !sign;
1264 :
1265 30 : case rmTowardNegative:
1266 30 : return sign;
1267 : }
1268 0 : llvm_unreachable("Invalid rounding mode found");
1269 : }
1270 :
1271 1214648 : IEEEFloat::opStatus IEEEFloat::normalize(roundingMode rounding_mode,
1272 : lostFraction lost_fraction) {
1273 : unsigned int omsb; /* One, not zero, based MSB. */
1274 : int exponentChange;
1275 :
1276 : if (!isFiniteNonZero())
1277 : return opOK;
1278 :
1279 : /* Before rounding normalize the exponent of fcNormal numbers. */
1280 1214577 : omsb = significandMSB() + 1;
1281 :
1282 1214577 : if (omsb) {
1283 : /* OMSB is numbered from 1. We want to place it in the integer
1284 : bit numbered PRECISION if possible, with a compensating change in
1285 : the exponent. */
1286 1193496 : exponentChange = omsb - semantics->precision;
1287 :
1288 : /* If the resulting exponent is too high, overflow according to
1289 : the rounding mode. */
1290 1193496 : if (exponent + exponentChange > semantics->maxExponent)
1291 203882 : return handleOverflow(rounding_mode);
1292 :
1293 : /* Subnormal numbers have exponent minExponent, and their MSB
1294 : is forced based on that. */
1295 989614 : if (exponent + exponentChange < semantics->minExponent)
1296 15966 : exponentChange = semantics->minExponent - exponent;
1297 :
1298 : /* Shifting left is easy as we don't lose precision. */
1299 989614 : if (exponentChange < 0) {
1300 : assert(lost_fraction == lfExactlyZero);
1301 :
1302 383483 : shiftSignificandLeft(-exponentChange);
1303 :
1304 383483 : return opOK;
1305 : }
1306 :
1307 606131 : if (exponentChange > 0) {
1308 : lostFraction lf;
1309 :
1310 : /* Shift right and capture any new lost fraction. */
1311 244681 : lf = shiftSignificandRight(exponentChange);
1312 :
1313 : lost_fraction = combineLostFractions(lf, lost_fraction);
1314 :
1315 : /* Keep OMSB up-to-date. */
1316 244681 : if (omsb > (unsigned) exponentChange)
1317 1392 : omsb -= exponentChange;
1318 : else
1319 : omsb = 0;
1320 : }
1321 : }
1322 :
1323 : /* Now round the number according to rounding_mode given the lost
1324 : fraction. */
1325 :
1326 : /* As specified in IEEE 754, since we do not trap we do not report
1327 : underflow for exact results. */
1328 627212 : if (lost_fraction == lfExactlyZero) {
1329 : /* Canonicalize zeroes. */
1330 245738 : if (omsb == 0)
1331 10756 : category = fcZero;
1332 :
1333 245738 : return opOK;
1334 : }
1335 :
1336 : /* Increment the significand if we're rounding away from zero. */
1337 381474 : if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1338 62687 : if (omsb == 0)
1339 10294 : exponent = semantics->minExponent;
1340 :
1341 62687 : incrementSignificand();
1342 62687 : omsb = significandMSB() + 1;
1343 :
1344 : /* Did the significand increment overflow? */
1345 62687 : if (omsb == (unsigned) semantics->precision + 1) {
1346 : /* Renormalize by incrementing the exponent and shifting our
1347 : significand right one. However if we already have the
1348 : maximum exponent we overflow to infinity. */
1349 309 : if (exponent == semantics->maxExponent) {
1350 10 : category = fcInfinity;
1351 :
1352 10 : return (opStatus) (opOverflow | opInexact);
1353 : }
1354 :
1355 299 : shiftSignificandRight(1);
1356 :
1357 299 : return opInexact;
1358 : }
1359 : }
1360 :
1361 : /* The normal case - we were and are not denormal, and any
1362 : significand increment above didn't overflow. */
1363 381165 : if (omsb == semantics->precision)
1364 : return opInexact;
1365 :
1366 : /* We have a non-zero denormal. */
1367 : assert(omsb < semantics->precision);
1368 :
1369 : /* Canonicalize zeroes. */
1370 15655 : if (omsb == 0)
1371 173 : category = fcZero;
1372 :
1373 : /* The fcZero case is a denormal that underflowed to zero. */
1374 : return (opStatus) (opUnderflow | opInexact);
1375 : }
1376 :
1377 5123 : IEEEFloat::opStatus IEEEFloat::addOrSubtractSpecials(const IEEEFloat &rhs,
1378 : bool subtract) {
1379 5123 : switch (PackCategoriesIntoKey(category, rhs.category)) {
1380 0 : default:
1381 0 : llvm_unreachable(nullptr);
1382 :
1383 : case PackCategoriesIntoKey(fcNaN, fcZero):
1384 : case PackCategoriesIntoKey(fcNaN, fcNormal):
1385 : case PackCategoriesIntoKey(fcNaN, fcInfinity):
1386 : case PackCategoriesIntoKey(fcNaN, fcNaN):
1387 : case PackCategoriesIntoKey(fcNormal, fcZero):
1388 : case PackCategoriesIntoKey(fcInfinity, fcNormal):
1389 : case PackCategoriesIntoKey(fcInfinity, fcZero):
1390 : return opOK;
1391 :
1392 107 : case PackCategoriesIntoKey(fcZero, fcNaN):
1393 : case PackCategoriesIntoKey(fcNormal, fcNaN):
1394 : case PackCategoriesIntoKey(fcInfinity, fcNaN):
1395 : // We need to be sure to flip the sign here for subtraction because we
1396 : // don't have a separate negate operation so -NaN becomes 0 - NaN here.
1397 107 : sign = rhs.sign ^ subtract;
1398 107 : category = fcNaN;
1399 107 : copySignificand(rhs);
1400 107 : return opOK;
1401 :
1402 90 : case PackCategoriesIntoKey(fcNormal, fcInfinity):
1403 : case PackCategoriesIntoKey(fcZero, fcInfinity):
1404 90 : category = fcInfinity;
1405 90 : sign = rhs.sign ^ subtract;
1406 90 : return opOK;
1407 :
1408 771 : case PackCategoriesIntoKey(fcZero, fcNormal):
1409 771 : assign(rhs);
1410 771 : sign = rhs.sign ^ subtract;
1411 771 : return opOK;
1412 :
1413 : case PackCategoriesIntoKey(fcZero, fcZero):
1414 : /* Sign depends on rounding mode; handled by caller. */
1415 : return opOK;
1416 :
1417 10 : case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1418 : /* Differently signed infinities can only be validly
1419 : subtracted. */
1420 10 : if (((sign ^ rhs.sign)!=0) != subtract) {
1421 4 : makeNaN();
1422 4 : return opInvalidOp;
1423 : }
1424 :
1425 : return opOK;
1426 :
1427 3198 : case PackCategoriesIntoKey(fcNormal, fcNormal):
1428 3198 : return opDivByZero;
1429 : }
1430 : }
1431 :
1432 : /* Add or subtract two normal numbers. */
1433 3240 : lostFraction IEEEFloat::addOrSubtractSignificand(const IEEEFloat &rhs,
1434 : bool subtract) {
1435 : integerPart carry;
1436 : lostFraction lost_fraction;
1437 : int bits;
1438 :
1439 : /* Determine if the operation on the absolute values is effectively
1440 : an addition or subtraction. */
1441 3240 : subtract ^= static_cast<bool>(sign ^ rhs.sign);
1442 :
1443 : /* Are we bigger exponent-wise than the RHS? */
1444 3240 : bits = exponent - rhs.exponent;
1445 :
1446 : /* Subtraction is more subtle than one might naively expect. */
1447 3240 : if (subtract) {
1448 2090 : IEEEFloat temp_rhs(rhs);
1449 : bool reverse;
1450 :
1451 1045 : if (bits == 0) {
1452 697 : reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
1453 : lost_fraction = lfExactlyZero;
1454 348 : } else if (bits > 0) {
1455 254 : lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1456 254 : shiftSignificandLeft(1);
1457 : reverse = false;
1458 : } else {
1459 94 : lost_fraction = shiftSignificandRight(-bits - 1);
1460 94 : temp_rhs.shiftSignificandLeft(1);
1461 : reverse = true;
1462 : }
1463 :
1464 697 : if (reverse) {
1465 : carry = temp_rhs.subtractSignificand
1466 114 : (*this, lost_fraction != lfExactlyZero);
1467 114 : copySignificand(temp_rhs);
1468 114 : sign = !sign;
1469 : } else {
1470 : carry = subtractSignificand
1471 931 : (temp_rhs, lost_fraction != lfExactlyZero);
1472 : }
1473 :
1474 : /* Invert the lost fraction - it was on the RHS and
1475 : subtracted. */
1476 1045 : if (lost_fraction == lfLessThanHalf)
1477 : lost_fraction = lfMoreThanHalf;
1478 992 : else if (lost_fraction == lfMoreThanHalf)
1479 : lost_fraction = lfLessThanHalf;
1480 :
1481 : /* The code above is intended to ensure that no borrow is
1482 : necessary. */
1483 : assert(!carry);
1484 : (void)carry;
1485 : } else {
1486 2195 : if (bits > 0) {
1487 2686 : IEEEFloat temp_rhs(rhs);
1488 :
1489 1343 : lost_fraction = temp_rhs.shiftSignificandRight(bits);
1490 1343 : carry = addSignificand(temp_rhs);
1491 : } else {
1492 852 : lost_fraction = shiftSignificandRight(-bits);
1493 852 : carry = addSignificand(rhs);
1494 : }
1495 :
1496 : /* We have a guard bit; generating a carry cannot happen. */
1497 : assert(!carry);
1498 : (void)carry;
1499 : }
1500 :
1501 3240 : return lost_fraction;
1502 : }
1503 :
1504 1955 : IEEEFloat::opStatus IEEEFloat::multiplySpecials(const IEEEFloat &rhs) {
1505 1955 : switch (PackCategoriesIntoKey(category, rhs.category)) {
1506 0 : default:
1507 0 : llvm_unreachable(nullptr);
1508 :
1509 124 : case PackCategoriesIntoKey(fcNaN, fcZero):
1510 : case PackCategoriesIntoKey(fcNaN, fcNormal):
1511 : case PackCategoriesIntoKey(fcNaN, fcInfinity):
1512 : case PackCategoriesIntoKey(fcNaN, fcNaN):
1513 124 : sign = false;
1514 124 : return opOK;
1515 :
1516 54 : case PackCategoriesIntoKey(fcZero, fcNaN):
1517 : case PackCategoriesIntoKey(fcNormal, fcNaN):
1518 : case PackCategoriesIntoKey(fcInfinity, fcNaN):
1519 54 : sign = false;
1520 54 : category = fcNaN;
1521 54 : copySignificand(rhs);
1522 54 : return opOK;
1523 :
1524 189 : case PackCategoriesIntoKey(fcNormal, fcInfinity):
1525 : case PackCategoriesIntoKey(fcInfinity, fcNormal):
1526 : case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1527 189 : category = fcInfinity;
1528 189 : return opOK;
1529 :
1530 258 : case PackCategoriesIntoKey(fcZero, fcNormal):
1531 : case PackCategoriesIntoKey(fcNormal, fcZero):
1532 : case PackCategoriesIntoKey(fcZero, fcZero):
1533 258 : category = fcZero;
1534 258 : return opOK;
1535 :
1536 62 : case PackCategoriesIntoKey(fcZero, fcInfinity):
1537 : case PackCategoriesIntoKey(fcInfinity, fcZero):
1538 62 : makeNaN();
1539 62 : return opInvalidOp;
1540 :
1541 : case PackCategoriesIntoKey(fcNormal, fcNormal):
1542 : return opOK;
1543 : }
1544 : }
1545 :
1546 2218 : IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
1547 2218 : switch (PackCategoriesIntoKey(category, rhs.category)) {
1548 0 : default:
1549 0 : llvm_unreachable(nullptr);
1550 :
1551 15 : case PackCategoriesIntoKey(fcZero, fcNaN):
1552 : case PackCategoriesIntoKey(fcNormal, fcNaN):
1553 : case PackCategoriesIntoKey(fcInfinity, fcNaN):
1554 15 : category = fcNaN;
1555 15 : copySignificand(rhs);
1556 : LLVM_FALLTHROUGH;
1557 65 : case PackCategoriesIntoKey(fcNaN, fcZero):
1558 : case PackCategoriesIntoKey(fcNaN, fcNormal):
1559 : case PackCategoriesIntoKey(fcNaN, fcInfinity):
1560 : case PackCategoriesIntoKey(fcNaN, fcNaN):
1561 65 : sign = false;
1562 : LLVM_FALLTHROUGH;
1563 : case PackCategoriesIntoKey(fcInfinity, fcZero):
1564 : case PackCategoriesIntoKey(fcInfinity, fcNormal):
1565 : case PackCategoriesIntoKey(fcZero, fcInfinity):
1566 : case PackCategoriesIntoKey(fcZero, fcNormal):
1567 : return opOK;
1568 :
1569 24 : case PackCategoriesIntoKey(fcNormal, fcInfinity):
1570 24 : category = fcZero;
1571 24 : return opOK;
1572 :
1573 41 : case PackCategoriesIntoKey(fcNormal, fcZero):
1574 41 : category = fcInfinity;
1575 41 : return opDivByZero;
1576 :
1577 34 : case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1578 : case PackCategoriesIntoKey(fcZero, fcZero):
1579 34 : makeNaN();
1580 34 : return opInvalidOp;
1581 :
1582 : case PackCategoriesIntoKey(fcNormal, fcNormal):
1583 : return opOK;
1584 : }
1585 : }
1586 :
1587 109 : IEEEFloat::opStatus IEEEFloat::modSpecials(const IEEEFloat &rhs) {
1588 109 : switch (PackCategoriesIntoKey(category, rhs.category)) {
1589 0 : default:
1590 0 : llvm_unreachable(nullptr);
1591 :
1592 : case PackCategoriesIntoKey(fcNaN, fcZero):
1593 : case PackCategoriesIntoKey(fcNaN, fcNormal):
1594 : case PackCategoriesIntoKey(fcNaN, fcInfinity):
1595 : case PackCategoriesIntoKey(fcNaN, fcNaN):
1596 : case PackCategoriesIntoKey(fcZero, fcInfinity):
1597 : case PackCategoriesIntoKey(fcZero, fcNormal):
1598 : case PackCategoriesIntoKey(fcNormal, fcInfinity):
1599 : return opOK;
1600 :
1601 9 : case PackCategoriesIntoKey(fcZero, fcNaN):
1602 : case PackCategoriesIntoKey(fcNormal, fcNaN):
1603 : case PackCategoriesIntoKey(fcInfinity, fcNaN):
1604 9 : sign = false;
1605 9 : category = fcNaN;
1606 9 : copySignificand(rhs);
1607 9 : return opOK;
1608 :
1609 32 : case PackCategoriesIntoKey(fcNormal, fcZero):
1610 : case PackCategoriesIntoKey(fcInfinity, fcZero):
1611 : case PackCategoriesIntoKey(fcInfinity, fcNormal):
1612 : case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1613 : case PackCategoriesIntoKey(fcZero, fcZero):
1614 32 : makeNaN();
1615 32 : return opInvalidOp;
1616 :
1617 : case PackCategoriesIntoKey(fcNormal, fcNormal):
1618 : return opOK;
1619 : }
1620 : }
1621 :
1622 : /* Change sign. */
1623 46353 : void IEEEFloat::changeSign() {
1624 : /* Look mummy, this one's easy. */
1625 46353 : sign = !sign;
1626 46353 : }
1627 :
1628 : /* Normalized addition or subtraction. */
1629 5123 : IEEEFloat::opStatus IEEEFloat::addOrSubtract(const IEEEFloat &rhs,
1630 : roundingMode rounding_mode,
1631 : bool subtract) {
1632 : opStatus fs;
1633 :
1634 5123 : fs = addOrSubtractSpecials(rhs, subtract);
1635 :
1636 : /* This return code means it was not a simple case. */
1637 5123 : if (fs == opDivByZero) {
1638 : lostFraction lost_fraction;
1639 :
1640 3198 : lost_fraction = addOrSubtractSignificand(rhs, subtract);
1641 3198 : fs = normalize(rounding_mode, lost_fraction);
1642 :
1643 : /* Can only be zero if we lost no fraction. */
1644 : assert(category != fcZero || lost_fraction == lfExactlyZero);
1645 : }
1646 :
1647 : /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1648 : positive zero unless rounding to minus infinity, except that
1649 : adding two like-signed zeroes gives that zero. */
1650 5123 : if (category == fcZero) {
1651 534 : if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
1652 322 : sign = (rounding_mode == rmTowardNegative);
1653 : }
1654 :
1655 5123 : return fs;
1656 : }
1657 :
1658 : /* Normalized addition. */
1659 3179 : IEEEFloat::opStatus IEEEFloat::add(const IEEEFloat &rhs,
1660 : roundingMode rounding_mode) {
1661 3179 : return addOrSubtract(rhs, rounding_mode, false);
1662 : }
1663 :
1664 : /* Normalized subtraction. */
1665 1931 : IEEEFloat::opStatus IEEEFloat::subtract(const IEEEFloat &rhs,
1666 : roundingMode rounding_mode) {
1667 1931 : return addOrSubtract(rhs, rounding_mode, true);
1668 : }
1669 :
1670 : /* Normalized multiply. */
1671 1942 : IEEEFloat::opStatus IEEEFloat::multiply(const IEEEFloat &rhs,
1672 : roundingMode rounding_mode) {
1673 : opStatus fs;
1674 :
1675 1942 : sign ^= rhs.sign;
1676 1942 : fs = multiplySpecials(rhs);
1677 :
1678 : if (isFiniteNonZero()) {
1679 1264 : lostFraction lost_fraction = multiplySignificand(rhs, nullptr);
1680 1264 : fs = normalize(rounding_mode, lost_fraction);
1681 1264 : if (lost_fraction != lfExactlyZero)
1682 99 : fs = (opStatus) (fs | opInexact);
1683 : }
1684 :
1685 1942 : return fs;
1686 : }
1687 :
1688 : /* Normalized divide. */
1689 2218 : IEEEFloat::opStatus IEEEFloat::divide(const IEEEFloat &rhs,
1690 : roundingMode rounding_mode) {
1691 : opStatus fs;
1692 :
1693 2218 : sign ^= rhs.sign;
1694 2218 : fs = divideSpecials(rhs);
1695 :
1696 : if (isFiniteNonZero()) {
1697 1990 : lostFraction lost_fraction = divideSignificand(rhs);
1698 1990 : fs = normalize(rounding_mode, lost_fraction);
1699 1990 : if (lost_fraction != lfExactlyZero)
1700 678 : fs = (opStatus) (fs | opInexact);
1701 : }
1702 :
1703 2218 : return fs;
1704 : }
1705 :
1706 : /* Normalized remainder. This is not currently correct in all cases. */
1707 2 : IEEEFloat::opStatus IEEEFloat::remainder(const IEEEFloat &rhs) {
1708 : opStatus fs;
1709 4 : IEEEFloat V = *this;
1710 2 : unsigned int origSign = sign;
1711 :
1712 2 : fs = V.divide(rhs, rmNearestTiesToEven);
1713 2 : if (fs == opDivByZero)
1714 : return fs;
1715 :
1716 2 : int parts = partCount();
1717 2 : integerPart *x = new integerPart[parts];
1718 : bool ignored;
1719 2 : fs = V.convertToInteger(makeMutableArrayRef(x, parts),
1720 : parts * integerPartWidth, true, rmNearestTiesToEven,
1721 : &ignored);
1722 2 : if (fs == opInvalidOp) {
1723 0 : delete[] x;
1724 0 : return fs;
1725 : }
1726 :
1727 2 : fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1728 : rmNearestTiesToEven);
1729 : assert(fs==opOK); // should always work
1730 :
1731 2 : fs = V.multiply(rhs, rmNearestTiesToEven);
1732 : assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1733 :
1734 2 : fs = subtract(V, rmNearestTiesToEven);
1735 : assert(fs==opOK || fs==opInexact); // likewise
1736 :
1737 2 : if (isZero())
1738 0 : sign = origSign; // IEEE754 requires this
1739 2 : delete[] x;
1740 2 : return fs;
1741 : }
1742 :
1743 : /* Normalized llvm frem (C fmod). */
1744 109 : IEEEFloat::opStatus IEEEFloat::mod(const IEEEFloat &rhs) {
1745 : opStatus fs;
1746 109 : fs = modSpecials(rhs);
1747 109 : unsigned int origSign = sign;
1748 :
1749 199 : while (isFiniteNonZero() && rhs.isFiniteNonZero() &&
1750 118 : compareAbsoluteValue(rhs) != cmpLessThan) {
1751 162 : IEEEFloat V = scalbn(rhs, ilogb(*this) - ilogb(rhs), rmNearestTiesToEven);
1752 81 : if (compareAbsoluteValue(V) == cmpLessThan)
1753 49 : V = scalbn(V, -1, rmNearestTiesToEven);
1754 81 : V.sign = sign;
1755 :
1756 81 : fs = subtract(V, rmNearestTiesToEven);
1757 : assert(fs==opOK);
1758 : }
1759 109 : if (isZero())
1760 16 : sign = origSign; // fmod requires this
1761 109 : return fs;
1762 : }
1763 :
1764 : /* Normalized fused-multiply-add. */
1765 57 : IEEEFloat::opStatus IEEEFloat::fusedMultiplyAdd(const IEEEFloat &multiplicand,
1766 : const IEEEFloat &addend,
1767 : roundingMode rounding_mode) {
1768 : opStatus fs;
1769 :
1770 : /* Post-multiplication sign, before addition. */
1771 57 : sign ^= multiplicand.sign;
1772 :
1773 : /* If and only if all arguments are normal do we need to do an
1774 : extended-precision calculation. */
1775 : if (isFiniteNonZero() &&
1776 : multiplicand.isFiniteNonZero() &&
1777 : addend.isFinite()) {
1778 : lostFraction lost_fraction;
1779 :
1780 44 : lost_fraction = multiplySignificand(multiplicand, &addend);
1781 44 : fs = normalize(rounding_mode, lost_fraction);
1782 44 : if (lost_fraction != lfExactlyZero)
1783 1 : fs = (opStatus) (fs | opInexact);
1784 :
1785 : /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1786 : positive zero unless rounding to minus infinity, except that
1787 : adding two like-signed zeroes gives that zero. */
1788 44 : if (category == fcZero && !(fs & opUnderflow) && sign != addend.sign)
1789 19 : sign = (rounding_mode == rmTowardNegative);
1790 : } else {
1791 13 : fs = multiplySpecials(multiplicand);
1792 :
1793 : /* FS can only be opOK or opInvalidOp. There is no more work
1794 : to do in the latter case. The IEEE-754R standard says it is
1795 : implementation-defined in this case whether, if ADDEND is a
1796 : quiet NaN, we raise invalid op; this implementation does so.
1797 :
1798 : If we need to do the addition we can do so with normal
1799 : precision. */
1800 13 : if (fs == opOK)
1801 13 : fs = addOrSubtract(addend, rounding_mode, false);
1802 : }
1803 :
1804 57 : return fs;
1805 : }
1806 :
1807 : /* Rounding-mode corrrect round to integral value. */
1808 481 : IEEEFloat::opStatus IEEEFloat::roundToIntegral(roundingMode rounding_mode) {
1809 : opStatus fs;
1810 :
1811 : // If the exponent is large enough, we know that this value is already
1812 : // integral, and the arithmetic below would potentially cause it to saturate
1813 : // to +/-Inf. Bail out early instead.
1814 425 : if (isFiniteNonZero() && exponent+1 >= (int)semanticsPrecision(*semantics))
1815 : return opOK;
1816 :
1817 : // The algorithm here is quite simple: we add 2^(p-1), where p is the
1818 : // precision of our format, and then subtract it back off again. The choice
1819 : // of rounding modes for the addition/subtraction determines the rounding mode
1820 : // for our integral rounding as well.
1821 : // NOTE: When the input value is negative, we do subtraction followed by
1822 : // addition instead.
1823 471 : APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
1824 471 : IntegerConstant <<= semanticsPrecision(*semantics)-1;
1825 942 : IEEEFloat MagicConstant(*semantics);
1826 471 : fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
1827 : rmNearestTiesToEven);
1828 471 : MagicConstant.sign = sign;
1829 :
1830 471 : if (fs != opOK)
1831 : return fs;
1832 :
1833 : // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
1834 : bool inputSign = isNegative();
1835 :
1836 471 : fs = add(MagicConstant, rounding_mode);
1837 471 : if (fs != opOK && fs != opInexact)
1838 : return fs;
1839 :
1840 471 : fs = subtract(MagicConstant, rounding_mode);
1841 :
1842 : // Restore the input sign.
1843 471 : if (inputSign != isNegative())
1844 18 : changeSign();
1845 :
1846 : return fs;
1847 : }
1848 :
1849 :
1850 : /* Comparison requires normalized numbers. */
1851 3493 : IEEEFloat::cmpResult IEEEFloat::compare(const IEEEFloat &rhs) const {
1852 : cmpResult result;
1853 :
1854 : assert(semantics == rhs.semantics);
1855 :
1856 3493 : switch (PackCategoriesIntoKey(category, rhs.category)) {
1857 0 : default:
1858 0 : llvm_unreachable(nullptr);
1859 :
1860 : case PackCategoriesIntoKey(fcNaN, fcZero):
1861 : case PackCategoriesIntoKey(fcNaN, fcNormal):
1862 : case PackCategoriesIntoKey(fcNaN, fcInfinity):
1863 : case PackCategoriesIntoKey(fcNaN, fcNaN):
1864 : case PackCategoriesIntoKey(fcZero, fcNaN):
1865 : case PackCategoriesIntoKey(fcNormal, fcNaN):
1866 : case PackCategoriesIntoKey(fcInfinity, fcNaN):
1867 : return cmpUnordered;
1868 :
1869 275 : case PackCategoriesIntoKey(fcInfinity, fcNormal):
1870 : case PackCategoriesIntoKey(fcInfinity, fcZero):
1871 : case PackCategoriesIntoKey(fcNormal, fcZero):
1872 275 : if (sign)
1873 : return cmpLessThan;
1874 : else
1875 235 : return cmpGreaterThan;
1876 :
1877 331 : case PackCategoriesIntoKey(fcNormal, fcInfinity):
1878 : case PackCategoriesIntoKey(fcZero, fcInfinity):
1879 : case PackCategoriesIntoKey(fcZero, fcNormal):
1880 331 : if (rhs.sign)
1881 : return cmpGreaterThan;
1882 : else
1883 328 : return cmpLessThan;
1884 :
1885 5 : case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1886 5 : if (sign == rhs.sign)
1887 : return cmpEqual;
1888 0 : else if (sign)
1889 : return cmpLessThan;
1890 : else
1891 0 : return cmpGreaterThan;
1892 :
1893 578 : case PackCategoriesIntoKey(fcZero, fcZero):
1894 578 : return cmpEqual;
1895 :
1896 : case PackCategoriesIntoKey(fcNormal, fcNormal):
1897 : break;
1898 : }
1899 :
1900 : /* Two normal numbers. Do they have the same sign? */
1901 2263 : if (sign != rhs.sign) {
1902 103 : if (sign)
1903 : result = cmpLessThan;
1904 : else
1905 : result = cmpGreaterThan;
1906 : } else {
1907 : /* Compare absolute values; invert result if negative. */
1908 2160 : result = compareAbsoluteValue(rhs);
1909 :
1910 2160 : if (sign) {
1911 68 : if (result == cmpLessThan)
1912 : result = cmpGreaterThan;
1913 63 : else if (result == cmpGreaterThan)
1914 : result = cmpLessThan;
1915 : }
1916 : }
1917 :
1918 : return result;
1919 : }
1920 :
1921 : /// IEEEFloat::convert - convert a value of one floating point type to another.
1922 : /// The return value corresponds to the IEEE754 exceptions. *losesInfo
1923 : /// records whether the transformation lost information, i.e. whether
1924 : /// converting the result back to the original type will produce the
1925 : /// original value (this is almost the same as return value==fsOK, but there
1926 : /// are edge cases where this is not so).
1927 :
1928 179893 : IEEEFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
1929 : roundingMode rounding_mode,
1930 : bool *losesInfo) {
1931 : lostFraction lostFraction;
1932 : unsigned int newPartCount, oldPartCount;
1933 : opStatus fs;
1934 : int shift;
1935 179893 : const fltSemantics &fromSemantics = *semantics;
1936 :
1937 : lostFraction = lfExactlyZero;
1938 179893 : newPartCount = partCountForBits(toSemantics.precision + 1);
1939 179893 : oldPartCount = partCount();
1940 179893 : shift = toSemantics.precision - fromSemantics.precision;
1941 :
1942 : bool X86SpecialNan = false;
1943 2928 : if (&fromSemantics == &semX87DoubleExtended &&
1944 182821 : &toSemantics != &semX87DoubleExtended && category == fcNaN &&
1945 135 : (!(*significandParts() & 0x8000000000000000ULL) ||
1946 135 : !(*significandParts() & 0x4000000000000000ULL))) {
1947 : // x86 has some unusual NaNs which cannot be represented in any other
1948 : // format; note them here.
1949 : X86SpecialNan = true;
1950 : }
1951 :
1952 : // If this is a truncation of a denormal number, and the target semantics
1953 : // has larger exponent range than the source semantics (this can happen
1954 : // when truncating from PowerPC double-double to double format), the
1955 : // right shift could lose result mantissa bits. Adjust exponent instead
1956 : // of performing excessive shift.
1957 179893 : if (shift < 0 && isFiniteNonZero()) {
1958 95830 : int exponentChange = significandMSB() + 1 - fromSemantics.precision;
1959 95830 : if (exponent + exponentChange < toSemantics.minExponent)
1960 312 : exponentChange = toSemantics.minExponent - exponent;
1961 95830 : if (exponentChange < shift)
1962 : exponentChange = shift;
1963 95830 : if (exponentChange < 0) {
1964 0 : shift -= exponentChange;
1965 0 : exponent += exponentChange;
1966 : }
1967 : }
1968 :
1969 : // If this is a truncation, perform the shift before we narrow the storage.
1970 220633 : if (shift < 0 && (isFiniteNonZero() || category==fcNaN))
1971 97591 : lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
1972 :
1973 : // Fix the storage so it can hold to new value.
1974 179893 : if (newPartCount > oldPartCount) {
1975 : // The new type requires more storage; make it available.
1976 : integerPart *newParts;
1977 34469 : newParts = new integerPart[newPartCount];
1978 34469 : APInt::tcSet(newParts, 0, newPartCount);
1979 10457 : if (isFiniteNonZero() || category==fcNaN)
1980 24096 : APInt::tcAssign(newParts, significandParts(), oldPartCount);
1981 34469 : freeSignificand();
1982 34469 : significand.parts = newParts;
1983 145424 : } else if (newPartCount == 1 && oldPartCount != 1) {
1984 : // Switch to built-in storage for a single part.
1985 : integerPart newPart = 0;
1986 1042 : if (isFiniteNonZero() || category==fcNaN)
1987 2344 : newPart = significandParts()[0];
1988 3207 : freeSignificand();
1989 3207 : significand.part = newPart;
1990 : }
1991 :
1992 : // Now that we have the right storage, switch the semantics.
1993 179893 : semantics = &toSemantics;
1994 :
1995 : // If this is an extension, perform the shift now that the storage is
1996 : // available.
1997 195649 : if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
1998 28659 : APInt::tcShiftLeft(significandParts(), newPartCount, shift);
1999 :
2000 : if (isFiniteNonZero()) {
2001 123391 : fs = normalize(rounding_mode, lostFraction);
2002 123391 : *losesInfo = (fs != opOK);
2003 56502 : } else if (category == fcNaN) {
2004 2922 : *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
2005 :
2006 : // For x87 extended precision, we want to make a NaN, not a special NaN if
2007 : // the input wasn't special either.
2008 2922 : if (!X86SpecialNan && semantics == &semX87DoubleExtended)
2009 106 : APInt::tcSetBit(significandParts(), semantics->precision - 1);
2010 :
2011 : // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
2012 : // does not give you back the same bits. This is dubious, and we
2013 : // don't currently do it. You're really supposed to get
2014 : // an invalid operation signal at runtime, but nobody does that.
2015 : fs = opOK;
2016 : } else {
2017 53580 : *losesInfo = false;
2018 : fs = opOK;
2019 : }
2020 :
2021 179893 : return fs;
2022 : }
2023 :
2024 : /* Convert a floating point number to an integer according to the
2025 : rounding mode. If the rounded integer value is out of range this
2026 : returns an invalid operation exception and the contents of the
2027 : destination parts are unspecified. If the rounded value is in
2028 : range but the floating point number is not the exact integer, the C
2029 : standard doesn't require an inexact exception to be raised. IEEE
2030 : 854 does require it so we do that.
2031 :
2032 : Note that for conversions to integer type the C standard requires
2033 : round-to-zero to always be used. */
2034 11099 : IEEEFloat::opStatus IEEEFloat::convertToSignExtendedInteger(
2035 : MutableArrayRef<integerPart> parts, unsigned int width, bool isSigned,
2036 : roundingMode rounding_mode, bool *isExact) const {
2037 : lostFraction lost_fraction;
2038 : const integerPart *src;
2039 : unsigned int dstPartsCount, truncatedBits;
2040 :
2041 11099 : *isExact = false;
2042 :
2043 : /* Handle the three special cases first. */
2044 11099 : if (category == fcInfinity || category == fcNaN)
2045 : return opInvalidOp;
2046 :
2047 : dstPartsCount = partCountForBits(width);
2048 : assert(dstPartsCount <= parts.size() && "Integer too big");
2049 :
2050 11016 : if (category == fcZero) {
2051 542 : APInt::tcSet(parts.data(), 0, dstPartsCount);
2052 : // Negative zero can't be represented as an int.
2053 542 : *isExact = !sign;
2054 542 : return opOK;
2055 : }
2056 :
2057 10474 : src = significandParts();
2058 :
2059 : /* Step 1: place our absolute value, with any fraction truncated, in
2060 : the destination. */
2061 10474 : if (exponent < 0) {
2062 : /* Our absolute value is less than one; truncate everything. */
2063 184 : APInt::tcSet(parts.data(), 0, dstPartsCount);
2064 : /* For exponent -1 the integer bit represents .5, look at that.
2065 : For smaller exponents leftmost truncated bit is 0. */
2066 184 : truncatedBits = semantics->precision -1U - exponent;
2067 : } else {
2068 : /* We want the most significant (exponent + 1) bits; the rest are
2069 : truncated. */
2070 10290 : unsigned int bits = exponent + 1U;
2071 :
2072 : /* Hopelessly large in magnitude? */
2073 10290 : if (bits > width)
2074 : return opInvalidOp;
2075 :
2076 10192 : if (bits < semantics->precision) {
2077 : /* We truncate (semantics->precision - bits) bits. */
2078 10145 : truncatedBits = semantics->precision - bits;
2079 10145 : APInt::tcExtract(parts.data(), dstPartsCount, src, bits, truncatedBits);
2080 : } else {
2081 : /* We want at least as many bits as are available. */
2082 47 : APInt::tcExtract(parts.data(), dstPartsCount, src, semantics->precision,
2083 : 0);
2084 47 : APInt::tcShiftLeft(parts.data(), dstPartsCount,
2085 47 : bits - semantics->precision);
2086 : truncatedBits = 0;
2087 : }
2088 : }
2089 :
2090 : /* Step 2: work out any lost fraction, and increment the absolute
2091 : value if we would round away from zero. */
2092 10329 : if (truncatedBits) {
2093 10329 : lost_fraction = lostFractionThroughTruncation(src, partCount(),
2094 : truncatedBits);
2095 11555 : if (lost_fraction != lfExactlyZero &&
2096 1226 : roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
2097 13 : if (APInt::tcIncrement(parts.data(), dstPartsCount))
2098 : return opInvalidOp; /* Overflow. */
2099 : }
2100 : } else {
2101 : lost_fraction = lfExactlyZero;
2102 : }
2103 :
2104 : /* Step 3: check if we fit in the destination. */
2105 10376 : unsigned int omsb = APInt::tcMSB(parts.data(), dstPartsCount) + 1;
2106 :
2107 10376 : if (sign) {
2108 175 : if (!isSigned) {
2109 : /* Negative numbers cannot be represented as unsigned. */
2110 7 : if (omsb != 0)
2111 : return opInvalidOp;
2112 : } else {
2113 : /* It takes omsb bits to represent the unsigned integer value.
2114 : We lose a bit for the sign, but care is needed as the
2115 : maximally negative integer is a special case. */
2116 173 : if (omsb == width &&
2117 5 : APInt::tcLSB(parts.data(), dstPartsCount) + 1 != omsb)
2118 : return opInvalidOp;
2119 :
2120 : /* This case can happen because of rounding. */
2121 165 : if (omsb > width)
2122 : return opInvalidOp;
2123 : }
2124 :
2125 167 : APInt::tcNegate (parts.data(), dstPartsCount);
2126 : } else {
2127 10201 : if (omsb >= width + !isSigned)
2128 : return opInvalidOp;
2129 : }
2130 :
2131 10361 : if (lost_fraction == lfExactlyZero) {
2132 9135 : *isExact = true;
2133 9135 : return opOK;
2134 : } else
2135 : return opInexact;
2136 : }
2137 :
2138 : /* Same as convertToSignExtendedInteger, except we provide
2139 : deterministic values in case of an invalid operation exception,
2140 : namely zero for NaNs and the minimal or maximal value respectively
2141 : for underflow or overflow.
2142 : The *isExact output tells whether the result is exact, in the sense
2143 : that converting it back to the original floating point type produces
2144 : the original value. This is almost equivalent to result==opOK,
2145 : except for negative zeroes.
2146 : */
2147 : IEEEFloat::opStatus
2148 11099 : IEEEFloat::convertToInteger(MutableArrayRef<integerPart> parts,
2149 : unsigned int width, bool isSigned,
2150 : roundingMode rounding_mode, bool *isExact) const {
2151 : opStatus fs;
2152 :
2153 11099 : fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
2154 : isExact);
2155 :
2156 11099 : if (fs == opInvalidOp) {
2157 : unsigned int bits, dstPartsCount;
2158 :
2159 : dstPartsCount = partCountForBits(width);
2160 : assert(dstPartsCount <= parts.size() && "Integer too big");
2161 :
2162 196 : if (category == fcNaN)
2163 : bits = 0;
2164 146 : else if (sign)
2165 37 : bits = isSigned;
2166 : else
2167 109 : bits = width - isSigned;
2168 :
2169 196 : APInt::tcSetLeastSignificantBits(parts.data(), dstPartsCount, bits);
2170 196 : if (sign && isSigned)
2171 19 : APInt::tcShiftLeft(parts.data(), dstPartsCount, width - 1);
2172 : }
2173 :
2174 11099 : return fs;
2175 : }
2176 :
2177 : /* Convert an unsigned integer SRC to a floating point number,
2178 : rounding according to ROUNDING_MODE. The sign of the floating
2179 : point number is not modified. */
2180 420358 : IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
2181 : const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
2182 : unsigned int omsb, precision, dstCount;
2183 : integerPart *dst;
2184 : lostFraction lost_fraction;
2185 :
2186 420358 : category = fcNormal;
2187 420358 : omsb = APInt::tcMSB(src, srcCount) + 1;
2188 420358 : dst = significandParts();
2189 420358 : dstCount = partCount();
2190 420358 : precision = semantics->precision;
2191 :
2192 : /* We want the most significant PRECISION bits of SRC. There may not
2193 : be that many; extract what we can. */
2194 420358 : if (precision <= omsb) {
2195 56776 : exponent = omsb - 1;
2196 56776 : lost_fraction = lostFractionThroughTruncation(src, srcCount,
2197 : omsb - precision);
2198 56776 : APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2199 : } else {
2200 363582 : exponent = precision - 1;
2201 : lost_fraction = lfExactlyZero;
2202 363582 : APInt::tcExtract(dst, dstCount, src, omsb, 0);
2203 : }
2204 :
2205 420358 : return normalize(rounding_mode, lost_fraction);
2206 : }
2207 :
2208 46538 : IEEEFloat::opStatus IEEEFloat::convertFromAPInt(const APInt &Val, bool isSigned,
2209 : roundingMode rounding_mode) {
2210 46538 : unsigned int partCount = Val.getNumWords();
2211 : APInt api = Val;
2212 :
2213 46538 : sign = false;
2214 46541 : if (isSigned && api.isNegative()) {
2215 3140 : sign = true;
2216 3140 : api = -api;
2217 : }
2218 :
2219 46538 : return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2220 : }
2221 :
2222 : /* Convert a two's complement integer SRC to a floating point number,
2223 : rounding according to ROUNDING_MODE. ISSIGNED is true if the
2224 : integer is signed, in which case it must be sign-extended. */
2225 : IEEEFloat::opStatus
2226 0 : IEEEFloat::convertFromSignExtendedInteger(const integerPart *src,
2227 : unsigned int srcCount, bool isSigned,
2228 : roundingMode rounding_mode) {
2229 : opStatus status;
2230 :
2231 0 : if (isSigned &&
2232 0 : APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2233 : integerPart *copy;
2234 :
2235 : /* If we're signed and negative negate a copy. */
2236 0 : sign = true;
2237 0 : copy = new integerPart[srcCount];
2238 0 : APInt::tcAssign(copy, src, srcCount);
2239 0 : APInt::tcNegate(copy, srcCount);
2240 0 : status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
2241 0 : delete [] copy;
2242 : } else {
2243 0 : sign = false;
2244 0 : status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2245 : }
2246 :
2247 0 : return status;
2248 : }
2249 :
2250 : /* FIXME: should this just take a const APInt reference? */
2251 : IEEEFloat::opStatus
2252 2 : IEEEFloat::convertFromZeroExtendedInteger(const integerPart *parts,
2253 : unsigned int width, bool isSigned,
2254 : roundingMode rounding_mode) {
2255 : unsigned int partCount = partCountForBits(width);
2256 2 : APInt api = APInt(width, makeArrayRef(parts, partCount));
2257 :
2258 2 : sign = false;
2259 2 : if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2260 0 : sign = true;
2261 0 : api = -api;
2262 : }
2263 :
2264 2 : return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2265 : }
2266 :
2267 : IEEEFloat::opStatus
2268 855 : IEEEFloat::convertFromHexadecimalString(StringRef s,
2269 : roundingMode rounding_mode) {
2270 : lostFraction lost_fraction = lfExactlyZero;
2271 :
2272 855 : category = fcNormal;
2273 855 : zeroSignificand();
2274 855 : exponent = 0;
2275 :
2276 855 : integerPart *significand = significandParts();
2277 855 : unsigned partsCount = partCount();
2278 855 : unsigned bitPos = partsCount * integerPartWidth;
2279 : bool computedTrailingFraction = false;
2280 :
2281 : // Skip leading zeroes and any (hexa)decimal point.
2282 : StringRef::iterator begin = s.begin();
2283 855 : StringRef::iterator end = s.end();
2284 : StringRef::iterator dot;
2285 : StringRef::iterator p = skipLeadingZeroesAndAnyDot(begin, end, &dot);
2286 : StringRef::iterator firstSignificantDigit = p;
2287 :
2288 4580 : while (p != end) {
2289 : integerPart hex_value;
2290 :
2291 4580 : if (*p == '.') {
2292 : assert(dot == end && "String contains multiple dots");
2293 256 : dot = p++;
2294 256 : continue;
2295 : }
2296 :
2297 4324 : hex_value = hexDigitValue(*p);
2298 4324 : if (hex_value == -1U)
2299 : break;
2300 :
2301 3469 : p++;
2302 :
2303 : // Store the number while we have space.
2304 3469 : if (bitPos) {
2305 3460 : bitPos -= 4;
2306 3460 : hex_value <<= bitPos % integerPartWidth;
2307 3460 : significand[bitPos / integerPartWidth] |= hex_value;
2308 9 : } else if (!computedTrailingFraction) {
2309 2 : lost_fraction = trailingHexadecimalFraction(p, end, hex_value);
2310 : computedTrailingFraction = true;
2311 : }
2312 : }
2313 :
2314 : /* Hex floats require an exponent but not a hexadecimal point. */
2315 : assert(p != end && "Hex strings require an exponent");
2316 : assert((*p == 'p' || *p == 'P') && "Invalid character in significand");
2317 : assert(p != begin && "Significand has no digits");
2318 : assert((dot == end || p - begin != 1) && "Significand has no digits");
2319 :
2320 : /* Ignore the exponent if we are zero. */
2321 855 : if (p != firstSignificantDigit) {
2322 : int expAdjustment;
2323 :
2324 : /* Implicit hexadecimal point? */
2325 664 : if (dot == end)
2326 : dot = p;
2327 :
2328 : /* Calculate the exponent adjustment implicit in the number of
2329 : significant digits. */
2330 664 : expAdjustment = static_cast<int>(dot - firstSignificantDigit);
2331 664 : if (expAdjustment < 0)
2332 39 : expAdjustment++;
2333 664 : expAdjustment = expAdjustment * 4 - 1;
2334 :
2335 : /* Adjust for writing the significand starting at the most
2336 : significant nibble. */
2337 664 : expAdjustment += semantics->precision;
2338 664 : expAdjustment -= partsCount * integerPartWidth;
2339 :
2340 : /* Adjust for the given exponent. */
2341 664 : exponent = totalExponent(p + 1, end, expAdjustment);
2342 : }
2343 :
2344 855 : return normalize(rounding_mode, lost_fraction);
2345 : }
2346 :
2347 : IEEEFloat::opStatus
2348 186877 : IEEEFloat::roundSignificandWithExponent(const integerPart *decSigParts,
2349 : unsigned sigPartCount, int exp,
2350 : roundingMode rounding_mode) {
2351 : unsigned int parts, pow5PartCount;
2352 186877 : fltSemantics calcSemantics = { 32767, -32767, 0, 0 };
2353 : integerPart pow5Parts[maxPowerOfFiveParts];
2354 : bool isNearest;
2355 :
2356 373754 : isNearest = (rounding_mode == rmNearestTiesToEven ||
2357 186877 : rounding_mode == rmNearestTiesToAway);
2358 :
2359 186877 : parts = partCountForBits(semantics->precision + 11);
2360 :
2361 : /* Calculate pow(5, abs(exp)). */
2362 186877 : pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2363 :
2364 32 : for (;; parts *= 2) {
2365 : opStatus sigStatus, powStatus;
2366 : unsigned int excessPrecision, truncatedBits;
2367 :
2368 186909 : calcSemantics.precision = parts * integerPartWidth - 1;
2369 186909 : excessPrecision = calcSemantics.precision - semantics->precision;
2370 : truncatedBits = excessPrecision;
2371 :
2372 186941 : IEEEFloat decSig(calcSemantics, uninitialized);
2373 186909 : decSig.makeZero(sign);
2374 186941 : IEEEFloat pow5(calcSemantics);
2375 :
2376 186909 : sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2377 : rmNearestTiesToEven);
2378 186909 : powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2379 : rmNearestTiesToEven);
2380 : /* Add exp, as 10^n = 5^n * 2^n. */
2381 186909 : decSig.exponent += exp;
2382 :
2383 : lostFraction calcLostFraction;
2384 : integerPart HUerr, HUdistance;
2385 : unsigned int powHUerr;
2386 :
2387 186909 : if (exp >= 0) {
2388 : /* multiplySignificand leaves the precision-th bit set to 1. */
2389 75938 : calcLostFraction = decSig.multiplySignificand(pow5, nullptr);
2390 75938 : powHUerr = powStatus != opOK;
2391 : } else {
2392 110971 : calcLostFraction = decSig.divideSignificand(pow5);
2393 : /* Denormal numbers have less precision. */
2394 110971 : if (decSig.exponent < semantics->minExponent) {
2395 25758 : excessPrecision += (semantics->minExponent - decSig.exponent);
2396 : truncatedBits = excessPrecision;
2397 25758 : if (excessPrecision > calcSemantics.precision)
2398 : excessPrecision = calcSemantics.precision;
2399 : }
2400 : /* Extra half-ulp lost in reciprocal of exponent. */
2401 110971 : powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
2402 : }
2403 :
2404 : /* Both multiplySignificand and divideSignificand return the
2405 : result with the integer bit set. */
2406 : assert(APInt::tcExtractBit
2407 : (decSig.significandParts(), calcSemantics.precision - 1) == 1);
2408 :
2409 186909 : HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
2410 : powHUerr);
2411 186909 : HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
2412 : excessPrecision, isNearest);
2413 :
2414 : /* Are we guaranteed to round correctly if we truncate? */
2415 186909 : if (HUdistance >= HUerr) {
2416 186877 : APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2417 186877 : calcSemantics.precision - excessPrecision,
2418 : excessPrecision);
2419 : /* Take the exponent of decSig. If we tcExtract-ed less bits
2420 : above we must adjust our exponent to compensate for the
2421 : implicit right shift. */
2422 373754 : exponent = (decSig.exponent + semantics->precision
2423 186877 : - (calcSemantics.precision - excessPrecision));
2424 186877 : calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
2425 : decSig.partCount(),
2426 : truncatedBits);
2427 373754 : return normalize(rounding_mode, calcLostFraction);
2428 : }
2429 32 : }
2430 : }
2431 :
2432 : IEEEFloat::opStatus
2433 246355 : IEEEFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode) {
2434 : decimalInfo D;
2435 : opStatus fs;
2436 :
2437 : /* Scan the text. */
2438 : StringRef::iterator p = str.begin();
2439 246355 : interpretDecimal(p, str.end(), &D);
2440 :
2441 : /* Handle the quick cases. First the case of no significant digits,
2442 : i.e. zero, and then exponents that are obviously too large or too
2443 : small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
2444 : definitely overflows if
2445 :
2446 : (exp - 1) * L >= maxExponent
2447 :
2448 : and definitely underflows to zero where
2449 :
2450 : (exp + 1) * L <= minExponent - precision
2451 :
2452 : With integer arithmetic the tightest bounds for L are
2453 :
2454 : 93/28 < L < 196/59 [ numerator <= 256 ]
2455 : 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
2456 : */
2457 :
2458 : // Test if we have a zero number allowing for strings with no null terminators
2459 : // and zero decimals with non-zero exponents.
2460 : //
2461 : // We computed firstSigDigit by ignoring all zeros and dots. Thus if
2462 : // D->firstSigDigit equals str.end(), every digit must be a zero and there can
2463 : // be at most one dot. On the other hand, if we have a zero with a non-zero
2464 : // exponent, then we know that D.firstSigDigit will be non-numeric.
2465 246355 : if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
2466 59464 : category = fcZero;
2467 : fs = opOK;
2468 :
2469 : /* Check whether the normalized exponent is high enough to overflow
2470 : max during the log-rebasing in the max-exponent check below. */
2471 186891 : } else if (D.normalizedExponent - 1 > INT_MAX / 42039) {
2472 2 : fs = handleOverflow(rounding_mode);
2473 :
2474 : /* If it wasn't, then it also wasn't high enough to overflow max
2475 : during the log-rebasing in the min-exponent check. Check that it
2476 : won't overflow min in either check, then perform the min-exponent
2477 : check. */
2478 186889 : } else if (D.normalizedExponent - 1 < INT_MIN / 42039 ||
2479 186887 : (D.normalizedExponent + 1) * 28738 <=
2480 186887 : 8651 * (semantics->minExponent - (int) semantics->precision)) {
2481 : /* Underflow to zero and round. */
2482 6 : category = fcNormal;
2483 6 : zeroSignificand();
2484 6 : fs = normalize(rounding_mode, lfLessThanHalf);
2485 :
2486 : /* We can finally safely perform the max-exponent check. */
2487 373766 : } else if ((D.normalizedExponent - 1) * 42039
2488 186883 : >= 12655 * semantics->maxExponent) {
2489 : /* Overflow and round. */
2490 6 : fs = handleOverflow(rounding_mode);
2491 : } else {
2492 : integerPart *decSignificand;
2493 : unsigned int partCount;
2494 :
2495 : /* A tight upper bound on number of bits required to hold an
2496 : N-digit decimal integer is N * 196 / 59. Allocate enough space
2497 : to hold the full significand, and an extra part required by
2498 : tcMultiplyPart. */
2499 186877 : partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
2500 186877 : partCount = partCountForBits(1 + 196 * partCount / 59);
2501 186877 : decSignificand = new integerPart[partCount + 1];
2502 : partCount = 0;
2503 :
2504 : /* Convert to binary efficiently - we do almost all multiplication
2505 : in an integerPart. When this would overflow do we do a single
2506 : bignum multiplication, and then revert again to multiplication
2507 : in an integerPart. */
2508 : do {
2509 : integerPart decValue, val, multiplier;
2510 :
2511 : val = 0;
2512 : multiplier = 1;
2513 :
2514 : do {
2515 1254705 : if (*p == '.') {
2516 125606 : p++;
2517 125606 : if (p == str.end()) {
2518 : break;
2519 : }
2520 : }
2521 2509410 : decValue = decDigitValue(*p++);
2522 : assert(decValue < 10U && "Invalid character in significand");
2523 1254705 : multiplier *= 10;
2524 1254705 : val = val * 10 + decValue;
2525 : /* The maximum number that can be multiplied by ten with any
2526 : digit added without overflowing an integerPart. */
2527 1254705 : } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
2528 :
2529 : /* Multiply out the current part. */
2530 208502 : APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2531 : partCount, partCount + 1, false);
2532 :
2533 : /* If we used another part (likely but not guaranteed), increase
2534 : the count. */
2535 208502 : if (decSignificand[partCount])
2536 : partCount++;
2537 208502 : } while (p <= D.lastSigDigit);
2538 :
2539 186877 : category = fcNormal;
2540 186877 : fs = roundSignificandWithExponent(decSignificand, partCount,
2541 : D.exponent, rounding_mode);
2542 :
2543 186877 : delete [] decSignificand;
2544 : }
2545 :
2546 246355 : return fs;
2547 : }
2548 :
2549 247516 : bool IEEEFloat::convertFromStringSpecials(StringRef str) {
2550 : if (str.equals("inf") || str.equals("INFINITY") || str.equals("+Inf")) {
2551 91 : makeInf(false);
2552 91 : return true;
2553 : }
2554 :
2555 : if (str.equals("-inf") || str.equals("-INFINITY") || str.equals("-Inf")) {
2556 91 : makeInf(true);
2557 91 : return true;
2558 : }
2559 :
2560 : if (str.equals("nan") || str.equals("NaN")) {
2561 110 : makeNaN(false, false);
2562 110 : return true;
2563 : }
2564 :
2565 : if (str.equals("-nan") || str.equals("-NaN")) {
2566 14 : makeNaN(false, true);
2567 14 : return true;
2568 : }
2569 :
2570 : return false;
2571 : }
2572 :
2573 247516 : IEEEFloat::opStatus IEEEFloat::convertFromString(StringRef str,
2574 : roundingMode rounding_mode) {
2575 : assert(!str.empty() && "Invalid string length");
2576 :
2577 : // Handle special cases.
2578 247516 : if (convertFromStringSpecials(str))
2579 : return opOK;
2580 :
2581 : /* Handle a leading minus sign. */
2582 247210 : StringRef::iterator p = str.begin();
2583 : size_t slen = str.size();
2584 247210 : sign = *p == '-' ? 1 : 0;
2585 247210 : if (*p == '-' || *p == '+') {
2586 19919 : p++;
2587 19919 : slen--;
2588 : assert(slen && "String has no digits");
2589 : }
2590 :
2591 247210 : if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
2592 : assert(slen - 2 && "Invalid string");
2593 1710 : return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
2594 : rounding_mode);
2595 : }
2596 :
2597 246355 : return convertFromDecimalString(StringRef(p, slen), rounding_mode);
2598 : }
2599 :
2600 : /* Write out a hexadecimal representation of the floating point value
2601 : to DST, which must be of sufficient size, in the C99 form
2602 : [-]0xh.hhhhp[+-]d. Return the number of characters written,
2603 : excluding the terminating NUL.
2604 :
2605 : If UPPERCASE, the output is in upper case, otherwise in lower case.
2606 :
2607 : HEXDIGITS digits appear altogether, rounding the value if
2608 : necessary. If HEXDIGITS is 0, the minimal precision to display the
2609 : number precisely is used instead. If nothing would appear after
2610 : the decimal point it is suppressed.
2611 :
2612 : The decimal exponent is always printed and has at least one digit.
2613 : Zero values display an exponent of zero. Infinities and NaNs
2614 : appear as "infinity" or "nan" respectively.
2615 :
2616 : The above rules are as specified by C99. There is ambiguity about
2617 : what the leading hexadecimal digit should be. This implementation
2618 : uses whatever is necessary so that the exponent is displayed as
2619 : stored. This implies the exponent will fall within the IEEE format
2620 : range, and the leading hexadecimal digit will be 0 (for denormals),
2621 : 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
2622 : any other digits zero).
2623 : */
2624 208 : unsigned int IEEEFloat::convertToHexString(char *dst, unsigned int hexDigits,
2625 : bool upperCase,
2626 : roundingMode rounding_mode) const {
2627 : char *p;
2628 :
2629 : p = dst;
2630 208 : if (sign)
2631 14 : *dst++ = '-';
2632 :
2633 208 : switch (category) {
2634 4 : case fcInfinity:
2635 4 : memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
2636 4 : dst += sizeof infinityL - 1;
2637 4 : break;
2638 :
2639 4 : case fcNaN:
2640 4 : memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
2641 4 : dst += sizeof NaNU - 1;
2642 4 : break;
2643 :
2644 24 : case fcZero:
2645 24 : *dst++ = '0';
2646 24 : *dst++ = upperCase ? 'X': 'x';
2647 24 : *dst++ = '0';
2648 24 : if (hexDigits > 1) {
2649 0 : *dst++ = '.';
2650 0 : memset (dst, '0', hexDigits - 1);
2651 0 : dst += hexDigits - 1;
2652 : }
2653 24 : *dst++ = upperCase ? 'P': 'p';
2654 24 : *dst++ = '0';
2655 24 : break;
2656 :
2657 176 : case fcNormal:
2658 176 : dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
2659 176 : break;
2660 : }
2661 :
2662 208 : *dst = 0;
2663 :
2664 208 : return static_cast<unsigned int>(dst - p);
2665 : }
2666 :
2667 : /* Does the hard work of outputting the correctly rounded hexadecimal
2668 : form of a normal floating point number with the specified number of
2669 : hexadecimal digits. If HEXDIGITS is zero the minimum number of
2670 : digits necessary to print the value precisely is output. */
2671 176 : char *IEEEFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
2672 : bool upperCase,
2673 : roundingMode rounding_mode) const {
2674 : unsigned int count, valueBits, shift, partsCount, outputDigits;
2675 : const char *hexDigitChars;
2676 : const integerPart *significand;
2677 : char *p;
2678 : bool roundUp;
2679 :
2680 176 : *dst++ = '0';
2681 176 : *dst++ = upperCase ? 'X': 'x';
2682 :
2683 : roundUp = false;
2684 176 : hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;
2685 :
2686 176 : significand = significandParts();
2687 176 : partsCount = partCount();
2688 :
2689 : /* +3 because the first digit only uses the single integer bit, so
2690 : we have 3 virtual zero most-significant-bits. */
2691 176 : valueBits = semantics->precision + 3;
2692 176 : shift = integerPartWidth - valueBits % integerPartWidth;
2693 :
2694 : /* The natural number of digits required ignoring trailing
2695 : insignificant zeroes. */
2696 176 : outputDigits = (valueBits - significandLSB () + 3) / 4;
2697 :
2698 : /* hexDigits of zero means use the required number for the
2699 : precision. Otherwise, see if we are truncating. If we are,
2700 : find out if we need to round away from zero. */
2701 176 : if (hexDigits) {
2702 0 : if (hexDigits < outputDigits) {
2703 : /* We are dropping non-zero bits, so need to check how to round.
2704 : "bits" is the number of dropped bits. */
2705 : unsigned int bits;
2706 : lostFraction fraction;
2707 :
2708 0 : bits = valueBits - hexDigits * 4;
2709 0 : fraction = lostFractionThroughTruncation (significand, partsCount, bits);
2710 0 : roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
2711 : }
2712 : outputDigits = hexDigits;
2713 : }
2714 :
2715 : /* Write the digits consecutively, and start writing in the location
2716 : of the hexadecimal point. We move the most significant digit
2717 : left and add the hexadecimal point later. */
2718 176 : p = ++dst;
2719 :
2720 176 : count = (valueBits + integerPartWidth - 1) / integerPartWidth;
2721 :
2722 352 : while (outputDigits && count) {
2723 : integerPart part;
2724 :
2725 : /* Put the most significant integerPartWidth bits in "part". */
2726 176 : if (--count == partsCount)
2727 : part = 0; /* An imaginary higher zero part. */
2728 : else
2729 176 : part = significand[count] << shift;
2730 :
2731 176 : if (count && shift)
2732 0 : part |= significand[count - 1] >> (integerPartWidth - shift);
2733 :
2734 : /* Convert as much of "part" to hexdigits as we can. */
2735 : unsigned int curDigits = integerPartWidth / 4;
2736 :
2737 176 : if (curDigits > outputDigits)
2738 : curDigits = outputDigits;
2739 176 : dst += partAsHex (dst, part, curDigits, hexDigitChars);
2740 176 : outputDigits -= curDigits;
2741 : }
2742 :
2743 176 : if (roundUp) {
2744 : char *q = dst;
2745 :
2746 : /* Note that hexDigitChars has a trailing '0'. */
2747 : do {
2748 0 : q--;
2749 0 : *q = hexDigitChars[hexDigitValue (*q) + 1];
2750 0 : } while (*q == '0');
2751 : assert(q >= p);
2752 : } else {
2753 : /* Add trailing zeroes. */
2754 176 : memset (dst, '0', outputDigits);
2755 176 : dst += outputDigits;
2756 : }
2757 :
2758 : /* Move the most significant digit to before the point, and if there
2759 : is something after the decimal point add it. This must come
2760 : after rounding above. */
2761 176 : p[-1] = p[0];
2762 176 : if (dst -1 == p)
2763 : dst--;
2764 : else
2765 142 : p[0] = '.';
2766 :
2767 : /* Finally output the exponent. */
2768 176 : *dst++ = upperCase ? 'P': 'p';
2769 :
2770 176 : return writeSignedDecimal (dst, exponent);
2771 : }
2772 :
2773 190390 : hash_code hash_value(const IEEEFloat &Arg) {
2774 : if (!Arg.isFiniteNonZero())
2775 178910 : return hash_combine((uint8_t)Arg.category,
2776 : // NaN has no sign, fix it at zero.
2777 155321 : Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
2778 155321 : Arg.semantics->precision);
2779 :
2780 : // Normal floats need their exponent and significand hashed.
2781 201870 : return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
2782 100935 : Arg.semantics->precision, Arg.exponent,
2783 100935 : hash_combine_range(
2784 : Arg.significandParts(),
2785 201870 : Arg.significandParts() + Arg.partCount()));
2786 : }
2787 :
2788 : // Conversion from APFloat to/from host float/double. It may eventually be
2789 : // possible to eliminate these and have everybody deal with APFloats, but that
2790 : // will take a while. This approach will not easily extend to long double.
2791 : // Current implementation requires integerPartWidth==64, which is correct at
2792 : // the moment but could be made more general.
2793 :
2794 : // Denormals have exponent minExponent in APFloat, but minExponent-1 in
2795 : // the actual IEEE respresentations. We compensate for that here.
2796 :
2797 22266 : APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt() const {
2798 : assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended);
2799 : assert(partCount()==2);
2800 :
2801 : uint64_t myexponent, mysignificand;
2802 :
2803 : if (isFiniteNonZero()) {
2804 21400 : myexponent = exponent+16383; //bias
2805 21400 : mysignificand = significandParts()[0];
2806 21400 : if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
2807 : myexponent = 0; // denormal
2808 866 : } else if (category==fcZero) {
2809 : myexponent = 0;
2810 : mysignificand = 0;
2811 27 : } else if (category==fcInfinity) {
2812 : myexponent = 0x7fff;
2813 : mysignificand = 0x8000000000000000ULL;
2814 : } else {
2815 : assert(category == fcNaN && "Unknown category");
2816 : myexponent = 0x7fff;
2817 12 : mysignificand = significandParts()[0];
2818 : }
2819 :
2820 : uint64_t words[2];
2821 22266 : words[0] = mysignificand;
2822 44532 : words[1] = ((uint64_t)(sign & 1) << 15) |
2823 22266 : (myexponent & 0x7fffLL);
2824 22266 : return APInt(80, words);
2825 : }
2826 :
2827 68 : APInt IEEEFloat::convertPPCDoubleDoubleAPFloatToAPInt() const {
2828 : assert(semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy);
2829 : assert(partCount()==2);
2830 :
2831 : uint64_t words[2];
2832 : opStatus fs;
2833 : bool losesInfo;
2834 :
2835 : // Convert number to double. To avoid spurious underflows, we re-
2836 : // normalize against the "double" minExponent first, and only *then*
2837 : // truncate the mantissa. The result of that second conversion
2838 : // may be inexact, but should never underflow.
2839 : // Declare fltSemantics before APFloat that uses it (and
2840 : // saves pointer to it) to ensure correct destruction order.
2841 68 : fltSemantics extendedSemantics = *semantics;
2842 68 : extendedSemantics.minExponent = semIEEEdouble.minExponent;
2843 136 : IEEEFloat extended(*this);
2844 68 : fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2845 : assert(fs == opOK && !losesInfo);
2846 : (void)fs;
2847 :
2848 68 : IEEEFloat u(extended);
2849 68 : fs = u.convert(semIEEEdouble, rmNearestTiesToEven, &losesInfo);
2850 : assert(fs == opOK || fs == opInexact);
2851 : (void)fs;
2852 136 : words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
2853 :
2854 : // If conversion was exact or resulted in a special case, we're done;
2855 : // just set the second double to zero. Otherwise, re-convert back to
2856 : // the extended format and compute the difference. This now should
2857 : // convert exactly to double.
2858 62 : if (u.isFiniteNonZero() && losesInfo) {
2859 6 : fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2860 : assert(fs == opOK && !losesInfo);
2861 : (void)fs;
2862 :
2863 6 : IEEEFloat v(extended);
2864 6 : v.subtract(u, rmNearestTiesToEven);
2865 6 : fs = v.convert(semIEEEdouble, rmNearestTiesToEven, &losesInfo);
2866 : assert(fs == opOK && !losesInfo);
2867 : (void)fs;
2868 12 : words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
2869 : } else {
2870 62 : words[1] = 0;
2871 : }
2872 :
2873 68 : return APInt(128, words);
2874 : }
2875 :
2876 539 : APInt IEEEFloat::convertQuadrupleAPFloatToAPInt() const {
2877 : assert(semantics == (const llvm::fltSemantics*)&semIEEEquad);
2878 : assert(partCount()==2);
2879 :
2880 : uint64_t myexponent, mysignificand, mysignificand2;
2881 :
2882 : if (isFiniteNonZero()) {
2883 388 : myexponent = exponent+16383; //bias
2884 388 : mysignificand = significandParts()[0];
2885 388 : mysignificand2 = significandParts()[1];
2886 388 : if (myexponent==1 && !(mysignificand2 & 0x1000000000000LL))
2887 : myexponent = 0; // denormal
2888 151 : } else if (category==fcZero) {
2889 : myexponent = 0;
2890 : mysignificand = mysignificand2 = 0;
2891 21 : } else if (category==fcInfinity) {
2892 : myexponent = 0x7fff;
2893 : mysignificand = mysignificand2 = 0;
2894 : } else {
2895 : assert(category == fcNaN && "Unknown category!");
2896 : myexponent = 0x7fff;
2897 18 : mysignificand = significandParts()[0];
2898 18 : mysignificand2 = significandParts()[1];
2899 : }
2900 :
2901 : uint64_t words[2];
2902 539 : words[0] = mysignificand;
2903 1617 : words[1] = ((uint64_t)(sign & 1) << 63) |
2904 1078 : ((myexponent & 0x7fff) << 48) |
2905 539 : (mysignificand2 & 0xffffffffffffLL);
2906 :
2907 539 : return APInt(128, words);
2908 : }
2909 :
2910 248710 : APInt IEEEFloat::convertDoubleAPFloatToAPInt() const {
2911 : assert(semantics == (const llvm::fltSemantics*)&semIEEEdouble);
2912 : assert(partCount()==1);
2913 :
2914 : uint64_t myexponent, mysignificand;
2915 :
2916 : if (isFiniteNonZero()) {
2917 165169 : myexponent = exponent+1023; //bias
2918 165169 : mysignificand = *significandParts();
2919 165169 : if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2920 : myexponent = 0; // denormal
2921 83541 : } else if (category==fcZero) {
2922 : myexponent = 0;
2923 : mysignificand = 0;
2924 16495 : } else if (category==fcInfinity) {
2925 : myexponent = 0x7ff;
2926 : mysignificand = 0;
2927 : } else {
2928 : assert(category == fcNaN && "Unknown category!");
2929 : myexponent = 0x7ff;
2930 14919 : mysignificand = *significandParts();
2931 : }
2932 :
2933 497420 : return APInt(64, ((((uint64_t)(sign & 1) << 63) |
2934 497420 : ((myexponent & 0x7ff) << 52) |
2935 248710 : (mysignificand & 0xfffffffffffffLL))));
2936 : }
2937 :
2938 186163 : APInt IEEEFloat::convertFloatAPFloatToAPInt() const {
2939 : assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle);
2940 : assert(partCount()==1);
2941 :
2942 : uint32_t myexponent, mysignificand;
2943 :
2944 : if (isFiniteNonZero()) {
2945 103003 : myexponent = exponent+127; //bias
2946 103003 : mysignificand = (uint32_t)*significandParts();
2947 103003 : if (myexponent == 1 && !(mysignificand & 0x800000))
2948 : myexponent = 0; // denormal
2949 83160 : } else if (category==fcZero) {
2950 : myexponent = 0;
2951 : mysignificand = 0;
2952 17664 : } else if (category==fcInfinity) {
2953 : myexponent = 0xff;
2954 : mysignificand = 0;
2955 : } else {
2956 : assert(category == fcNaN && "Unknown category!");
2957 : myexponent = 0xff;
2958 17320 : mysignificand = (uint32_t)*significandParts();
2959 : }
2960 :
2961 372326 : return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
2962 186163 : (mysignificand & 0x7fffff)));
2963 : }
2964 :
2965 11200 : APInt IEEEFloat::convertHalfAPFloatToAPInt() const {
2966 : assert(semantics == (const llvm::fltSemantics*)&semIEEEhalf);
2967 : assert(partCount()==1);
2968 :
2969 : uint32_t myexponent, mysignificand;
2970 :
2971 : if (isFiniteNonZero()) {
2972 9822 : myexponent = exponent+15; //bias
2973 9822 : mysignificand = (uint32_t)*significandParts();
2974 9822 : if (myexponent == 1 && !(mysignificand & 0x400))
2975 : myexponent = 0; // denormal
2976 1378 : } else if (category==fcZero) {
2977 : myexponent = 0;
2978 : mysignificand = 0;
2979 220 : } else if (category==fcInfinity) {
2980 : myexponent = 0x1f;
2981 : mysignificand = 0;
2982 : } else {
2983 : assert(category == fcNaN && "Unknown category!");
2984 : myexponent = 0x1f;
2985 153 : mysignificand = (uint32_t)*significandParts();
2986 : }
2987 :
2988 22400 : return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
2989 11200 : (mysignificand & 0x3ff)));
2990 : }
2991 :
2992 : // This function creates an APInt that is just a bit map of the floating
2993 : // point constant as it would appear in memory. It is not a conversion,
2994 : // and treating the result as a normal integer is unlikely to be useful.
2995 :
2996 468872 : APInt IEEEFloat::bitcastToAPInt() const {
2997 468872 : if (semantics == (const llvm::fltSemantics*)&semIEEEhalf)
2998 11200 : return convertHalfAPFloatToAPInt();
2999 :
3000 457672 : if (semantics == (const llvm::fltSemantics*)&semIEEEsingle)
3001 186163 : return convertFloatAPFloatToAPInt();
3002 :
3003 271509 : if (semantics == (const llvm::fltSemantics*)&semIEEEdouble)
3004 248636 : return convertDoubleAPFloatToAPInt();
3005 :
3006 22873 : if (semantics == (const llvm::fltSemantics*)&semIEEEquad)
3007 539 : return convertQuadrupleAPFloatToAPInt();
3008 :
3009 22334 : if (semantics == (const llvm::fltSemantics *)&semPPCDoubleDoubleLegacy)
3010 68 : return convertPPCDoubleDoubleAPFloatToAPInt();
3011 :
3012 : assert(semantics == (const llvm::fltSemantics*)&semX87DoubleExtended &&
3013 : "unknown format!");
3014 22266 : return convertF80LongDoubleAPFloatToAPInt();
3015 : }
3016 :
3017 11300 : float IEEEFloat::convertToFloat() const {
3018 : assert(semantics == (const llvm::fltSemantics*)&semIEEEsingle &&
3019 : "Float semantics are not IEEEsingle");
3020 11300 : APInt api = bitcastToAPInt();
3021 11300 : return api.bitsToFloat();
3022 : }
3023 :
3024 24723 : double IEEEFloat::convertToDouble() const {
3025 : assert(semantics == (const llvm::fltSemantics*)&semIEEEdouble &&
3026 : "Float semantics are not IEEEdouble");
3027 24723 : APInt api = bitcastToAPInt();
3028 24723 : return api.bitsToDouble();
3029 : }
3030 :
3031 : /// Integer bit is explicit in this format. Intel hardware (387 and later)
3032 : /// does not support these bit patterns:
3033 : /// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
3034 : /// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
3035 : /// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
3036 : /// exponent = 0, integer bit 1 ("pseudodenormal")
3037 : /// At the moment, the first three are treated as NaNs, the last one as Normal.
3038 22044 : void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
3039 : assert(api.getBitWidth()==80);
3040 22044 : uint64_t i1 = api.getRawData()[0];
3041 22044 : uint64_t i2 = api.getRawData()[1];
3042 22044 : uint64_t myexponent = (i2 & 0x7fff);
3043 : uint64_t mysignificand = i1;
3044 22044 : uint8_t myintegerbit = mysignificand >> 63;
3045 :
3046 22044 : initialize(&semX87DoubleExtended);
3047 : assert(partCount()==2);
3048 :
3049 22044 : sign = static_cast<unsigned int>(i2>>15);
3050 22044 : if (myexponent == 0 && mysignificand == 0) {
3051 : // exponent, significand meaningless
3052 756 : category = fcZero;
3053 21288 : } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3054 : // exponent, significand meaningless
3055 1 : category = fcInfinity;
3056 21287 : } else if ((myexponent == 0x7fff && mysignificand != 0x8000000000000000ULL) ||
3057 21283 : (myexponent != 0x7fff && myexponent != 0 && myintegerbit == 0)) {
3058 : // exponent meaningless
3059 6 : category = fcNaN;
3060 6 : significandParts()[0] = mysignificand;
3061 6 : significandParts()[1] = 0;
3062 : } else {
3063 21281 : category = fcNormal;
3064 21281 : exponent = myexponent - 16383;
3065 21281 : significandParts()[0] = mysignificand;
3066 21281 : significandParts()[1] = 0;
3067 21281 : if (myexponent==0) // denormal
3068 5155 : exponent = -16382;
3069 : }
3070 22044 : }
3071 :
3072 24 : void IEEEFloat::initFromPPCDoubleDoubleAPInt(const APInt &api) {
3073 : assert(api.getBitWidth()==128);
3074 24 : uint64_t i1 = api.getRawData()[0];
3075 24 : uint64_t i2 = api.getRawData()[1];
3076 : opStatus fs;
3077 : bool losesInfo;
3078 :
3079 : // Get the first double and convert to our format.
3080 24 : initFromDoubleAPInt(APInt(64, i1));
3081 24 : fs = convert(semPPCDoubleDoubleLegacy, rmNearestTiesToEven, &losesInfo);
3082 : assert(fs == opOK && !losesInfo);
3083 : (void)fs;
3084 :
3085 : // Unless we have a special case, add in second double.
3086 : if (isFiniteNonZero()) {
3087 40 : IEEEFloat v(semIEEEdouble, APInt(64, i2));
3088 20 : fs = v.convert(semPPCDoubleDoubleLegacy, rmNearestTiesToEven, &losesInfo);
3089 : assert(fs == opOK && !losesInfo);
3090 : (void)fs;
3091 :
3092 20 : add(v, rmNearestTiesToEven);
3093 : }
3094 24 : }
3095 :
3096 490 : void IEEEFloat::initFromQuadrupleAPInt(const APInt &api) {
3097 : assert(api.getBitWidth()==128);
3098 490 : uint64_t i1 = api.getRawData()[0];
3099 490 : uint64_t i2 = api.getRawData()[1];
3100 490 : uint64_t myexponent = (i2 >> 48) & 0x7fff;
3101 : uint64_t mysignificand = i1;
3102 490 : uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
3103 :
3104 490 : initialize(&semIEEEquad);
3105 : assert(partCount()==2);
3106 :
3107 490 : sign = static_cast<unsigned int>(i2>>63);
3108 490 : if (myexponent==0 &&
3109 190 : (mysignificand==0 && mysignificand2==0)) {
3110 : // exponent, significand meaningless
3111 188 : category = fcZero;
3112 302 : } else if (myexponent==0x7fff &&
3113 27 : (mysignificand==0 && mysignificand2==0)) {
3114 : // exponent, significand meaningless
3115 3 : category = fcInfinity;
3116 299 : } else if (myexponent==0x7fff &&
3117 24 : (mysignificand!=0 || mysignificand2 !=0)) {
3118 : // exponent meaningless
3119 24 : category = fcNaN;
3120 24 : significandParts()[0] = mysignificand;
3121 24 : significandParts()[1] = mysignificand2;
3122 : } else {
3123 275 : category = fcNormal;
3124 275 : exponent = myexponent - 16383;
3125 275 : significandParts()[0] = mysignificand;
3126 275 : significandParts()[1] = mysignificand2;
3127 275 : if (myexponent==0) // denormal
3128 2 : exponent = -16382;
3129 : else
3130 273 : significandParts()[1] |= 0x1000000000000LL; // integer bit
3131 : }
3132 490 : }
3133 :
3134 4987543 : void IEEEFloat::initFromDoubleAPInt(const APInt &api) {
3135 : assert(api.getBitWidth()==64);
3136 4987543 : uint64_t i = *api.getRawData();
3137 4987543 : uint64_t myexponent = (i >> 52) & 0x7ff;
3138 4987543 : uint64_t mysignificand = i & 0xfffffffffffffLL;
3139 :
3140 4987543 : initialize(&semIEEEdouble);
3141 : assert(partCount()==1);
3142 :
3143 4987543 : sign = static_cast<unsigned int>(i>>63);
3144 4987543 : if (myexponent==0 && mysignificand==0) {
3145 : // exponent, significand meaningless
3146 4812129 : category = fcZero;
3147 175414 : } else if (myexponent==0x7ff && mysignificand==0) {
3148 : // exponent, significand meaningless
3149 426 : category = fcInfinity;
3150 174988 : } else if (myexponent==0x7ff && mysignificand!=0) {
3151 : // exponent meaningless
3152 10943 : category = fcNaN;
3153 10943 : *significandParts() = mysignificand;
3154 : } else {
3155 164045 : category = fcNormal;
3156 164045 : exponent = myexponent - 1023;
3157 164045 : *significandParts() = mysignificand;
3158 164045 : if (myexponent==0) // denormal
3159 5514 : exponent = -1022;
3160 : else
3161 158531 : *significandParts() |= 0x10000000000000LL; // integer bit
3162 : }
3163 4987543 : }
3164 :
3165 108175 : void IEEEFloat::initFromFloatAPInt(const APInt &api) {
3166 : assert(api.getBitWidth()==32);
3167 108175 : uint32_t i = (uint32_t)*api.getRawData();
3168 108175 : uint32_t myexponent = (i >> 23) & 0xff;
3169 108175 : uint32_t mysignificand = i & 0x7fffff;
3170 :
3171 108175 : initialize(&semIEEEsingle);
3172 : assert(partCount()==1);
3173 :
3174 108175 : sign = i >> 31;
3175 108175 : if (myexponent==0 && mysignificand==0) {
3176 : // exponent, significand meaningless
3177 35901 : category = fcZero;
3178 72274 : } else if (myexponent==0xff && mysignificand==0) {
3179 : // exponent, significand meaningless
3180 139 : category = fcInfinity;
3181 72135 : } else if (myexponent==0xff && mysignificand!=0) {
3182 : // sign, exponent, significand meaningless
3183 11385 : category = fcNaN;
3184 11385 : *significandParts() = mysignificand;
3185 : } else {
3186 60750 : category = fcNormal;
3187 60750 : exponent = myexponent - 127; //bias
3188 60750 : *significandParts() = mysignificand;
3189 60750 : if (myexponent==0) // denormal
3190 5736 : exponent = -126;
3191 : else
3192 55014 : *significandParts() |= 0x800000; // integer bit
3193 : }
3194 108175 : }
3195 :
3196 5832 : void IEEEFloat::initFromHalfAPInt(const APInt &api) {
3197 : assert(api.getBitWidth()==16);
3198 5832 : uint32_t i = (uint32_t)*api.getRawData();
3199 5832 : uint32_t myexponent = (i >> 10) & 0x1f;
3200 5832 : uint32_t mysignificand = i & 0x3ff;
3201 :
3202 5832 : initialize(&semIEEEhalf);
3203 : assert(partCount()==1);
3204 :
3205 5832 : sign = i >> 15;
3206 5832 : if (myexponent==0 && mysignificand==0) {
3207 : // exponent, significand meaningless
3208 1030 : category = fcZero;
3209 4802 : } else if (myexponent==0x1f && mysignificand==0) {
3210 : // exponent, significand meaningless
3211 63 : category = fcInfinity;
3212 4739 : } else if (myexponent==0x1f && mysignificand!=0) {
3213 : // sign, exponent, significand meaningless
3214 113 : category = fcNaN;
3215 113 : *significandParts() = mysignificand;
3216 : } else {
3217 4626 : category = fcNormal;
3218 4626 : exponent = myexponent - 15; //bias
3219 4626 : *significandParts() = mysignificand;
3220 4626 : if (myexponent==0) // denormal
3221 905 : exponent = -14;
3222 : else
3223 3721 : *significandParts() |= 0x400; // integer bit
3224 : }
3225 5832 : }
3226 :
3227 : /// Treat api as containing the bits of a floating point number. Currently
3228 : /// we infer the floating point type from the size of the APInt. The
3229 : /// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
3230 : /// when the size is anything else).
3231 5124084 : void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
3232 5124084 : if (Sem == &semIEEEhalf)
3233 5832 : return initFromHalfAPInt(api);
3234 5118252 : if (Sem == &semIEEEsingle)
3235 108175 : return initFromFloatAPInt(api);
3236 5010077 : if (Sem == &semIEEEdouble)
3237 4987519 : return initFromDoubleAPInt(api);
3238 22558 : if (Sem == &semX87DoubleExtended)
3239 22044 : return initFromF80LongDoubleAPInt(api);
3240 514 : if (Sem == &semIEEEquad)
3241 490 : return initFromQuadrupleAPInt(api);
3242 24 : if (Sem == &semPPCDoubleDoubleLegacy)
3243 24 : return initFromPPCDoubleDoubleAPInt(api);
3244 :
3245 0 : llvm_unreachable(nullptr);
3246 : }
3247 :
3248 : /// Make this number the largest magnitude normal number in the given
3249 : /// semantics.
3250 276 : void IEEEFloat::makeLargest(bool Negative) {
3251 : // We want (in interchange format):
3252 : // sign = {Negative}
3253 : // exponent = 1..10
3254 : // significand = 1..1
3255 276 : category = fcNormal;
3256 276 : sign = Negative;
3257 276 : exponent = semantics->maxExponent;
3258 :
3259 : // Use memset to set all but the highest integerPart to all ones.
3260 276 : integerPart *significand = significandParts();
3261 276 : unsigned PartCount = partCount();
3262 276 : memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));
3263 :
3264 : // Set the high integerPart especially setting all unused top bits for
3265 : // internal consistency.
3266 276 : const unsigned NumUnusedHighBits =
3267 276 : PartCount*integerPartWidth - semantics->precision;
3268 276 : significand[PartCount - 1] = (NumUnusedHighBits < integerPartWidth)
3269 276 : ? (~integerPart(0) >> NumUnusedHighBits)
3270 : : 0;
3271 276 : }
3272 :
3273 : /// Make this number the smallest magnitude denormal number in the given
3274 : /// semantics.
3275 50 : void IEEEFloat::makeSmallest(bool Negative) {
3276 : // We want (in interchange format):
3277 : // sign = {Negative}
3278 : // exponent = 0..0
3279 : // significand = 0..01
3280 50 : category = fcNormal;
3281 50 : sign = Negative;
3282 50 : exponent = semantics->minExponent;
3283 50 : APInt::tcSet(significandParts(), 1, partCount());
3284 50 : }
3285 :
3286 123 : void IEEEFloat::makeSmallestNormalized(bool Negative) {
3287 : // We want (in interchange format):
3288 : // sign = {Negative}
3289 : // exponent = 0..0
3290 : // significand = 10..0
3291 :
3292 123 : category = fcNormal;
3293 123 : zeroSignificand();
3294 123 : sign = Negative;
3295 123 : exponent = semantics->minExponent;
3296 123 : significandParts()[partCountForBits(semantics->precision) - 1] |=
3297 123 : (((integerPart)1) << ((semantics->precision - 1) % integerPartWidth));
3298 123 : }
3299 :
3300 279412 : IEEEFloat::IEEEFloat(const fltSemantics &Sem, const APInt &API) {
3301 279412 : initFromAPInt(&Sem, API);
3302 279412 : }
3303 :
3304 25821 : IEEEFloat::IEEEFloat(float f) {
3305 25821 : initFromAPInt(&semIEEEsingle, APInt::floatToBits(f));
3306 25821 : }
3307 :
3308 4818851 : IEEEFloat::IEEEFloat(double d) {
3309 4818851 : initFromAPInt(&semIEEEdouble, APInt::doubleToBits(d));
3310 4818851 : }
3311 :
3312 : namespace {
3313 : void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
3314 11386 : Buffer.append(Str.begin(), Str.end());
3315 : }
3316 :
3317 : /// Removes data from the given significand until it is no more
3318 : /// precise than is required for the desired precision.
3319 27400 : void AdjustToPrecision(APInt &significand,
3320 : int &exp, unsigned FormatPrecision) {
3321 : unsigned bits = significand.getActiveBits();
3322 :
3323 : // 196/59 is a very slight overestimate of lg_2(10).
3324 27400 : unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
3325 :
3326 27463 : if (bits <= bitsRequired) return;
3327 :
3328 4797 : unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
3329 4797 : if (!tensRemovable) return;
3330 :
3331 4734 : exp += tensRemovable;
3332 :
3333 4734 : APInt divisor(significand.getBitWidth(), 1);
3334 4734 : APInt powten(significand.getBitWidth(), 10);
3335 : while (true) {
3336 23934 : if (tensRemovable & 1)
3337 13884 : divisor *= powten;
3338 23934 : tensRemovable >>= 1;
3339 23934 : if (!tensRemovable) break;
3340 19200 : powten *= powten;
3341 : }
3342 :
3343 9468 : significand = significand.udiv(divisor);
3344 :
3345 : // Truncate the significand down to its active bit count.
3346 9468 : significand = significand.trunc(significand.getActiveBits());
3347 : }
3348 :
3349 :
3350 27400 : void AdjustToPrecision(SmallVectorImpl<char> &buffer,
3351 : int &exp, unsigned FormatPrecision) {
3352 27400 : unsigned N = buffer.size();
3353 27400 : if (N <= FormatPrecision) return;
3354 :
3355 : // The most significant figures are the last ones in the buffer.
3356 3577 : unsigned FirstSignificant = N - FormatPrecision;
3357 :
3358 : // Round.
3359 : // FIXME: this probably shouldn't use 'round half up'.
3360 :
3361 : // Rounding down is just a truncation, except we also want to drop
3362 : // trailing zeros from the new result.
3363 7154 : if (buffer[FirstSignificant - 1] < '5') {
3364 2546 : while (FirstSignificant < N && buffer[FirstSignificant] == '0')
3365 919 : FirstSignificant++;
3366 :
3367 1627 : exp += FirstSignificant;
3368 3254 : buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3369 1627 : return;
3370 : }
3371 :
3372 : // Rounding up requires a decimal add-with-carry. If we continue
3373 : // the carry, the newly-introduced zeros will just be truncated.
3374 4519 : for (unsigned I = FirstSignificant; I != N; ++I) {
3375 9036 : if (buffer[I] == '9') {
3376 2569 : FirstSignificant++;
3377 : } else {
3378 1949 : buffer[I]++;
3379 1949 : break;
3380 : }
3381 : }
3382 :
3383 : // If we carried through, we have exactly one digit of precision.
3384 1950 : if (FirstSignificant == N) {
3385 1 : exp += FirstSignificant;
3386 : buffer.clear();
3387 1 : buffer.push_back('1');
3388 1 : return;
3389 : }
3390 :
3391 1949 : exp += FirstSignificant;
3392 3898 : buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3393 : }
3394 : }
3395 :
3396 35291 : void IEEEFloat::toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
3397 : unsigned FormatMaxPadding, bool TruncateZero) const {
3398 35291 : switch (category) {
3399 : case fcInfinity:
3400 161 : if (isNegative())
3401 31859 : return append(Str, "-Inf");
3402 : else
3403 98 : return append(Str, "+Inf");
3404 :
3405 835 : case fcNaN: return append(Str, "NaN");
3406 :
3407 : case fcZero:
3408 6895 : if (isNegative())
3409 3358 : Str.push_back('-');
3410 :
3411 6895 : if (!FormatMaxPadding) {
3412 5195 : if (TruncateZero)
3413 : append(Str, "0.0E+0");
3414 : else {
3415 : append(Str, "0.0");
3416 5195 : if (FormatPrecision > 1)
3417 5195 : Str.append(FormatPrecision - 1, '0');
3418 : append(Str, "e+00");
3419 : }
3420 : } else
3421 1700 : Str.push_back('0');
3422 : return;
3423 :
3424 : case fcNormal:
3425 : break;
3426 : }
3427 :
3428 27400 : if (isNegative())
3429 2408 : Str.push_back('-');
3430 :
3431 : // Decompose the number into an APInt and an exponent.
3432 27400 : int exp = exponent - ((int) semantics->precision - 1);
3433 27400 : APInt significand(semantics->precision,
3434 : makeArrayRef(significandParts(),
3435 27400 : partCountForBits(semantics->precision)));
3436 :
3437 : // Set FormatPrecision if zero. We want to do this before we
3438 : // truncate trailing zeros, as those are part of the precision.
3439 27400 : if (!FormatPrecision) {
3440 : // We use enough digits so the number can be round-tripped back to an
3441 : // APFloat. The formula comes from "How to Print Floating-Point Numbers
3442 : // Accurately" by Steele and White.
3443 : // FIXME: Using a formula based purely on the precision is conservative;
3444 : // we can print fewer digits depending on the actual value being printed.
3445 :
3446 : // FormatPrecision = 2 + floor(significandBits / lg_2(10))
3447 15360 : FormatPrecision = 2 + semantics->precision * 59 / 196;
3448 : }
3449 :
3450 : // Ignore trailing binary zeros.
3451 27400 : int trailingZeros = significand.countTrailingZeros();
3452 27400 : exp += trailingZeros;
3453 : significand.lshrInPlace(trailingZeros);
3454 :
3455 : // Change the exponent from 2^e to 10^e.
3456 27400 : if (exp == 0) {
3457 : // Nothing to do.
3458 14605 : } else if (exp > 0) {
3459 : // Just shift left.
3460 7314 : significand = significand.zext(semantics->precision + exp);
3461 7314 : significand <<= exp;
3462 7314 : exp = 0;
3463 : } else { /* exp < 0 */
3464 7291 : int texp = -exp;
3465 :
3466 : // We transform this using the identity:
3467 : // (N)(2^-e) == (N)(5^e)(10^-e)
3468 : // This means we have to multiply N (the significand) by 5^e.
3469 : // To avoid overflow, we have to operate on numbers large
3470 : // enough to store N * 5^e:
3471 : // log2(N * 5^e) == log2(N) + e * log2(5)
3472 : // <= semantics->precision + e * 137 / 59
3473 : // (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)
3474 :
3475 7291 : unsigned precision = semantics->precision + (137 * texp + 136) / 59;
3476 :
3477 : // Multiply significand by 5^e.
3478 : // N * 5^0101 == N * 5^(1*1) * 5^(0*2) * 5^(1*4) * 5^(0*8)
3479 14582 : significand = significand.zext(precision);
3480 : APInt five_to_the_i(precision, 5);
3481 : while (true) {
3482 27107 : if (texp & 1) significand *= five_to_the_i;
3483 :
3484 27107 : texp >>= 1;
3485 27107 : if (!texp) break;
3486 19816 : five_to_the_i *= five_to_the_i;
3487 : }
3488 : }
3489 :
3490 27400 : AdjustToPrecision(significand, exp, FormatPrecision);
3491 :
3492 : SmallVector<char, 256> buffer;
3493 :
3494 : // Fill the buffer.
3495 27400 : unsigned precision = significand.getBitWidth();
3496 : APInt ten(precision, 10);
3497 : APInt digit(precision, 0);
3498 :
3499 : bool inTrail = true;
3500 116361 : while (significand != 0) {
3501 : // digit <- significand % 10
3502 : // significand <- significand / 10
3503 88961 : APInt::udivrem(significand, ten, significand, digit);
3504 :
3505 88961 : unsigned d = digit.getZExtValue();
3506 :
3507 : // Drop trailing zeros.
3508 88961 : if (inTrail && !d) exp++;
3509 : else {
3510 85828 : buffer.push_back((char) ('0' + d));
3511 : inTrail = false;
3512 : }
3513 : }
3514 :
3515 : assert(!buffer.empty() && "no characters in buffer!");
3516 :
3517 : // Drop down to FormatPrecision.
3518 : // TODO: don't do more precise calculations above than are required.
3519 27400 : AdjustToPrecision(buffer, exp, FormatPrecision);
3520 :
3521 27400 : unsigned NDigits = buffer.size();
3522 :
3523 : // Check whether we should use scientific notation.
3524 : bool FormatScientific;
3525 27400 : if (!FormatMaxPadding)
3526 : FormatScientific = true;
3527 : else {
3528 15514 : if (exp >= 0) {
3529 : // 765e3 --> 765000
3530 : // ^^^
3531 : // But we shouldn't make the number look more precise than it is.
3532 11144 : FormatScientific = ((unsigned) exp > FormatMaxPadding ||
3533 10770 : NDigits + (unsigned) exp > FormatPrecision);
3534 : } else {
3535 : // Power of the most significant digit.
3536 4370 : int MSD = exp + (int) (NDigits - 1);
3537 4370 : if (MSD >= 0) {
3538 : // 765e-2 == 7.65
3539 : FormatScientific = false;
3540 : } else {
3541 : // 765e-5 == 0.00765
3542 : // ^ ^^
3543 1697 : FormatScientific = ((unsigned) -MSD) > FormatMaxPadding;
3544 : }
3545 : }
3546 : }
3547 :
3548 : // Scientific formatting is pretty straightforward.
3549 1697 : if (FormatScientific) {
3550 13519 : exp += (NDigits - 1);
3551 :
3552 27038 : Str.push_back(buffer[NDigits-1]);
3553 13519 : Str.push_back('.');
3554 13519 : if (NDigits == 1 && TruncateZero)
3555 63 : Str.push_back('0');
3556 : else
3557 33695 : for (unsigned I = 1; I != NDigits; ++I)
3558 40478 : Str.push_back(buffer[NDigits-1-I]);
3559 : // Fill with zeros up to FormatPrecision.
3560 13519 : if (!TruncateZero && FormatPrecision > NDigits - 1)
3561 11887 : Str.append(FormatPrecision - NDigits + 1, '0');
3562 : // For !TruncateZero we use lower 'e'.
3563 25406 : Str.push_back(TruncateZero ? 'E' : 'e');
3564 :
3565 16435 : Str.push_back(exp >= 0 ? '+' : '-');
3566 13519 : if (exp < 0) exp = -exp;
3567 : SmallVector<char, 6> expbuf;
3568 : do {
3569 15269 : expbuf.push_back((char) ('0' + (exp % 10)));
3570 15269 : exp /= 10;
3571 15269 : } while (exp);
3572 : // Exponent always at least two digits if we do not truncate zeros.
3573 13519 : if (!TruncateZero && expbuf.size() < 2)
3574 11759 : expbuf.push_back('0');
3575 40547 : for (unsigned I = 0, E = expbuf.size(); I != E; ++I)
3576 54056 : Str.push_back(expbuf[E-1-I]);
3577 : return;
3578 : }
3579 :
3580 : // Non-scientific, positive exponents.
3581 13881 : if (exp >= 0) {
3582 26264 : for (unsigned I = 0; I != NDigits; ++I)
3583 31630 : Str.push_back(buffer[NDigits-1-I]);
3584 10942 : for (unsigned I = 0; I != (unsigned) exp; ++I)
3585 493 : Str.push_back('0');
3586 : return;
3587 : }
3588 :
3589 : // Non-scientific, negative exponents.
3590 :
3591 : // The number of digits to the left of the decimal point.
3592 3432 : int NWholeDigits = exp + (int) NDigits;
3593 :
3594 : unsigned I = 0;
3595 3432 : if (NWholeDigits > 0) {
3596 7405 : for (; I != (unsigned) NWholeDigits; ++I)
3597 9464 : Str.push_back(buffer[NDigits-I-1]);
3598 2673 : Str.push_back('.');
3599 : } else {
3600 759 : unsigned NZeros = 1 + (unsigned) -NWholeDigits;
3601 :
3602 759 : Str.push_back('0');
3603 759 : Str.push_back('.');
3604 1125 : for (unsigned Z = 1; Z != NZeros; ++Z)
3605 366 : Str.push_back('0');
3606 : }
3607 :
3608 27806 : for (; I != NDigits; ++I)
3609 48748 : Str.push_back(buffer[NDigits-I-1]);
3610 : }
3611 :
3612 126 : bool IEEEFloat::getExactInverse(APFloat *inv) const {
3613 : // Special floats and denormals have no exact inverse.
3614 : if (!isFiniteNonZero())
3615 : return false;
3616 :
3617 : // Check that the number is a power of two by making sure that only the
3618 : // integer bit is set in the significand.
3619 125 : if (significandLSB() != semantics->precision - 1)
3620 : return false;
3621 :
3622 : // Get the inverse.
3623 90 : IEEEFloat reciprocal(*semantics, 1ULL);
3624 45 : if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
3625 : return false;
3626 :
3627 : // Avoid multiplication with a denormal, it is not safe on all platforms and
3628 : // may be slower than a normal division.
3629 45 : if (reciprocal.isDenormal())
3630 : return false;
3631 :
3632 : assert(reciprocal.isFiniteNonZero() &&
3633 : reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
3634 :
3635 43 : if (inv)
3636 12 : *inv = APFloat(reciprocal, *semantics);
3637 :
3638 : return true;
3639 : }
3640 :
3641 7360 : bool IEEEFloat::isSignaling() const {
3642 7360 : if (!isNaN())
3643 : return false;
3644 :
3645 : // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
3646 : // first bit of the trailing significand being 0.
3647 385 : return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3648 : }
3649 :
3650 : /// IEEE-754R 2008 5.3.1: nextUp/nextDown.
3651 : ///
3652 : /// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
3653 : /// appropriate sign switching before/after the computation.
3654 47 : IEEEFloat::opStatus IEEEFloat::next(bool nextDown) {
3655 : // If we are performing nextDown, swap sign so we have -x.
3656 47 : if (nextDown)
3657 22 : changeSign();
3658 :
3659 : // Compute nextUp(x)
3660 : opStatus result = opOK;
3661 :
3662 : // Handle each float category separately.
3663 47 : switch (category) {
3664 : case fcInfinity:
3665 : // nextUp(+inf) = +inf
3666 4 : if (!isNegative())
3667 : break;
3668 : // nextUp(-inf) = -getLargest()
3669 2 : makeLargest(true);
3670 2 : break;
3671 4 : case fcNaN:
3672 : // IEEE-754R 2008 6.2 Par 2: nextUp(sNaN) = qNaN. Set Invalid flag.
3673 : // IEEE-754R 2008 6.2: nextUp(qNaN) = qNaN. Must be identity so we do not
3674 : // change the payload.
3675 4 : if (isSignaling()) {
3676 : result = opInvalidOp;
3677 : // For consistency, propagate the sign of the sNaN to the qNaN.
3678 2 : makeNaN(false, isNegative(), nullptr);
3679 : }
3680 : break;
3681 4 : case fcZero:
3682 : // nextUp(pm 0) = +getSmallest()
3683 4 : makeSmallest(false);
3684 4 : break;
3685 35 : case fcNormal:
3686 : // nextUp(-getSmallest()) = -0
3687 35 : if (isSmallest() && isNegative()) {
3688 2 : APInt::tcSet(significandParts(), 0, partCount());
3689 2 : category = fcZero;
3690 2 : exponent = 0;
3691 2 : break;
3692 : }
3693 :
3694 : // nextUp(getLargest()) == INFINITY
3695 33 : if (isLargest() && !isNegative()) {
3696 2 : APInt::tcSet(significandParts(), 0, partCount());
3697 2 : category = fcInfinity;
3698 2 : exponent = semantics->maxExponent + 1;
3699 2 : break;
3700 : }
3701 :
3702 : // nextUp(normal) == normal + inc.
3703 31 : if (isNegative()) {
3704 : // If we are negative, we need to decrement the significand.
3705 :
3706 : // We only cross a binade boundary that requires adjusting the exponent
3707 : // if:
3708 : // 1. exponent != semantics->minExponent. This implies we are not in the
3709 : // smallest binade or are dealing with denormals.
3710 : // 2. Our significand excluding the integral bit is all zeros.
3711 : bool WillCrossBinadeBoundary =
3712 14 : exponent != semantics->minExponent && isSignificandAllZeros();
3713 :
3714 : // Decrement the significand.
3715 : //
3716 : // We always do this since:
3717 : // 1. If we are dealing with a non-binade decrement, by definition we
3718 : // just decrement the significand.
3719 : // 2. If we are dealing with a normal -> normal binade decrement, since
3720 : // we have an explicit integral bit the fact that all bits but the
3721 : // integral bit are zero implies that subtracting one will yield a
3722 : // significand with 0 integral bit and 1 in all other spots. Thus we
3723 : // must just adjust the exponent and set the integral bit to 1.
3724 : // 3. If we are dealing with a normal -> denormal binade decrement,
3725 : // since we set the integral bit to 0 when we represent denormals, we
3726 : // just decrement the significand.
3727 14 : integerPart *Parts = significandParts();
3728 14 : APInt::tcDecrement(Parts, partCount());
3729 :
3730 14 : if (WillCrossBinadeBoundary) {
3731 : // Our result is a normal number. Do the following:
3732 : // 1. Set the integral bit to 1.
3733 : // 2. Decrement the exponent.
3734 4 : APInt::tcSetBit(Parts, semantics->precision - 1);
3735 4 : exponent--;
3736 : }
3737 : } else {
3738 : // If we are positive, we need to increment the significand.
3739 :
3740 : // We only cross a binade boundary that requires adjusting the exponent if
3741 : // the input is not a denormal and all of said input's significand bits
3742 : // are set. If all of said conditions are true: clear the significand, set
3743 : // the integral bit to 1, and increment the exponent. If we have a
3744 : // denormal always increment since moving denormals and the numbers in the
3745 : // smallest normal binade have the same exponent in our representation.
3746 17 : bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();
3747 :
3748 : if (WillCrossBinadeBoundary) {
3749 4 : integerPart *Parts = significandParts();
3750 4 : APInt::tcSet(Parts, 0, partCount());
3751 4 : APInt::tcSetBit(Parts, semantics->precision - 1);
3752 : assert(exponent != semantics->maxExponent &&
3753 : "We can not increment an exponent beyond the maxExponent allowed"
3754 : " by the given floating point semantics.");
3755 4 : exponent++;
3756 : } else {
3757 13 : incrementSignificand();
3758 : }
3759 : }
3760 : break;
3761 : }
3762 :
3763 : // If we are performing nextDown, swap sign so we have -nextUp(-x)
3764 47 : if (nextDown)
3765 22 : changeSign();
3766 :
3767 47 : return result;
3768 : }
3769 :
3770 18134 : void IEEEFloat::makeInf(bool Negative) {
3771 18134 : category = fcInfinity;
3772 18134 : sign = Negative;
3773 18134 : exponent = semantics->maxExponent + 1;
3774 18134 : APInt::tcSet(significandParts(), 0, partCount());
3775 18134 : }
3776 :
3777 220846 : void IEEEFloat::makeZero(bool Negative) {
3778 220846 : category = fcZero;
3779 220846 : sign = Negative;
3780 220846 : exponent = semantics->minExponent-1;
3781 220846 : APInt::tcSet(significandParts(), 0, partCount());
3782 220846 : }
3783 :
3784 43 : void IEEEFloat::makeQuiet() {
3785 : assert(isNaN());
3786 43 : APInt::tcSetBit(significandParts(), semantics->precision - 2);
3787 43 : }
3788 :
3789 310 : int ilogb(const IEEEFloat &Arg) {
3790 310 : if (Arg.isNaN())
3791 : return IEEEFloat::IEK_NaN;
3792 300 : if (Arg.isZero())
3793 : return IEEEFloat::IEK_Zero;
3794 253 : if (Arg.isInfinity())
3795 : return IEEEFloat::IEK_Inf;
3796 238 : if (!Arg.isDenormal())
3797 221 : return Arg.exponent;
3798 :
3799 17 : IEEEFloat Normalized(Arg);
3800 17 : int SignificandBits = Arg.getSemantics().precision - 1;
3801 :
3802 17 : Normalized.exponent += SignificandBits;
3803 17 : Normalized.normalize(IEEEFloat::rmNearestTiesToEven, lfExactlyZero);
3804 17 : return Normalized.exponent - SignificandBits;
3805 : }
3806 :
3807 313 : IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode RoundingMode) {
3808 313 : auto MaxExp = X.getSemantics().maxExponent;
3809 313 : auto MinExp = X.getSemantics().minExponent;
3810 :
3811 : // If Exp is wildly out-of-scale, simply adding it to X.exponent will
3812 : // overflow; clamp it to a safe range before adding, but ensure that the range
3813 : // is large enough that the clamp does not change the result. The range we
3814 : // need to support is the difference between the largest possible exponent and
3815 : // the normalized exponent of half the smallest denormal.
3816 :
3817 313 : int SignificandBits = X.getSemantics().precision - 1;
3818 313 : int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
3819 :
3820 : // Clamp to one past the range ends to let normalize handle overlflow.
3821 313 : X.exponent += std::min(std::max(Exp, -MaxIncrement - 1), MaxIncrement);
3822 313 : X.normalize(RoundingMode, lfExactlyZero);
3823 313 : if (X.isNaN())
3824 35 : X.makeQuiet();
3825 313 : return X;
3826 : }
3827 :
3828 59 : IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM) {
3829 59 : Exp = ilogb(Val);
3830 :
3831 : // Quiet signalling nans.
3832 59 : if (Exp == IEEEFloat::IEK_NaN) {
3833 16 : IEEEFloat Quiet(Val);
3834 8 : Quiet.makeQuiet();
3835 8 : return Quiet;
3836 : }
3837 :
3838 51 : if (Exp == IEEEFloat::IEK_Inf)
3839 10 : return Val;
3840 :
3841 : // 1 is added because frexp is defined to return a normalized fraction in
3842 : // +/-[0.5, 1.0), rather than the usual +/-[1.0, 2.0).
3843 41 : Exp = Exp == IEEEFloat::IEK_Zero ? 0 : Exp + 1;
3844 41 : return scalbn(Val, -Exp, RM);
3845 : }
3846 :
3847 46 : DoubleAPFloat::DoubleAPFloat(const fltSemantics &S)
3848 : : Semantics(&S),
3849 46 : Floats(new APFloat[2]{APFloat(semIEEEdouble), APFloat(semIEEEdouble)}) {
3850 : assert(Semantics == &semPPCDoubleDouble);
3851 46 : }
3852 :
3853 28 : DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, uninitializedTag)
3854 : : Semantics(&S),
3855 : Floats(new APFloat[2]{APFloat(semIEEEdouble, uninitialized),
3856 28 : APFloat(semIEEEdouble, uninitialized)}) {
3857 : assert(Semantics == &semPPCDoubleDouble);
3858 28 : }
3859 :
3860 0 : DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
3861 : : Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
3862 0 : APFloat(semIEEEdouble)}) {
3863 : assert(Semantics == &semPPCDoubleDouble);
3864 0 : }
3865 :
3866 351 : DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, const APInt &I)
3867 : : Semantics(&S),
3868 : Floats(new APFloat[2]{
3869 351 : APFloat(semIEEEdouble, APInt(64, I.getRawData()[0])),
3870 1404 : APFloat(semIEEEdouble, APInt(64, I.getRawData()[1]))}) {
3871 : assert(Semantics == &semPPCDoubleDouble);
3872 351 : }
3873 :
3874 7 : DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, APFloat &&First,
3875 7 : APFloat &&Second)
3876 : : Semantics(&S),
3877 7 : Floats(new APFloat[2]{std::move(First), std::move(Second)}) {
3878 : assert(Semantics == &semPPCDoubleDouble);
3879 : assert(&Floats[0].getSemantics() == &semIEEEdouble);
3880 : assert(&Floats[1].getSemantics() == &semIEEEdouble);
3881 7 : }
3882 :
3883 372 : DoubleAPFloat::DoubleAPFloat(const DoubleAPFloat &RHS)
3884 372 : : Semantics(RHS.Semantics),
3885 : Floats(RHS.Floats ? new APFloat[2]{APFloat(RHS.Floats[0]),
3886 372 : APFloat(RHS.Floats[1])}
3887 1116 : : nullptr) {
3888 : assert(Semantics == &semPPCDoubleDouble);
3889 372 : }
3890 :
3891 200 : DoubleAPFloat::DoubleAPFloat(DoubleAPFloat &&RHS)
3892 200 : : Semantics(RHS.Semantics), Floats(std::move(RHS.Floats)) {
3893 200 : RHS.Semantics = &semBogus;
3894 : assert(Semantics == &semPPCDoubleDouble);
3895 200 : }
3896 :
3897 30 : DoubleAPFloat &DoubleAPFloat::operator=(const DoubleAPFloat &RHS) {
3898 30 : if (Semantics == RHS.Semantics && RHS.Floats) {
3899 30 : Floats[0] = RHS.Floats[0];
3900 30 : Floats[1] = RHS.Floats[1];
3901 0 : } else if (this != &RHS) {
3902 : this->~DoubleAPFloat();
3903 0 : new (this) DoubleAPFloat(RHS);
3904 : }
3905 30 : return *this;
3906 : }
3907 :
3908 : // Implement addition, subtraction, multiplication and division based on:
3909 : // "Software for Doubled-Precision Floating-Point Computations",
3910 : // by Seppo Linnainmaa, ACM TOMS vol 7 no 3, September 1981, pages 272-283.
3911 24 : APFloat::opStatus DoubleAPFloat::addImpl(const APFloat &a, const APFloat &aa,
3912 : const APFloat &c, const APFloat &cc,
3913 : roundingMode RM) {
3914 : int Status = opOK;
3915 : APFloat z = a;
3916 24 : Status |= z.add(c, RM);
3917 : if (!z.isFinite()) {
3918 6 : if (!z.isInfinity()) {
3919 : Floats[0] = std::move(z);
3920 0 : Floats[1].makeZero(/* Neg = */ false);
3921 2 : return (opStatus)Status;
3922 : }
3923 : Status = opOK;
3924 6 : auto AComparedToC = a.compareAbsoluteValue(c);
3925 : z = cc;
3926 6 : Status |= z.add(aa, RM);
3927 6 : if (AComparedToC == APFloat::cmpGreaterThan) {
3928 : // z = cc + aa + c + a;
3929 2 : Status |= z.add(c, RM);
3930 2 : Status |= z.add(a, RM);
3931 : } else {
3932 : // z = cc + aa + a + c;
3933 4 : Status |= z.add(a, RM);
3934 4 : Status |= z.add(c, RM);
3935 : }
3936 : if (!z.isFinite()) {
3937 : Floats[0] = std::move(z);
3938 2 : Floats[1].makeZero(/* Neg = */ false);
3939 2 : return (opStatus)Status;
3940 : }
3941 : Floats[0] = z;
3942 : APFloat zz = aa;
3943 4 : Status |= zz.add(cc, RM);
3944 4 : if (AComparedToC == APFloat::cmpGreaterThan) {
3945 : // Floats[1] = a - z + c + zz;
3946 : Floats[1] = a;
3947 2 : Status |= Floats[1].subtract(z, RM);
3948 2 : Status |= Floats[1].add(c, RM);
3949 2 : Status |= Floats[1].add(zz, RM);
3950 : } else {
3951 : // Floats[1] = c - z + a + zz;
3952 : Floats[1] = c;
3953 2 : Status |= Floats[1].subtract(z, RM);
3954 2 : Status |= Floats[1].add(a, RM);
3955 2 : Status |= Floats[1].add(zz, RM);
3956 : }
3957 : } else {
3958 : // q = a - z;
3959 : APFloat q = a;
3960 18 : Status |= q.subtract(z, RM);
3961 :
3962 : // zz = q + c + (a - (q + z)) + aa + cc;
3963 : // Compute a - (q + z) as -((q + z) - a) to avoid temporary copies.
3964 : auto zz = q;
3965 18 : Status |= zz.add(c, RM);
3966 18 : Status |= q.add(z, RM);
3967 18 : Status |= q.subtract(a, RM);
3968 18 : q.changeSign();
3969 18 : Status |= zz.add(q, RM);
3970 18 : Status |= zz.add(aa, RM);
3971 18 : Status |= zz.add(cc, RM);
3972 18 : if (zz.isZero() && !zz.isNegative()) {
3973 : Floats[0] = std::move(z);
3974 4 : Floats[1].makeZero(/* Neg = */ false);
3975 4 : return opOK;
3976 : }
3977 : Floats[0] = z;
3978 14 : Status |= Floats[0].add(zz, RM);
3979 : if (!Floats[0].isFinite()) {
3980 2 : Floats[1].makeZero(/* Neg = */ false);
3981 2 : return (opStatus)Status;
3982 : }
3983 : Floats[1] = std::move(z);
3984 12 : Status |= Floats[1].subtract(Floats[0], RM);
3985 12 : Status |= Floats[1].add(zz, RM);
3986 : }
3987 16 : return (opStatus)Status;
3988 : }
3989 :
3990 33 : APFloat::opStatus DoubleAPFloat::addWithSpecial(const DoubleAPFloat &LHS,
3991 : const DoubleAPFloat &RHS,
3992 : DoubleAPFloat &Out,
3993 : roundingMode RM) {
3994 33 : if (LHS.getCategory() == fcNaN) {
3995 1 : Out = LHS;
3996 1 : return opOK;
3997 : }
3998 32 : if (RHS.getCategory() == fcNaN) {
3999 1 : Out = RHS;
4000 1 : return opOK;
4001 : }
4002 31 : if (LHS.getCategory() == fcZero) {
4003 3 : Out = RHS;
4004 3 : return opOK;
4005 : }
4006 28 : if (RHS.getCategory() == fcZero) {
4007 4 : Out = LHS;
4008 4 : return opOK;
4009 : }
4010 24 : if (LHS.getCategory() == fcInfinity && RHS.getCategory() == fcInfinity &&
4011 0 : LHS.isNegative() != RHS.isNegative()) {
4012 0 : Out.makeNaN(false, Out.isNegative(), nullptr);
4013 0 : return opInvalidOp;
4014 : }
4015 24 : if (LHS.getCategory() == fcInfinity) {
4016 0 : Out = LHS;
4017 0 : return opOK;
4018 : }
4019 24 : if (RHS.getCategory() == fcInfinity) {
4020 0 : Out = RHS;
4021 0 : return opOK;
4022 : }
4023 : assert(LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal);
4024 :
4025 : APFloat A(LHS.Floats[0]), AA(LHS.Floats[1]), C(RHS.Floats[0]),
4026 : CC(RHS.Floats[1]);
4027 : assert(&A.getSemantics() == &semIEEEdouble);
4028 : assert(&AA.getSemantics() == &semIEEEdouble);
4029 : assert(&C.getSemantics() == &semIEEEdouble);
4030 : assert(&CC.getSemantics() == &semIEEEdouble);
4031 : assert(&Out.Floats[0].getSemantics() == &semIEEEdouble);
4032 : assert(&Out.Floats[1].getSemantics() == &semIEEEdouble);
4033 24 : return Out.addImpl(A, AA, C, CC, RM);
4034 : }
4035 :
4036 33 : APFloat::opStatus DoubleAPFloat::add(const DoubleAPFloat &RHS,
4037 : roundingMode RM) {
4038 33 : return addWithSpecial(*this, RHS, *this, RM);
4039 : }
4040 :
4041 10 : APFloat::opStatus DoubleAPFloat::subtract(const DoubleAPFloat &RHS,
4042 : roundingMode RM) {
4043 10 : changeSign();
4044 10 : auto Ret = add(RHS, RM);
4045 10 : changeSign();
4046 10 : return Ret;
4047 : }
4048 :
4049 40 : APFloat::opStatus DoubleAPFloat::multiply(const DoubleAPFloat &RHS,
4050 : APFloat::roundingMode RM) {
4051 : const auto &LHS = *this;
4052 : auto &Out = *this;
4053 : /* Interesting observation: For special categories, finding the lowest
4054 : common ancestor of the following layered graph gives the correct
4055 : return category:
4056 :
4057 : NaN
4058 : / \
4059 : Zero Inf
4060 : \ /
4061 : Normal
4062 :
4063 : e.g. NaN * NaN = NaN
4064 : Zero * Inf = NaN
4065 : Normal * Zero = Zero
4066 : Normal * Inf = Inf
4067 : */
4068 40 : if (LHS.getCategory() == fcNaN) {
4069 5 : Out = LHS;
4070 5 : return opOK;
4071 : }
4072 35 : if (RHS.getCategory() == fcNaN) {
4073 3 : Out = RHS;
4074 3 : return opOK;
4075 : }
4076 63 : if ((LHS.getCategory() == fcZero && RHS.getCategory() == fcInfinity) ||
4077 35 : (LHS.getCategory() == fcInfinity && RHS.getCategory() == fcZero)) {
4078 2 : Out.makeNaN(false, false, nullptr);
4079 2 : return opOK;
4080 : }
4081 30 : if (LHS.getCategory() == fcZero || LHS.getCategory() == fcInfinity) {
4082 9 : Out = LHS;
4083 9 : return opOK;
4084 : }
4085 21 : if (RHS.getCategory() == fcZero || RHS.getCategory() == fcInfinity) {
4086 2 : Out = RHS;
4087 2 : return opOK;
4088 : }
4089 : assert(LHS.getCategory() == fcNormal && RHS.getCategory() == fcNormal &&
4090 : "Special cases not handled exhaustively");
4091 :
4092 : int Status = opOK;
4093 : APFloat A = Floats[0], B = Floats[1], C = RHS.Floats[0], D = RHS.Floats[1];
4094 : // t = a * c
4095 : APFloat T = A;
4096 19 : Status |= T.multiply(C, RM);
4097 19 : if (!T.isFiniteNonZero()) {
4098 : Floats[0] = T;
4099 0 : Floats[1].makeZero(/* Neg = */ false);
4100 0 : return (opStatus)Status;
4101 : }
4102 :
4103 : // tau = fmsub(a, c, t), that is -fmadd(-a, c, t).
4104 : APFloat Tau = A;
4105 19 : T.changeSign();
4106 19 : Status |= Tau.fusedMultiplyAdd(C, T, RM);
4107 19 : T.changeSign();
4108 : {
4109 : // v = a * d
4110 : APFloat V = A;
4111 19 : Status |= V.multiply(D, RM);
4112 : // w = b * c
4113 : APFloat W = B;
4114 19 : Status |= W.multiply(C, RM);
4115 19 : Status |= V.add(W, RM);
4116 : // tau += v + w
4117 19 : Status |= Tau.add(V, RM);
4118 : }
4119 : // u = t + tau
4120 : APFloat U = T;
4121 19 : Status |= U.add(Tau, RM);
4122 :
4123 : Floats[0] = U;
4124 : if (!U.isFinite()) {
4125 2 : Floats[1].makeZero(/* Neg = */ false);
4126 : } else {
4127 : // Floats[1] = (t - u) + tau
4128 17 : Status |= T.subtract(U, RM);
4129 17 : Status |= T.add(Tau, RM);
4130 : Floats[1] = T;
4131 : }
4132 19 : return (opStatus)Status;
4133 : }
4134 :
4135 2 : APFloat::opStatus DoubleAPFloat::divide(const DoubleAPFloat &RHS,
4136 : APFloat::roundingMode RM) {
4137 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4138 2 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4139 : auto Ret =
4140 6 : Tmp.divide(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()), RM);
4141 6 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4142 2 : return Ret;
4143 : }
4144 :
4145 2 : APFloat::opStatus DoubleAPFloat::remainder(const DoubleAPFloat &RHS) {
4146 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4147 2 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4148 : auto Ret =
4149 6 : Tmp.remainder(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
4150 6 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4151 2 : return Ret;
4152 : }
4153 :
4154 2 : APFloat::opStatus DoubleAPFloat::mod(const DoubleAPFloat &RHS) {
4155 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4156 2 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4157 6 : auto Ret = Tmp.mod(APFloat(semPPCDoubleDoubleLegacy, RHS.bitcastToAPInt()));
4158 6 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4159 2 : return Ret;
4160 : }
4161 :
4162 : APFloat::opStatus
4163 1 : DoubleAPFloat::fusedMultiplyAdd(const DoubleAPFloat &Multiplicand,
4164 : const DoubleAPFloat &Addend,
4165 : APFloat::roundingMode RM) {
4166 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4167 1 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4168 1 : auto Ret = Tmp.fusedMultiplyAdd(
4169 3 : APFloat(semPPCDoubleDoubleLegacy, Multiplicand.bitcastToAPInt()),
4170 2 : APFloat(semPPCDoubleDoubleLegacy, Addend.bitcastToAPInt()), RM);
4171 3 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4172 1 : return Ret;
4173 : }
4174 :
4175 2 : APFloat::opStatus DoubleAPFloat::roundToIntegral(APFloat::roundingMode RM) {
4176 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4177 2 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4178 2 : auto Ret = Tmp.roundToIntegral(RM);
4179 6 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4180 2 : return Ret;
4181 : }
4182 :
4183 27 : void DoubleAPFloat::changeSign() {
4184 27 : Floats[0].changeSign();
4185 27 : Floats[1].changeSign();
4186 27 : }
4187 :
4188 : APFloat::cmpResult
4189 0 : DoubleAPFloat::compareAbsoluteValue(const DoubleAPFloat &RHS) const {
4190 0 : auto Result = Floats[0].compareAbsoluteValue(RHS.Floats[0]);
4191 0 : if (Result != cmpEqual)
4192 : return Result;
4193 0 : Result = Floats[1].compareAbsoluteValue(RHS.Floats[1]);
4194 0 : if (Result == cmpLessThan || Result == cmpGreaterThan) {
4195 0 : auto Against = Floats[0].isNegative() ^ Floats[1].isNegative();
4196 0 : auto RHSAgainst = RHS.Floats[0].isNegative() ^ RHS.Floats[1].isNegative();
4197 0 : if (Against && !RHSAgainst)
4198 : return cmpLessThan;
4199 0 : if (!Against && RHSAgainst)
4200 : return cmpGreaterThan;
4201 0 : if (!Against && !RHSAgainst)
4202 : return Result;
4203 0 : if (Against && RHSAgainst)
4204 0 : return (cmpResult)(cmpLessThan + cmpGreaterThan - Result);
4205 : }
4206 : return Result;
4207 : }
4208 :
4209 448 : APFloat::fltCategory DoubleAPFloat::getCategory() const {
4210 448 : return Floats[0].getCategory();
4211 : }
4212 :
4213 2 : bool DoubleAPFloat::isNegative() const { return Floats[0].isNegative(); }
4214 :
4215 0 : void DoubleAPFloat::makeInf(bool Neg) {
4216 0 : Floats[0].makeInf(Neg);
4217 0 : Floats[1].makeZero(/* Neg = */ false);
4218 0 : }
4219 :
4220 17 : void DoubleAPFloat::makeZero(bool Neg) {
4221 17 : Floats[0].makeZero(Neg);
4222 17 : Floats[1].makeZero(/* Neg = */ false);
4223 17 : }
4224 :
4225 5 : void DoubleAPFloat::makeLargest(bool Neg) {
4226 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4227 5 : Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x7fefffffffffffffull));
4228 5 : Floats[1] = APFloat(semIEEEdouble, APInt(64, 0x7c8ffffffffffffeull));
4229 5 : if (Neg)
4230 1 : changeSign();
4231 5 : }
4232 :
4233 5 : void DoubleAPFloat::makeSmallest(bool Neg) {
4234 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4235 5 : Floats[0].makeSmallest(Neg);
4236 5 : Floats[1].makeZero(/* Neg = */ false);
4237 5 : }
4238 :
4239 3 : void DoubleAPFloat::makeSmallestNormalized(bool Neg) {
4240 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4241 3 : Floats[0] = APFloat(semIEEEdouble, APInt(64, 0x0360000000000000ull));
4242 3 : if (Neg)
4243 1 : Floats[0].changeSign();
4244 3 : Floats[1].makeZero(/* Neg = */ false);
4245 3 : }
4246 :
4247 2 : void DoubleAPFloat::makeNaN(bool SNaN, bool Neg, const APInt *fill) {
4248 2 : Floats[0].makeNaN(SNaN, Neg, fill);
4249 2 : Floats[1].makeZero(/* Neg = */ false);
4250 2 : }
4251 :
4252 14 : APFloat::cmpResult DoubleAPFloat::compare(const DoubleAPFloat &RHS) const {
4253 14 : auto Result = Floats[0].compare(RHS.Floats[0]);
4254 : // |Float[0]| > |Float[1]|
4255 14 : if (Result == APFloat::cmpEqual)
4256 9 : return Floats[1].compare(RHS.Floats[1]);
4257 : return Result;
4258 : }
4259 :
4260 76 : bool DoubleAPFloat::bitwiseIsEqual(const DoubleAPFloat &RHS) const {
4261 129 : return Floats[0].bitwiseIsEqual(RHS.Floats[0]) &&
4262 53 : Floats[1].bitwiseIsEqual(RHS.Floats[1]);
4263 : }
4264 :
4265 128 : hash_code hash_value(const DoubleAPFloat &Arg) {
4266 128 : if (Arg.Floats)
4267 128 : return hash_combine(hash_value(Arg.Floats[0]), hash_value(Arg.Floats[1]));
4268 0 : return hash_combine(Arg.Semantics);
4269 : }
4270 :
4271 245 : APInt DoubleAPFloat::bitcastToAPInt() const {
4272 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4273 : uint64_t Data[] = {
4274 490 : Floats[0].bitcastToAPInt().getRawData()[0],
4275 245 : Floats[1].bitcastToAPInt().getRawData()[0],
4276 490 : };
4277 245 : return APInt(128, 2, Data);
4278 : }
4279 :
4280 42 : APFloat::opStatus DoubleAPFloat::convertFromString(StringRef S,
4281 : roundingMode RM) {
4282 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4283 : APFloat Tmp(semPPCDoubleDoubleLegacy);
4284 42 : auto Ret = Tmp.convertFromString(S, RM);
4285 126 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4286 42 : return Ret;
4287 : }
4288 :
4289 0 : APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
4290 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4291 0 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4292 0 : auto Ret = Tmp.next(nextDown);
4293 0 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4294 0 : return Ret;
4295 : }
4296 :
4297 : APFloat::opStatus
4298 2 : DoubleAPFloat::convertToInteger(MutableArrayRef<integerPart> Input,
4299 : unsigned int Width, bool IsSigned,
4300 : roundingMode RM, bool *IsExact) const {
4301 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4302 4 : return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
4303 2 : .convertToInteger(Input, Width, IsSigned, RM, IsExact);
4304 : }
4305 :
4306 0 : APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
4307 : bool IsSigned,
4308 : roundingMode RM) {
4309 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4310 : APFloat Tmp(semPPCDoubleDoubleLegacy);
4311 0 : auto Ret = Tmp.convertFromAPInt(Input, IsSigned, RM);
4312 0 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4313 0 : return Ret;
4314 : }
4315 :
4316 : APFloat::opStatus
4317 0 : DoubleAPFloat::convertFromSignExtendedInteger(const integerPart *Input,
4318 : unsigned int InputSize,
4319 : bool IsSigned, roundingMode RM) {
4320 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4321 : APFloat Tmp(semPPCDoubleDoubleLegacy);
4322 0 : auto Ret = Tmp.convertFromSignExtendedInteger(Input, InputSize, IsSigned, RM);
4323 0 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4324 0 : return Ret;
4325 : }
4326 :
4327 : APFloat::opStatus
4328 0 : DoubleAPFloat::convertFromZeroExtendedInteger(const integerPart *Input,
4329 : unsigned int InputSize,
4330 : bool IsSigned, roundingMode RM) {
4331 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4332 : APFloat Tmp(semPPCDoubleDoubleLegacy);
4333 0 : auto Ret = Tmp.convertFromZeroExtendedInteger(Input, InputSize, IsSigned, RM);
4334 0 : *this = DoubleAPFloat(semPPCDoubleDouble, Tmp.bitcastToAPInt());
4335 0 : return Ret;
4336 : }
4337 :
4338 0 : unsigned int DoubleAPFloat::convertToHexString(char *DST,
4339 : unsigned int HexDigits,
4340 : bool UpperCase,
4341 : roundingMode RM) const {
4342 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4343 0 : return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
4344 0 : .convertToHexString(DST, HexDigits, UpperCase, RM);
4345 : }
4346 :
4347 4 : bool DoubleAPFloat::isDenormal() const {
4348 8 : return getCategory() == fcNormal &&
4349 10 : (Floats[0].isDenormal() || Floats[1].isDenormal() ||
4350 : // (double)(Hi + Lo) == Hi defines a normal number.
4351 7 : Floats[0].compare(Floats[0] + Floats[1]) != cmpEqual);
4352 : }
4353 :
4354 1 : bool DoubleAPFloat::isSmallest() const {
4355 1 : if (getCategory() != fcNormal)
4356 : return false;
4357 1 : DoubleAPFloat Tmp(*this);
4358 1 : Tmp.makeSmallest(this->isNegative());
4359 1 : return Tmp.compare(*this) == cmpEqual;
4360 : }
4361 :
4362 1 : bool DoubleAPFloat::isLargest() const {
4363 1 : if (getCategory() != fcNormal)
4364 : return false;
4365 1 : DoubleAPFloat Tmp(*this);
4366 1 : Tmp.makeLargest(this->isNegative());
4367 1 : return Tmp.compare(*this) == cmpEqual;
4368 : }
4369 :
4370 3 : bool DoubleAPFloat::isInteger() const {
4371 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4372 3 : return Floats[0].isInteger() && Floats[1].isInteger();
4373 : }
4374 :
4375 4 : void DoubleAPFloat::toString(SmallVectorImpl<char> &Str,
4376 : unsigned FormatPrecision,
4377 : unsigned FormatMaxPadding,
4378 : bool TruncateZero) const {
4379 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4380 8 : APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
4381 4 : .toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero);
4382 4 : }
4383 :
4384 1 : bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
4385 : assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4386 1 : APFloat Tmp(semPPCDoubleDoubleLegacy, bitcastToAPInt());
4387 1 : if (!inv)
4388 0 : return Tmp.getExactInverse(nullptr);
4389 : APFloat Inv(semPPCDoubleDoubleLegacy);
4390 1 : auto Ret = Tmp.getExactInverse(&Inv);
4391 3 : *inv = APFloat(semPPCDoubleDouble, Inv.bitcastToAPInt());
4392 : return Ret;
4393 : }
4394 :
4395 2 : DoubleAPFloat scalbn(DoubleAPFloat Arg, int Exp, APFloat::roundingMode RM) {
4396 : assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4397 4 : return DoubleAPFloat(semPPCDoubleDouble, scalbn(Arg.Floats[0], Exp, RM),
4398 6 : scalbn(Arg.Floats[1], Exp, RM));
4399 : }
4400 :
4401 2 : DoubleAPFloat frexp(const DoubleAPFloat &Arg, int &Exp,
4402 : APFloat::roundingMode RM) {
4403 : assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
4404 2 : APFloat First = frexp(Arg.Floats[0], Exp, RM);
4405 : APFloat Second = Arg.Floats[1];
4406 2 : if (Arg.getCategory() == APFloat::fcNormal)
4407 4 : Second = scalbn(Second, -Exp, RM);
4408 2 : return DoubleAPFloat(semPPCDoubleDouble, std::move(First), std::move(Second));
4409 : }
4410 :
4411 : } // End detail namespace
4412 :
4413 4844881 : APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
4414 4844881 : if (usesLayout<IEEEFloat>(Semantics)) {
4415 4844881 : new (&IEEE) IEEEFloat(std::move(F));
4416 4844881 : return;
4417 : }
4418 : if (usesLayout<DoubleAPFloat>(Semantics)) {
4419 0 : new (&Double)
4420 0 : DoubleAPFloat(Semantics, APFloat(std::move(F), F.getSemantics()),
4421 0 : APFloat(semIEEEdouble));
4422 0 : return;
4423 : }
4424 : llvm_unreachable("Unexpected semantics");
4425 : }
4426 :
4427 247558 : APFloat::opStatus APFloat::convertFromString(StringRef Str, roundingMode RM) {
4428 495116 : APFLOAT_DISPATCH_ON_SEMANTICS(convertFromString(Str, RM));
4429 : }
4430 :
4431 190518 : hash_code hash_value(const APFloat &Arg) {
4432 381036 : if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
4433 190390 : return hash_value(Arg.U.IEEE);
4434 : if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
4435 128 : return hash_value(Arg.U.Double);
4436 : llvm_unreachable("Unexpected semantics");
4437 : }
4438 :
4439 81420 : APFloat::APFloat(const fltSemantics &Semantics, StringRef S)
4440 : : APFloat(Semantics) {
4441 81420 : convertFromString(S, rmNearestTiesToEven);
4442 81420 : }
4443 :
4444 184961 : APFloat::opStatus APFloat::convert(const fltSemantics &ToSemantics,
4445 : roundingMode RM, bool *losesInfo) {
4446 184961 : if (&getSemantics() == &ToSemantics) {
4447 5302 : *losesInfo = false;
4448 5302 : return opOK;
4449 : }
4450 179659 : if (usesLayout<IEEEFloat>(getSemantics()) &&
4451 : usesLayout<IEEEFloat>(ToSemantics))
4452 179641 : return U.IEEE.convert(ToSemantics, RM, losesInfo);
4453 18 : if (usesLayout<IEEEFloat>(getSemantics()) &&
4454 : usesLayout<DoubleAPFloat>(ToSemantics)) {
4455 : assert(&ToSemantics == &semPPCDoubleDouble);
4456 16 : auto Ret = U.IEEE.convert(semPPCDoubleDoubleLegacy, RM, losesInfo);
4457 32 : *this = APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
4458 16 : return Ret;
4459 : }
4460 2 : if (usesLayout<DoubleAPFloat>(getSemantics()) &&
4461 : usesLayout<IEEEFloat>(ToSemantics)) {
4462 2 : auto Ret = getIEEE().convert(ToSemantics, RM, losesInfo);
4463 4 : *this = APFloat(std::move(getIEEE()), ToSemantics);
4464 2 : return Ret;
4465 : }
4466 0 : llvm_unreachable("Unexpected semantics");
4467 : }
4468 :
4469 222 : APFloat APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE) {
4470 222 : if (isIEEE) {
4471 222 : switch (BitWidth) {
4472 3 : case 16:
4473 6 : return APFloat(semIEEEhalf, APInt::getAllOnesValue(BitWidth));
4474 215 : case 32:
4475 430 : return APFloat(semIEEEsingle, APInt::getAllOnesValue(BitWidth));
4476 4 : case 64:
4477 8 : return APFloat(semIEEEdouble, APInt::getAllOnesValue(BitWidth));
4478 0 : case 80:
4479 0 : return APFloat(semX87DoubleExtended, APInt::getAllOnesValue(BitWidth));
4480 0 : case 128:
4481 0 : return APFloat(semIEEEquad, APInt::getAllOnesValue(BitWidth));
4482 0 : default:
4483 0 : llvm_unreachable("Unknown floating bit width");
4484 : }
4485 : } else {
4486 : assert(BitWidth == 128);
4487 0 : return APFloat(semPPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
4488 : }
4489 : }
4490 :
4491 0 : void APFloat::print(raw_ostream &OS) const {
4492 : SmallVector<char, 16> Buffer;
4493 0 : toString(Buffer);
4494 0 : OS << Buffer << "\n";
4495 0 : }
4496 :
4497 : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
4498 : LLVM_DUMP_METHOD void APFloat::dump() const { print(dbgs()); }
4499 : #endif
4500 :
4501 2644 : void APFloat::Profile(FoldingSetNodeID &NID) const {
4502 2644 : NID.Add(bitcastToAPInt());
4503 2644 : }
4504 :
4505 : /* Same as convertToInteger(integerPart*, ...), except the result is returned in
4506 : an APSInt, whose initial bit-width and signed-ness are used to determine the
4507 : precision of the conversion.
4508 : */
4509 10921 : APFloat::opStatus APFloat::convertToInteger(APSInt &result,
4510 : roundingMode rounding_mode,
4511 : bool *isExact) const {
4512 10921 : unsigned bitWidth = result.getBitWidth();
4513 10921 : SmallVector<uint64_t, 4> parts(result.getNumWords());
4514 32763 : opStatus status = convertToInteger(parts, bitWidth, result.isSigned(),
4515 : rounding_mode, isExact);
4516 : // Keeps the original signed-ness.
4517 21842 : result = APInt(bitWidth, parts);
4518 10921 : return status;
4519 : }
4520 :
4521 : } // End llvm namespace
4522 :
4523 : #undef APFLOAT_DISPATCH_ON_SEMANTICS
|
