blob: 7989e30afae62d4cdbf4b4f552b648387f78448e [file] [log] [blame]
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001//===-- APFloat.cpp - Implement APFloat class -----------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattnerf3ebc3f2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00007//
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
Chris Lattnere5256752007-12-08 19:00:03 +000015#include "llvm/ADT/APFloat.h"
Jeffrey Yasskin03b81a22011-07-15 07:04:56 +000016#include "llvm/ADT/APSInt.h"
Ted Kremenek6f30a072008-02-11 17:24:50 +000017#include "llvm/ADT/FoldingSet.h"
Chandler Carruth71bd7d12012-03-04 12:02:57 +000018#include "llvm/ADT/Hashing.h"
Jordan Rosee1f76582013-01-18 21:45:30 +000019#include "llvm/ADT/StringExtras.h"
Chandler Carruth71bd7d12012-03-04 12:02:57 +000020#include "llvm/ADT/StringRef.h"
Torok Edwin56d06592009-07-11 20:10:48 +000021#include "llvm/Support/ErrorHandling.h"
Dale Johannesen918c33c2007-08-24 05:08:11 +000022#include "llvm/Support/MathExtras.h"
Chris Lattner17f71652008-08-17 07:19:36 +000023#include <cstring>
Chandler Carruthed0881b2012-12-03 16:50:05 +000024#include <limits.h>
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000025
26using namespace llvm;
27
Michael Gottesman9b877e12013-06-24 09:57:57 +000028/// A macro used to combine two fcCategory enums into one key which can be used
29/// in a switch statement to classify how the interaction of two APFloat's
30/// categories affects an operation.
31///
32/// TODO: If clang source code is ever allowed to use constexpr in its own
33/// codebase, change this into a static inline function.
34#define PackCategoriesIntoKey(_lhs, _rhs) ((_lhs) * 4 + (_rhs))
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000035
Neil Booth8f1946f2007-10-03 22:26:02 +000036/* Assumed in hexadecimal significand parsing, and conversion to
37 hexadecimal strings. */
Chris Lattner8fcea672008-08-17 04:58:58 +000038#define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000039COMPILE_TIME_ASSERT(integerPartWidth % 4 == 0);
40
41namespace llvm {
42
43 /* Represents floating point arithmetic semantics. */
44 struct fltSemantics {
45 /* The largest E such that 2^E is representable; this matches the
46 definition of IEEE 754. */
Michael Gottesman9dc98332013-06-24 04:06:23 +000047 APFloat::ExponentType maxExponent;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000048
49 /* The smallest E such that 2^E is a normalized number; this
50 matches the definition of IEEE 754. */
Michael Gottesman9dc98332013-06-24 04:06:23 +000051 APFloat::ExponentType minExponent;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000052
53 /* Number of bits in the significand. This includes the integer
54 bit. */
Neil Booth146fdb32007-10-12 15:33:27 +000055 unsigned int precision;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000056 };
57
Ulrich Weigand908c9362012-10-29 18:18:44 +000058 const fltSemantics APFloat::IEEEhalf = { 15, -14, 11 };
59 const fltSemantics APFloat::IEEEsingle = { 127, -126, 24 };
60 const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53 };
61 const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113 };
62 const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64 };
63 const fltSemantics APFloat::Bogus = { 0, 0, 0 };
Dale Johannesen007aa372007-10-11 18:07:22 +000064
Ulrich Weigandd9f7e252012-10-29 18:09:01 +000065 /* The PowerPC format consists of two doubles. It does not map cleanly
66 onto the usual format above. It is approximated using twice the
67 mantissa bits. Note that for exponents near the double minimum,
68 we no longer can represent the full 106 mantissa bits, so those
69 will be treated as denormal numbers.
70
71 FIXME: While this approximation is equivalent to what GCC uses for
72 compile-time arithmetic on PPC double-double numbers, it is not able
73 to represent all possible values held by a PPC double-double number,
74 for example: (long double) 1.0 + (long double) 0x1p-106
75 Should this be replaced by a full emulation of PPC double-double? */
Ulrich Weigand908c9362012-10-29 18:18:44 +000076 const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022 + 53, 53 + 53 };
Neil Boothb93d90e2007-10-12 16:02:31 +000077
78 /* A tight upper bound on number of parts required to hold the value
79 pow(5, power) is
80
Neil Booth91305512007-10-15 15:00:55 +000081 power * 815 / (351 * integerPartWidth) + 1
Dan Gohmanb452d4e2010-03-24 19:38:02 +000082
Neil Boothb93d90e2007-10-12 16:02:31 +000083 However, whilst the result may require only this many parts,
84 because we are multiplying two values to get it, the
85 multiplication may require an extra part with the excess part
86 being zero (consider the trivial case of 1 * 1, tcFullMultiply
87 requires two parts to hold the single-part result). So we add an
88 extra one to guarantee enough space whilst multiplying. */
89 const unsigned int maxExponent = 16383;
90 const unsigned int maxPrecision = 113;
91 const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
Neil Booth91305512007-10-15 15:00:55 +000092 const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
93 / (351 * integerPartWidth));
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000094}
95
Chris Lattner91702092009-03-12 23:59:55 +000096/* A bunch of private, handy routines. */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +000097
Chris Lattner91702092009-03-12 23:59:55 +000098static inline unsigned int
99partCountForBits(unsigned int bits)
100{
101 return ((bits) + integerPartWidth - 1) / integerPartWidth;
102}
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000103
Chris Lattner91702092009-03-12 23:59:55 +0000104/* Returns 0U-9U. Return values >= 10U are not digits. */
105static inline unsigned int
106decDigitValue(unsigned int c)
107{
108 return c - '0';
109}
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000110
Chris Lattner91702092009-03-12 23:59:55 +0000111/* Return the value of a decimal exponent of the form
112 [+-]ddddddd.
Neil Booth4ed401b2007-10-14 10:16:12 +0000113
Chris Lattner91702092009-03-12 23:59:55 +0000114 If the exponent overflows, returns a large exponent with the
115 appropriate sign. */
116static int
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000117readExponent(StringRef::iterator begin, StringRef::iterator end)
Chris Lattner91702092009-03-12 23:59:55 +0000118{
119 bool isNegative;
120 unsigned int absExponent;
121 const unsigned int overlargeExponent = 24000; /* FIXME. */
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000122 StringRef::iterator p = begin;
123
124 assert(p != end && "Exponent has no digits");
Neil Booth4ed401b2007-10-14 10:16:12 +0000125
Chris Lattner91702092009-03-12 23:59:55 +0000126 isNegative = (*p == '-');
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000127 if (*p == '-' || *p == '+') {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000128 p++;
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000129 assert(p != end && "Exponent has no digits");
130 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000131
Chris Lattner91702092009-03-12 23:59:55 +0000132 absExponent = decDigitValue(*p++);
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000133 assert(absExponent < 10U && "Invalid character in exponent");
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000134
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000135 for (; p != end; ++p) {
Chris Lattner91702092009-03-12 23:59:55 +0000136 unsigned int value;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000137
Chris Lattner91702092009-03-12 23:59:55 +0000138 value = decDigitValue(*p);
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000139 assert(value < 10U && "Invalid character in exponent");
Chris Lattner91702092009-03-12 23:59:55 +0000140
Chris Lattner91702092009-03-12 23:59:55 +0000141 value += absExponent * 10;
142 if (absExponent >= overlargeExponent) {
143 absExponent = overlargeExponent;
Dale Johannesen370c77c2010-08-19 17:58:35 +0000144 p = end; /* outwit assert below */
Chris Lattner91702092009-03-12 23:59:55 +0000145 break;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000146 }
Chris Lattner91702092009-03-12 23:59:55 +0000147 absExponent = value;
148 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000149
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000150 assert(p == end && "Invalid exponent in exponent");
151
Chris Lattner91702092009-03-12 23:59:55 +0000152 if (isNegative)
153 return -(int) absExponent;
154 else
155 return (int) absExponent;
156}
157
158/* This is ugly and needs cleaning up, but I don't immediately see
159 how whilst remaining safe. */
160static int
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000161totalExponent(StringRef::iterator p, StringRef::iterator end,
162 int exponentAdjustment)
Chris Lattner91702092009-03-12 23:59:55 +0000163{
164 int unsignedExponent;
165 bool negative, overflow;
Ted Kremenek3c4408c2011-01-23 17:05:06 +0000166 int exponent = 0;
Chris Lattner91702092009-03-12 23:59:55 +0000167
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000168 assert(p != end && "Exponent has no digits");
169
Chris Lattner91702092009-03-12 23:59:55 +0000170 negative = *p == '-';
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000171 if (*p == '-' || *p == '+') {
Chris Lattner91702092009-03-12 23:59:55 +0000172 p++;
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000173 assert(p != end && "Exponent has no digits");
174 }
Chris Lattner91702092009-03-12 23:59:55 +0000175
176 unsignedExponent = 0;
177 overflow = false;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000178 for (; p != end; ++p) {
Chris Lattner91702092009-03-12 23:59:55 +0000179 unsigned int value;
180
181 value = decDigitValue(*p);
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000182 assert(value < 10U && "Invalid character in exponent");
Chris Lattner91702092009-03-12 23:59:55 +0000183
Chris Lattner91702092009-03-12 23:59:55 +0000184 unsignedExponent = unsignedExponent * 10 + value;
Richard Smith156d9202012-08-24 00:01:19 +0000185 if (unsignedExponent > 32767) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000186 overflow = true;
Richard Smith156d9202012-08-24 00:01:19 +0000187 break;
188 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000189 }
190
Abramo Bagnaraa41d7ae2011-01-06 16:55:14 +0000191 if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
Chris Lattner91702092009-03-12 23:59:55 +0000192 overflow = true;
193
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000194 if (!overflow) {
Chris Lattner91702092009-03-12 23:59:55 +0000195 exponent = unsignedExponent;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000196 if (negative)
Chris Lattner91702092009-03-12 23:59:55 +0000197 exponent = -exponent;
198 exponent += exponentAdjustment;
Abramo Bagnaraa41d7ae2011-01-06 16:55:14 +0000199 if (exponent > 32767 || exponent < -32768)
Chris Lattner91702092009-03-12 23:59:55 +0000200 overflow = true;
201 }
202
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000203 if (overflow)
Abramo Bagnaraa41d7ae2011-01-06 16:55:14 +0000204 exponent = negative ? -32768: 32767;
Chris Lattner91702092009-03-12 23:59:55 +0000205
206 return exponent;
207}
208
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000209static StringRef::iterator
210skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
211 StringRef::iterator *dot)
Chris Lattner91702092009-03-12 23:59:55 +0000212{
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000213 StringRef::iterator p = begin;
214 *dot = end;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000215 while (*p == '0' && p != end)
Chris Lattner91702092009-03-12 23:59:55 +0000216 p++;
217
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000218 if (*p == '.') {
Chris Lattner91702092009-03-12 23:59:55 +0000219 *dot = p++;
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000220
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000221 assert(end - begin != 1 && "Significand has no digits");
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000222
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000223 while (*p == '0' && p != end)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000224 p++;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000225 }
226
Chris Lattner91702092009-03-12 23:59:55 +0000227 return p;
228}
Neil Booth4ed401b2007-10-14 10:16:12 +0000229
Chris Lattner91702092009-03-12 23:59:55 +0000230/* Given a normal decimal floating point number of the form
Neil Booth4ed401b2007-10-14 10:16:12 +0000231
Chris Lattner91702092009-03-12 23:59:55 +0000232 dddd.dddd[eE][+-]ddd
Neil Booth91305512007-10-15 15:00:55 +0000233
Chris Lattner91702092009-03-12 23:59:55 +0000234 where the decimal point and exponent are optional, fill out the
235 structure D. Exponent is appropriate if the significand is
236 treated as an integer, and normalizedExponent if the significand
237 is taken to have the decimal point after a single leading
238 non-zero digit.
Neil Booth4ed401b2007-10-14 10:16:12 +0000239
Chris Lattner91702092009-03-12 23:59:55 +0000240 If the value is zero, V->firstSigDigit points to a non-digit, and
241 the return exponent is zero.
242*/
243struct decimalInfo {
244 const char *firstSigDigit;
245 const char *lastSigDigit;
246 int exponent;
247 int normalizedExponent;
248};
Neil Booth4ed401b2007-10-14 10:16:12 +0000249
Chris Lattner91702092009-03-12 23:59:55 +0000250static void
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000251interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
252 decimalInfo *D)
Chris Lattner91702092009-03-12 23:59:55 +0000253{
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000254 StringRef::iterator dot = end;
255 StringRef::iterator p = skipLeadingZeroesAndAnyDot (begin, end, &dot);
Neil Booth4ed401b2007-10-14 10:16:12 +0000256
Chris Lattner91702092009-03-12 23:59:55 +0000257 D->firstSigDigit = p;
258 D->exponent = 0;
259 D->normalizedExponent = 0;
260
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000261 for (; p != end; ++p) {
Chris Lattner91702092009-03-12 23:59:55 +0000262 if (*p == '.') {
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000263 assert(dot == end && "String contains multiple dots");
Chris Lattner91702092009-03-12 23:59:55 +0000264 dot = p++;
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000265 if (p == end)
266 break;
Neil Booth4ed401b2007-10-14 10:16:12 +0000267 }
Chris Lattner91702092009-03-12 23:59:55 +0000268 if (decDigitValue(*p) >= 10U)
269 break;
Chris Lattner91702092009-03-12 23:59:55 +0000270 }
Neil Booth4ed401b2007-10-14 10:16:12 +0000271
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000272 if (p != end) {
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000273 assert((*p == 'e' || *p == 'E') && "Invalid character in significand");
274 assert(p != begin && "Significand has no digits");
275 assert((dot == end || p - begin != 1) && "Significand has no digits");
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000276
277 /* p points to the first non-digit in the string */
Erick Tryzelaarda666c82009-08-20 23:30:43 +0000278 D->exponent = readExponent(p + 1, end);
Neil Booth4ed401b2007-10-14 10:16:12 +0000279
Chris Lattner91702092009-03-12 23:59:55 +0000280 /* Implied decimal point? */
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000281 if (dot == end)
Chris Lattner91702092009-03-12 23:59:55 +0000282 dot = p;
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000283 }
Neil Booth4ed401b2007-10-14 10:16:12 +0000284
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000285 /* If number is all zeroes accept any exponent. */
286 if (p != D->firstSigDigit) {
Chris Lattner91702092009-03-12 23:59:55 +0000287 /* Drop insignificant trailing zeroes. */
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000288 if (p != begin) {
Neil Booth4ed401b2007-10-14 10:16:12 +0000289 do
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000290 do
291 p--;
292 while (p != begin && *p == '0');
293 while (p != begin && *p == '.');
294 }
Neil Booth4ed401b2007-10-14 10:16:12 +0000295
Chris Lattner91702092009-03-12 23:59:55 +0000296 /* Adjust the exponents for any decimal point. */
Michael Gottesman9dc98332013-06-24 04:06:23 +0000297 D->exponent += static_cast<APFloat::ExponentType>((dot - p) - (dot > p));
Chris Lattner91702092009-03-12 23:59:55 +0000298 D->normalizedExponent = (D->exponent +
Michael Gottesman9dc98332013-06-24 04:06:23 +0000299 static_cast<APFloat::ExponentType>((p - D->firstSigDigit)
Chris Lattner91702092009-03-12 23:59:55 +0000300 - (dot > D->firstSigDigit && dot < p)));
Neil Booth4ed401b2007-10-14 10:16:12 +0000301 }
302
Chris Lattner91702092009-03-12 23:59:55 +0000303 D->lastSigDigit = p;
304}
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000305
Chris Lattner91702092009-03-12 23:59:55 +0000306/* Return the trailing fraction of a hexadecimal number.
307 DIGITVALUE is the first hex digit of the fraction, P points to
308 the next digit. */
309static lostFraction
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000310trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
311 unsigned int digitValue)
Chris Lattner91702092009-03-12 23:59:55 +0000312{
313 unsigned int hexDigit;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000314
Chris Lattner91702092009-03-12 23:59:55 +0000315 /* If the first trailing digit isn't 0 or 8 we can work out the
316 fraction immediately. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000317 if (digitValue > 8)
Chris Lattner91702092009-03-12 23:59:55 +0000318 return lfMoreThanHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000319 else if (digitValue < 8 && digitValue > 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000320 return lfLessThanHalf;
Chris Lattner91702092009-03-12 23:59:55 +0000321
Eli Friedmand2eb07a2013-07-17 22:17:29 +0000322 // Otherwise we need to find the first non-zero digit.
323 while (p != end && (*p == '0' || *p == '.'))
Chris Lattner91702092009-03-12 23:59:55 +0000324 p++;
325
Erick Tryzelaar19f63b22009-08-16 23:36:19 +0000326 assert(p != end && "Invalid trailing hexadecimal fraction!");
327
Chris Lattner91702092009-03-12 23:59:55 +0000328 hexDigit = hexDigitValue(*p);
329
330 /* If we ran off the end it is exactly zero or one-half, otherwise
331 a little more. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000332 if (hexDigit == -1U)
Chris Lattner91702092009-03-12 23:59:55 +0000333 return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
334 else
335 return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
336}
337
338/* Return the fraction lost were a bignum truncated losing the least
339 significant BITS bits. */
340static lostFraction
341lostFractionThroughTruncation(const integerPart *parts,
342 unsigned int partCount,
343 unsigned int bits)
344{
345 unsigned int lsb;
346
347 lsb = APInt::tcLSB(parts, partCount);
348
349 /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000350 if (bits <= lsb)
Chris Lattner91702092009-03-12 23:59:55 +0000351 return lfExactlyZero;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000352 if (bits == lsb + 1)
Chris Lattner91702092009-03-12 23:59:55 +0000353 return lfExactlyHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000354 if (bits <= partCount * integerPartWidth &&
355 APInt::tcExtractBit(parts, bits - 1))
Chris Lattner91702092009-03-12 23:59:55 +0000356 return lfMoreThanHalf;
357
358 return lfLessThanHalf;
359}
360
361/* Shift DST right BITS bits noting lost fraction. */
362static lostFraction
363shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
364{
365 lostFraction lost_fraction;
366
367 lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
368
369 APInt::tcShiftRight(dst, parts, bits);
370
371 return lost_fraction;
372}
373
374/* Combine the effect of two lost fractions. */
375static lostFraction
376combineLostFractions(lostFraction moreSignificant,
377 lostFraction lessSignificant)
378{
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000379 if (lessSignificant != lfExactlyZero) {
380 if (moreSignificant == lfExactlyZero)
Chris Lattner91702092009-03-12 23:59:55 +0000381 moreSignificant = lfLessThanHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000382 else if (moreSignificant == lfExactlyHalf)
Chris Lattner91702092009-03-12 23:59:55 +0000383 moreSignificant = lfMoreThanHalf;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000384 }
385
Chris Lattner91702092009-03-12 23:59:55 +0000386 return moreSignificant;
387}
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000388
Chris Lattner91702092009-03-12 23:59:55 +0000389/* The error from the true value, in half-ulps, on multiplying two
390 floating point numbers, which differ from the value they
391 approximate by at most HUE1 and HUE2 half-ulps, is strictly less
392 than the returned value.
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000393
Chris Lattner91702092009-03-12 23:59:55 +0000394 See "How to Read Floating Point Numbers Accurately" by William D
395 Clinger. */
396static unsigned int
397HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
398{
399 assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000400
Chris Lattner91702092009-03-12 23:59:55 +0000401 if (HUerr1 + HUerr2 == 0)
402 return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
403 else
404 return inexactMultiply + 2 * (HUerr1 + HUerr2);
405}
Neil Booth8f1946f2007-10-03 22:26:02 +0000406
Chris Lattner91702092009-03-12 23:59:55 +0000407/* The number of ulps from the boundary (zero, or half if ISNEAREST)
408 when the least significant BITS are truncated. BITS cannot be
409 zero. */
410static integerPart
411ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
412{
413 unsigned int count, partBits;
414 integerPart part, boundary;
Neil Boothd3985922007-10-07 08:51:21 +0000415
Evan Cheng67c90212009-10-27 21:35:42 +0000416 assert(bits != 0);
Neil Booth8f1946f2007-10-03 22:26:02 +0000417
Chris Lattner91702092009-03-12 23:59:55 +0000418 bits--;
419 count = bits / integerPartWidth;
420 partBits = bits % integerPartWidth + 1;
Neil Boothb93d90e2007-10-12 16:02:31 +0000421
Chris Lattner91702092009-03-12 23:59:55 +0000422 part = parts[count] & (~(integerPart) 0 >> (integerPartWidth - partBits));
Neil Boothb93d90e2007-10-12 16:02:31 +0000423
Chris Lattner91702092009-03-12 23:59:55 +0000424 if (isNearest)
425 boundary = (integerPart) 1 << (partBits - 1);
426 else
427 boundary = 0;
428
429 if (count == 0) {
430 if (part - boundary <= boundary - part)
431 return part - boundary;
Neil Boothb93d90e2007-10-12 16:02:31 +0000432 else
Chris Lattner91702092009-03-12 23:59:55 +0000433 return boundary - part;
Neil Boothb93d90e2007-10-12 16:02:31 +0000434 }
435
Chris Lattner91702092009-03-12 23:59:55 +0000436 if (part == boundary) {
437 while (--count)
438 if (parts[count])
439 return ~(integerPart) 0; /* A lot. */
Neil Boothb93d90e2007-10-12 16:02:31 +0000440
Chris Lattner91702092009-03-12 23:59:55 +0000441 return parts[0];
442 } else if (part == boundary - 1) {
443 while (--count)
444 if (~parts[count])
445 return ~(integerPart) 0; /* A lot. */
Neil Boothb93d90e2007-10-12 16:02:31 +0000446
Chris Lattner91702092009-03-12 23:59:55 +0000447 return -parts[0];
448 }
Neil Boothb93d90e2007-10-12 16:02:31 +0000449
Chris Lattner91702092009-03-12 23:59:55 +0000450 return ~(integerPart) 0; /* A lot. */
451}
Neil Boothb93d90e2007-10-12 16:02:31 +0000452
Chris Lattner91702092009-03-12 23:59:55 +0000453/* Place pow(5, power) in DST, and return the number of parts used.
454 DST must be at least one part larger than size of the answer. */
455static unsigned int
456powerOf5(integerPart *dst, unsigned int power)
457{
458 static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
459 15625, 78125 };
Chris Lattnerb858c0e2009-03-13 00:24:01 +0000460 integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
461 pow5s[0] = 78125 * 5;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000462
Chris Lattner0bf18692009-03-13 00:03:51 +0000463 unsigned int partsCount[16] = { 1 };
Chris Lattner91702092009-03-12 23:59:55 +0000464 integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
465 unsigned int result;
Chris Lattner91702092009-03-12 23:59:55 +0000466 assert(power <= maxExponent);
467
468 p1 = dst;
469 p2 = scratch;
470
471 *p1 = firstEightPowers[power & 7];
472 power >>= 3;
473
474 result = 1;
475 pow5 = pow5s;
476
477 for (unsigned int n = 0; power; power >>= 1, n++) {
478 unsigned int pc;
479
480 pc = partsCount[n];
481
482 /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
483 if (pc == 0) {
484 pc = partsCount[n - 1];
485 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
486 pc *= 2;
487 if (pow5[pc - 1] == 0)
488 pc--;
489 partsCount[n] = pc;
Neil Boothb93d90e2007-10-12 16:02:31 +0000490 }
491
Chris Lattner91702092009-03-12 23:59:55 +0000492 if (power & 1) {
493 integerPart *tmp;
Neil Boothb93d90e2007-10-12 16:02:31 +0000494
Chris Lattner91702092009-03-12 23:59:55 +0000495 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
496 result += pc;
497 if (p2[result - 1] == 0)
498 result--;
Neil Boothb93d90e2007-10-12 16:02:31 +0000499
Chris Lattner91702092009-03-12 23:59:55 +0000500 /* Now result is in p1 with partsCount parts and p2 is scratch
501 space. */
502 tmp = p1, p1 = p2, p2 = tmp;
Neil Boothb93d90e2007-10-12 16:02:31 +0000503 }
504
Chris Lattner91702092009-03-12 23:59:55 +0000505 pow5 += pc;
Neil Boothb93d90e2007-10-12 16:02:31 +0000506 }
507
Chris Lattner91702092009-03-12 23:59:55 +0000508 if (p1 != dst)
509 APInt::tcAssign(dst, p1, result);
Neil Boothb93d90e2007-10-12 16:02:31 +0000510
Chris Lattner91702092009-03-12 23:59:55 +0000511 return result;
512}
Neil Boothb93d90e2007-10-12 16:02:31 +0000513
Chris Lattner91702092009-03-12 23:59:55 +0000514/* Zero at the end to avoid modular arithmetic when adding one; used
515 when rounding up during hexadecimal output. */
516static const char hexDigitsLower[] = "0123456789abcdef0";
517static const char hexDigitsUpper[] = "0123456789ABCDEF0";
518static const char infinityL[] = "infinity";
519static const char infinityU[] = "INFINITY";
520static const char NaNL[] = "nan";
521static const char NaNU[] = "NAN";
Neil Boothb93d90e2007-10-12 16:02:31 +0000522
Chris Lattner91702092009-03-12 23:59:55 +0000523/* Write out an integerPart in hexadecimal, starting with the most
524 significant nibble. Write out exactly COUNT hexdigits, return
525 COUNT. */
526static unsigned int
527partAsHex (char *dst, integerPart part, unsigned int count,
528 const char *hexDigitChars)
529{
530 unsigned int result = count;
Neil Boothb93d90e2007-10-12 16:02:31 +0000531
Evan Cheng67c90212009-10-27 21:35:42 +0000532 assert(count != 0 && count <= integerPartWidth / 4);
Neil Boothb93d90e2007-10-12 16:02:31 +0000533
Chris Lattner91702092009-03-12 23:59:55 +0000534 part >>= (integerPartWidth - 4 * count);
535 while (count--) {
536 dst[count] = hexDigitChars[part & 0xf];
537 part >>= 4;
Neil Boothb93d90e2007-10-12 16:02:31 +0000538 }
539
Chris Lattner91702092009-03-12 23:59:55 +0000540 return result;
541}
Neil Booth8f1946f2007-10-03 22:26:02 +0000542
Chris Lattner91702092009-03-12 23:59:55 +0000543/* Write out an unsigned decimal integer. */
544static char *
545writeUnsignedDecimal (char *dst, unsigned int n)
546{
547 char buff[40], *p;
Neil Booth8f1946f2007-10-03 22:26:02 +0000548
Chris Lattner91702092009-03-12 23:59:55 +0000549 p = buff;
550 do
551 *p++ = '0' + n % 10;
552 while (n /= 10);
Neil Booth8f1946f2007-10-03 22:26:02 +0000553
Chris Lattner91702092009-03-12 23:59:55 +0000554 do
555 *dst++ = *--p;
556 while (p != buff);
Neil Booth8f1946f2007-10-03 22:26:02 +0000557
Chris Lattner91702092009-03-12 23:59:55 +0000558 return dst;
559}
Neil Booth8f1946f2007-10-03 22:26:02 +0000560
Chris Lattner91702092009-03-12 23:59:55 +0000561/* Write out a signed decimal integer. */
562static char *
563writeSignedDecimal (char *dst, int value)
564{
565 if (value < 0) {
566 *dst++ = '-';
567 dst = writeUnsignedDecimal(dst, -(unsigned) value);
568 } else
569 dst = writeUnsignedDecimal(dst, value);
Neil Booth8f1946f2007-10-03 22:26:02 +0000570
Chris Lattner91702092009-03-12 23:59:55 +0000571 return dst;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000572}
573
574/* Constructors. */
575void
576APFloat::initialize(const fltSemantics *ourSemantics)
577{
578 unsigned int count;
579
580 semantics = ourSemantics;
581 count = partCount();
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000582 if (count > 1)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000583 significand.parts = new integerPart[count];
584}
585
586void
587APFloat::freeSignificand()
588{
Manuel Klimekd0cf5b22013-06-03 13:03:05 +0000589 if (needsCleanup())
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000590 delete [] significand.parts;
591}
592
593void
594APFloat::assign(const APFloat &rhs)
595{
596 assert(semantics == rhs.semantics);
597
598 sign = rhs.sign;
599 category = rhs.category;
600 exponent = rhs.exponent;
Michael Gottesman8136c382013-06-26 23:17:28 +0000601 if (isFiniteNonZero() || category == fcNaN)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000602 copySignificand(rhs);
603}
604
605void
606APFloat::copySignificand(const APFloat &rhs)
607{
Michael Gottesman8136c382013-06-26 23:17:28 +0000608 assert(isFiniteNonZero() || category == fcNaN);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000609 assert(rhs.partCount() >= partCount());
610
611 APInt::tcAssign(significandParts(), rhs.significandParts(),
Neil Booth9acbf5a2007-09-26 21:33:42 +0000612 partCount());
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000613}
614
Neil Booth5fe658b2007-10-14 10:39:51 +0000615/* Make this number a NaN, with an arbitrary but deterministic value
Dale Johannesen1f864982009-01-21 20:32:55 +0000616 for the significand. If double or longer, this is a signalling NaN,
Mike Stump799bf582009-05-30 03:49:43 +0000617 which may not be ideal. If float, this is QNaN(0). */
John McCalldcb9a7a2010-02-28 02:51:25 +0000618void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
Neil Booth5fe658b2007-10-14 10:39:51 +0000619{
620 category = fcNaN;
John McCalldcb9a7a2010-02-28 02:51:25 +0000621 sign = Negative;
622
John McCallc12b1332010-02-28 12:49:50 +0000623 integerPart *significand = significandParts();
624 unsigned numParts = partCount();
625
John McCalldcb9a7a2010-02-28 02:51:25 +0000626 // Set the significand bits to the fill.
John McCallc12b1332010-02-28 12:49:50 +0000627 if (!fill || fill->getNumWords() < numParts)
628 APInt::tcSet(significand, 0, numParts);
629 if (fill) {
John McCallc6dbe302010-03-01 18:38:45 +0000630 APInt::tcAssign(significand, fill->getRawData(),
631 std::min(fill->getNumWords(), numParts));
John McCallc12b1332010-02-28 12:49:50 +0000632
633 // Zero out the excess bits of the significand.
634 unsigned bitsToPreserve = semantics->precision - 1;
635 unsigned part = bitsToPreserve / 64;
636 bitsToPreserve %= 64;
637 significand[part] &= ((1ULL << bitsToPreserve) - 1);
638 for (part++; part != numParts; ++part)
639 significand[part] = 0;
640 }
641
642 unsigned QNaNBit = semantics->precision - 2;
John McCalldcb9a7a2010-02-28 02:51:25 +0000643
644 if (SNaN) {
645 // We always have to clear the QNaN bit to make it an SNaN.
John McCallc12b1332010-02-28 12:49:50 +0000646 APInt::tcClearBit(significand, QNaNBit);
John McCalldcb9a7a2010-02-28 02:51:25 +0000647
648 // If there are no bits set in the payload, we have to set
649 // *something* to make it a NaN instead of an infinity;
650 // conventionally, this is the next bit down from the QNaN bit.
John McCallc12b1332010-02-28 12:49:50 +0000651 if (APInt::tcIsZero(significand, numParts))
652 APInt::tcSetBit(significand, QNaNBit - 1);
John McCalldcb9a7a2010-02-28 02:51:25 +0000653 } else {
654 // We always have to set the QNaN bit to make it a QNaN.
John McCallc12b1332010-02-28 12:49:50 +0000655 APInt::tcSetBit(significand, QNaNBit);
John McCalldcb9a7a2010-02-28 02:51:25 +0000656 }
John McCallc12b1332010-02-28 12:49:50 +0000657
658 // For x87 extended precision, we want to make a NaN, not a
659 // pseudo-NaN. Maybe we should expose the ability to make
660 // pseudo-NaNs?
661 if (semantics == &APFloat::x87DoubleExtended)
662 APInt::tcSetBit(significand, QNaNBit + 1);
John McCalldcb9a7a2010-02-28 02:51:25 +0000663}
664
665APFloat APFloat::makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
666 const APInt *fill) {
667 APFloat value(Sem, uninitialized);
668 value.makeNaN(SNaN, Negative, fill);
669 return value;
Neil Booth5fe658b2007-10-14 10:39:51 +0000670}
671
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000672APFloat &
673APFloat::operator=(const APFloat &rhs)
674{
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000675 if (this != &rhs) {
676 if (semantics != rhs.semantics) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000677 freeSignificand();
678 initialize(rhs.semantics);
679 }
680 assign(rhs);
681 }
682
683 return *this;
684}
685
Benjamin Kramer06f47782014-03-04 20:26:51 +0000686APFloat &
687APFloat::operator=(APFloat &&rhs) {
688 freeSignificand();
689
690 semantics = rhs.semantics;
691 significand = rhs.significand;
692 exponent = rhs.exponent;
693 category = rhs.category;
694 sign = rhs.sign;
695
696 rhs.semantics = &Bogus;
697 return *this;
698}
699
Dale Johannesena719a602007-08-24 00:56:33 +0000700bool
Shuxin Yang4fb504f2013-01-07 18:59:35 +0000701APFloat::isDenormal() const {
Michael Gottesman3cb77ab2013-06-19 21:23:18 +0000702 return isFiniteNonZero() && (exponent == semantics->minExponent) &&
Shuxin Yang4fb504f2013-01-07 18:59:35 +0000703 (APInt::tcExtractBit(significandParts(),
704 semantics->precision - 1) == 0);
705}
706
707bool
Michael Gottesman0c622ea2013-05-30 18:07:13 +0000708APFloat::isSmallest() const {
709 // The smallest number by magnitude in our format will be the smallest
Michael Gottesmana7cc1242013-06-19 07:34:21 +0000710 // denormal, i.e. the floating point number with exponent being minimum
Michael Gottesman0c622ea2013-05-30 18:07:13 +0000711 // exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
Michael Gottesman3cb77ab2013-06-19 21:23:18 +0000712 return isFiniteNonZero() && exponent == semantics->minExponent &&
Michael Gottesman0c622ea2013-05-30 18:07:13 +0000713 significandMSB() == 0;
714}
715
716bool APFloat::isSignificandAllOnes() const {
717 // Test if the significand excluding the integral bit is all ones. This allows
718 // us to test for binade boundaries.
719 const integerPart *Parts = significandParts();
720 const unsigned PartCount = partCount();
721 for (unsigned i = 0; i < PartCount - 1; i++)
722 if (~Parts[i])
723 return false;
724
725 // Set the unused high bits to all ones when we compare.
726 const unsigned NumHighBits =
727 PartCount*integerPartWidth - semantics->precision + 1;
728 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
729 "fill than integerPartWidth");
730 const integerPart HighBitFill =
731 ~integerPart(0) << (integerPartWidth - NumHighBits);
732 if (~(Parts[PartCount - 1] | HighBitFill))
733 return false;
734
735 return true;
736}
737
738bool APFloat::isSignificandAllZeros() const {
739 // Test if the significand excluding the integral bit is all zeros. This
740 // allows us to test for binade boundaries.
741 const integerPart *Parts = significandParts();
742 const unsigned PartCount = partCount();
743
744 for (unsigned i = 0; i < PartCount - 1; i++)
745 if (Parts[i])
746 return false;
747
748 const unsigned NumHighBits =
749 PartCount*integerPartWidth - semantics->precision + 1;
750 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
751 "clear than integerPartWidth");
752 const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
753
754 if (Parts[PartCount - 1] & HighBitMask)
755 return false;
756
757 return true;
758}
759
760bool
761APFloat::isLargest() const {
762 // The largest number by magnitude in our format will be the floating point
763 // number with maximum exponent and with significand that is all ones.
Michael Gottesman3cb77ab2013-06-19 21:23:18 +0000764 return isFiniteNonZero() && exponent == semantics->maxExponent
Michael Gottesman0c622ea2013-05-30 18:07:13 +0000765 && isSignificandAllOnes();
766}
767
768bool
Dale Johannesenbdea32d2007-08-24 22:09:56 +0000769APFloat::bitwiseIsEqual(const APFloat &rhs) const {
Dale Johannesena719a602007-08-24 00:56:33 +0000770 if (this == &rhs)
771 return true;
772 if (semantics != rhs.semantics ||
Dale Johannesen3cf889f2007-08-31 04:03:46 +0000773 category != rhs.category ||
774 sign != rhs.sign)
Dale Johannesena719a602007-08-24 00:56:33 +0000775 return false;
Dale Johannesen3cf889f2007-08-31 04:03:46 +0000776 if (category==fcZero || category==fcInfinity)
Dale Johannesena719a602007-08-24 00:56:33 +0000777 return true;
Michael Gottesman8136c382013-06-26 23:17:28 +0000778 else if (isFiniteNonZero() && exponent!=rhs.exponent)
Dale Johannesen3cf889f2007-08-31 04:03:46 +0000779 return false;
Dale Johannesena719a602007-08-24 00:56:33 +0000780 else {
Dale Johannesena719a602007-08-24 00:56:33 +0000781 int i= partCount();
782 const integerPart* p=significandParts();
783 const integerPart* q=rhs.significandParts();
784 for (; i>0; i--, p++, q++) {
785 if (*p != *q)
786 return false;
787 }
788 return true;
789 }
790}
791
Ulrich Weigande1d62f92012-10-29 18:17:42 +0000792APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000793 initialize(&ourSemantics);
794 sign = 0;
Michael Gottesman30a90eb2013-07-27 21:49:21 +0000795 category = fcNormal;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000796 zeroSignificand();
797 exponent = ourSemantics.precision - 1;
798 significandParts()[0] = value;
799 normalize(rmNearestTiesToEven, lfExactlyZero);
800}
801
Ulrich Weigande1d62f92012-10-29 18:17:42 +0000802APFloat::APFloat(const fltSemantics &ourSemantics) {
Chris Lattnerac6271e2009-09-17 01:08:43 +0000803 initialize(&ourSemantics);
804 category = fcZero;
805 sign = false;
806}
807
Ulrich Weigande1d62f92012-10-29 18:17:42 +0000808APFloat::APFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
John McCalldcb9a7a2010-02-28 02:51:25 +0000809 // Allocates storage if necessary but does not initialize it.
810 initialize(&ourSemantics);
811}
Chris Lattnerac6271e2009-09-17 01:08:43 +0000812
Ulrich Weigande1d62f92012-10-29 18:17:42 +0000813APFloat::APFloat(const fltSemantics &ourSemantics, StringRef text) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000814 initialize(&ourSemantics);
815 convertFromString(text, rmNearestTiesToEven);
816}
817
Ulrich Weigande1d62f92012-10-29 18:17:42 +0000818APFloat::APFloat(const APFloat &rhs) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000819 initialize(rhs.semantics);
820 assign(rhs);
821}
822
Benjamin Kramer06f47782014-03-04 20:26:51 +0000823APFloat::APFloat(APFloat &&rhs) : semantics(&Bogus) {
824 *this = std::move(rhs);
825}
826
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000827APFloat::~APFloat()
828{
829 freeSignificand();
830}
831
Ted Kremenek6f30a072008-02-11 17:24:50 +0000832// Profile - This method 'profiles' an APFloat for use with FoldingSet.
833void APFloat::Profile(FoldingSetNodeID& ID) const {
Dale Johannesen54306fe2008-10-09 18:53:47 +0000834 ID.Add(bitcastToAPInt());
Ted Kremenek6f30a072008-02-11 17:24:50 +0000835}
836
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000837unsigned int
838APFloat::partCount() const
839{
Dale Johannesen146a0ea2007-09-20 23:47:58 +0000840 return partCountForBits(semantics->precision + 1);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000841}
842
843unsigned int
844APFloat::semanticsPrecision(const fltSemantics &semantics)
845{
846 return semantics.precision;
847}
848
849const integerPart *
850APFloat::significandParts() const
851{
852 return const_cast<APFloat *>(this)->significandParts();
853}
854
855integerPart *
856APFloat::significandParts()
857{
Evan Cheng67c90212009-10-27 21:35:42 +0000858 if (partCount() > 1)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000859 return significand.parts;
860 else
861 return &significand.part;
862}
863
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000864void
865APFloat::zeroSignificand()
866{
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000867 APInt::tcSet(significandParts(), 0, partCount());
868}
869
870/* Increment an fcNormal floating point number's significand. */
871void
872APFloat::incrementSignificand()
873{
874 integerPart carry;
875
876 carry = APInt::tcIncrement(significandParts(), partCount());
877
878 /* Our callers should never cause us to overflow. */
879 assert(carry == 0);
Duncan Sandsa41634e2011-08-12 14:54:45 +0000880 (void)carry;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000881}
882
883/* Add the significand of the RHS. Returns the carry flag. */
884integerPart
885APFloat::addSignificand(const APFloat &rhs)
886{
887 integerPart *parts;
888
889 parts = significandParts();
890
891 assert(semantics == rhs.semantics);
892 assert(exponent == rhs.exponent);
893
894 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
895}
896
897/* Subtract the significand of the RHS with a borrow flag. Returns
898 the borrow flag. */
899integerPart
900APFloat::subtractSignificand(const APFloat &rhs, integerPart borrow)
901{
902 integerPart *parts;
903
904 parts = significandParts();
905
906 assert(semantics == rhs.semantics);
907 assert(exponent == rhs.exponent);
908
909 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
Neil Booth9acbf5a2007-09-26 21:33:42 +0000910 partCount());
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000911}
912
913/* Multiply the significand of the RHS. If ADDEND is non-NULL, add it
914 on to the full-precision result of the multiplication. Returns the
915 lost fraction. */
916lostFraction
917APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
918{
Neil Booth9acbf5a2007-09-26 21:33:42 +0000919 unsigned int omsb; // One, not zero, based MSB.
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000920 unsigned int partsCount, newPartsCount, precision;
921 integerPart *lhsSignificand;
922 integerPart scratch[4];
923 integerPart *fullSignificand;
924 lostFraction lost_fraction;
Dale Johannesen4f0bd682008-10-09 23:00:39 +0000925 bool ignored;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000926
927 assert(semantics == rhs.semantics);
928
929 precision = semantics->precision;
930 newPartsCount = partCountForBits(precision * 2);
931
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000932 if (newPartsCount > 4)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000933 fullSignificand = new integerPart[newPartsCount];
934 else
935 fullSignificand = scratch;
936
937 lhsSignificand = significandParts();
938 partsCount = partCount();
939
940 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
Neil Booth0ea72a92007-10-06 00:24:48 +0000941 rhs.significandParts(), partsCount, partsCount);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000942
943 lost_fraction = lfExactlyZero;
944 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
945 exponent += rhs.exponent;
946
Shuxin Yangbbddbac2013-05-13 18:03:12 +0000947 // Assume the operands involved in the multiplication are single-precision
948 // FP, and the two multiplicants are:
949 // *this = a23 . a22 ... a0 * 2^e1
950 // rhs = b23 . b22 ... b0 * 2^e2
951 // the result of multiplication is:
952 // *this = c47 c46 . c45 ... c0 * 2^(e1+e2)
953 // Note that there are two significant bits at the left-hand side of the
954 // radix point. Move the radix point toward left by one bit, and adjust
955 // exponent accordingly.
956 exponent += 1;
957
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000958 if (addend) {
Shuxin Yangbbddbac2013-05-13 18:03:12 +0000959 // The intermediate result of the multiplication has "2 * precision"
960 // signicant bit; adjust the addend to be consistent with mul result.
961 //
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000962 Significand savedSignificand = significand;
963 const fltSemantics *savedSemantics = semantics;
964 fltSemantics extendedSemantics;
965 opStatus status;
966 unsigned int extendedPrecision;
967
968 /* Normalize our MSB. */
Shuxin Yangbbddbac2013-05-13 18:03:12 +0000969 extendedPrecision = 2 * precision;
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000970 if (omsb != extendedPrecision) {
Shuxin Yangbbddbac2013-05-13 18:03:12 +0000971 assert(extendedPrecision > omsb);
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000972 APInt::tcShiftLeft(fullSignificand, newPartsCount,
973 extendedPrecision - omsb);
974 exponent -= extendedPrecision - omsb;
975 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000976
977 /* Create new semantics. */
978 extendedSemantics = *semantics;
979 extendedSemantics.precision = extendedPrecision;
980
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000981 if (newPartsCount == 1)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000982 significand.part = fullSignificand[0];
983 else
984 significand.parts = fullSignificand;
985 semantics = &extendedSemantics;
986
987 APFloat extendedAddend(*addend);
Dale Johannesen4f0bd682008-10-09 23:00:39 +0000988 status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000989 assert(status == opOK);
Duncan Sandsa41634e2011-08-12 14:54:45 +0000990 (void)status;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000991 lost_fraction = addOrSubtractSignificand(extendedAddend, false);
992
993 /* Restore our state. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +0000994 if (newPartsCount == 1)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +0000995 fullSignificand[0] = significand.part;
996 significand = savedSignificand;
997 semantics = savedSemantics;
998
999 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1000 }
1001
Shuxin Yangbbddbac2013-05-13 18:03:12 +00001002 // Convert the result having "2 * precision" significant-bits back to the one
1003 // having "precision" significant-bits. First, move the radix point from
1004 // poision "2*precision - 1" to "precision - 1". The exponent need to be
1005 // adjusted by "2*precision - 1" - "precision - 1" = "precision".
1006 exponent -= precision;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001007
Shuxin Yangbbddbac2013-05-13 18:03:12 +00001008 // In case MSB resides at the left-hand side of radix point, shift the
1009 // mantissa right by some amount to make sure the MSB reside right before
1010 // the radix point (i.e. "MSB . rest-significant-bits").
1011 //
1012 // Note that the result is not normalized when "omsb < precision". So, the
1013 // caller needs to call APFloat::normalize() if normalized value is expected.
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001014 if (omsb > precision) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001015 unsigned int bits, significantParts;
1016 lostFraction lf;
1017
1018 bits = omsb - precision;
1019 significantParts = partCountForBits(omsb);
1020 lf = shiftRight(fullSignificand, significantParts, bits);
1021 lost_fraction = combineLostFractions(lf, lost_fraction);
1022 exponent += bits;
1023 }
1024
1025 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1026
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001027 if (newPartsCount > 4)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001028 delete [] fullSignificand;
1029
1030 return lost_fraction;
1031}
1032
1033/* Multiply the significands of LHS and RHS to DST. */
1034lostFraction
1035APFloat::divideSignificand(const APFloat &rhs)
1036{
1037 unsigned int bit, i, partsCount;
1038 const integerPart *rhsSignificand;
1039 integerPart *lhsSignificand, *dividend, *divisor;
1040 integerPart scratch[4];
1041 lostFraction lost_fraction;
1042
1043 assert(semantics == rhs.semantics);
1044
1045 lhsSignificand = significandParts();
1046 rhsSignificand = rhs.significandParts();
1047 partsCount = partCount();
1048
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001049 if (partsCount > 2)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001050 dividend = new integerPart[partsCount * 2];
1051 else
1052 dividend = scratch;
1053
1054 divisor = dividend + partsCount;
1055
1056 /* Copy the dividend and divisor as they will be modified in-place. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001057 for (i = 0; i < partsCount; i++) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001058 dividend[i] = lhsSignificand[i];
1059 divisor[i] = rhsSignificand[i];
1060 lhsSignificand[i] = 0;
1061 }
1062
1063 exponent -= rhs.exponent;
1064
1065 unsigned int precision = semantics->precision;
1066
1067 /* Normalize the divisor. */
1068 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001069 if (bit) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001070 exponent += bit;
1071 APInt::tcShiftLeft(divisor, partsCount, bit);
1072 }
1073
1074 /* Normalize the dividend. */
1075 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001076 if (bit) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001077 exponent -= bit;
1078 APInt::tcShiftLeft(dividend, partsCount, bit);
1079 }
1080
Neil Boothb93d90e2007-10-12 16:02:31 +00001081 /* Ensure the dividend >= divisor initially for the loop below.
1082 Incidentally, this means that the division loop below is
1083 guaranteed to set the integer bit to one. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001084 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001085 exponent--;
1086 APInt::tcShiftLeft(dividend, partsCount, 1);
1087 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1088 }
1089
1090 /* Long division. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001091 for (bit = precision; bit; bit -= 1) {
1092 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001093 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1094 APInt::tcSetBit(lhsSignificand, bit - 1);
1095 }
1096
1097 APInt::tcShiftLeft(dividend, partsCount, 1);
1098 }
1099
1100 /* Figure out the lost fraction. */
1101 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1102
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001103 if (cmp > 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001104 lost_fraction = lfMoreThanHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001105 else if (cmp == 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001106 lost_fraction = lfExactlyHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001107 else if (APInt::tcIsZero(dividend, partsCount))
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001108 lost_fraction = lfExactlyZero;
1109 else
1110 lost_fraction = lfLessThanHalf;
1111
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001112 if (partsCount > 2)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001113 delete [] dividend;
1114
1115 return lost_fraction;
1116}
1117
1118unsigned int
1119APFloat::significandMSB() const
1120{
1121 return APInt::tcMSB(significandParts(), partCount());
1122}
1123
1124unsigned int
1125APFloat::significandLSB() const
1126{
1127 return APInt::tcLSB(significandParts(), partCount());
1128}
1129
1130/* Note that a zero result is NOT normalized to fcZero. */
1131lostFraction
1132APFloat::shiftSignificandRight(unsigned int bits)
1133{
1134 /* Our exponent should not overflow. */
Michael Gottesman9dc98332013-06-24 04:06:23 +00001135 assert((ExponentType) (exponent + bits) >= exponent);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001136
1137 exponent += bits;
1138
1139 return shiftRight(significandParts(), partCount(), bits);
1140}
1141
1142/* Shift the significand left BITS bits, subtract BITS from its exponent. */
1143void
1144APFloat::shiftSignificandLeft(unsigned int bits)
1145{
1146 assert(bits < semantics->precision);
1147
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001148 if (bits) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001149 unsigned int partsCount = partCount();
1150
1151 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1152 exponent -= bits;
1153
1154 assert(!APInt::tcIsZero(significandParts(), partsCount));
1155 }
1156}
1157
1158APFloat::cmpResult
1159APFloat::compareAbsoluteValue(const APFloat &rhs) const
1160{
1161 int compare;
1162
1163 assert(semantics == rhs.semantics);
Michael Gottesman8136c382013-06-26 23:17:28 +00001164 assert(isFiniteNonZero());
1165 assert(rhs.isFiniteNonZero());
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001166
1167 compare = exponent - rhs.exponent;
1168
1169 /* If exponents are equal, do an unsigned bignum comparison of the
1170 significands. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001171 if (compare == 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001172 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
Neil Booth9acbf5a2007-09-26 21:33:42 +00001173 partCount());
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001174
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001175 if (compare > 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001176 return cmpGreaterThan;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001177 else if (compare < 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001178 return cmpLessThan;
1179 else
1180 return cmpEqual;
1181}
1182
1183/* Handle overflow. Sign is preserved. We either become infinity or
1184 the largest finite number. */
1185APFloat::opStatus
1186APFloat::handleOverflow(roundingMode rounding_mode)
1187{
1188 /* Infinity? */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001189 if (rounding_mode == rmNearestTiesToEven ||
1190 rounding_mode == rmNearestTiesToAway ||
1191 (rounding_mode == rmTowardPositive && !sign) ||
1192 (rounding_mode == rmTowardNegative && sign)) {
1193 category = fcInfinity;
1194 return (opStatus) (opOverflow | opInexact);
1195 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001196
1197 /* Otherwise we become the largest finite number. */
1198 category = fcNormal;
1199 exponent = semantics->maxExponent;
1200 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
Neil Booth9acbf5a2007-09-26 21:33:42 +00001201 semantics->precision);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001202
1203 return opInexact;
1204}
1205
Neil Booth1ca1f802007-10-03 15:16:41 +00001206/* Returns TRUE if, when truncating the current number, with BIT the
1207 new LSB, with the given lost fraction and rounding mode, the result
1208 would need to be rounded away from zero (i.e., by increasing the
1209 signficand). This routine must work for fcZero of both signs, and
1210 fcNormal numbers. */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001211bool
1212APFloat::roundAwayFromZero(roundingMode rounding_mode,
Neil Booth1ca1f802007-10-03 15:16:41 +00001213 lostFraction lost_fraction,
1214 unsigned int bit) const
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001215{
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001216 /* NaNs and infinities should not have lost fractions. */
Michael Gottesman8136c382013-06-26 23:17:28 +00001217 assert(isFiniteNonZero() || category == fcZero);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001218
Neil Booth1ca1f802007-10-03 15:16:41 +00001219 /* Current callers never pass this so we don't handle it. */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001220 assert(lost_fraction != lfExactlyZero);
1221
Mike Stump889285d2009-05-13 23:23:20 +00001222 switch (rounding_mode) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001223 case rmNearestTiesToAway:
1224 return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
1225
1226 case rmNearestTiesToEven:
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001227 if (lost_fraction == lfMoreThanHalf)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001228 return true;
1229
1230 /* Our zeroes don't have a significand to test. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001231 if (lost_fraction == lfExactlyHalf && category != fcZero)
Neil Booth1ca1f802007-10-03 15:16:41 +00001232 return APInt::tcExtractBit(significandParts(), bit);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001233
1234 return false;
1235
1236 case rmTowardZero:
1237 return false;
1238
1239 case rmTowardPositive:
1240 return sign == false;
1241
1242 case rmTowardNegative:
1243 return sign == true;
1244 }
Chandler Carruthf3e85022012-01-10 18:08:01 +00001245 llvm_unreachable("Invalid rounding mode found");
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001246}
1247
1248APFloat::opStatus
1249APFloat::normalize(roundingMode rounding_mode,
Neil Booth9acbf5a2007-09-26 21:33:42 +00001250 lostFraction lost_fraction)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001251{
Neil Booth9acbf5a2007-09-26 21:33:42 +00001252 unsigned int omsb; /* One, not zero, based MSB. */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001253 int exponentChange;
1254
Michael Gottesman8136c382013-06-26 23:17:28 +00001255 if (!isFiniteNonZero())
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001256 return opOK;
1257
1258 /* Before rounding normalize the exponent of fcNormal numbers. */
1259 omsb = significandMSB() + 1;
1260
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001261 if (omsb) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001262 /* OMSB is numbered from 1. We want to place it in the integer
Nick Lewyckyf66daac2011-10-03 21:30:08 +00001263 bit numbered PRECISION if possible, with a compensating change in
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001264 the exponent. */
1265 exponentChange = omsb - semantics->precision;
1266
1267 /* If the resulting exponent is too high, overflow according to
1268 the rounding mode. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001269 if (exponent + exponentChange > semantics->maxExponent)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001270 return handleOverflow(rounding_mode);
1271
1272 /* Subnormal numbers have exponent minExponent, and their MSB
1273 is forced based on that. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001274 if (exponent + exponentChange < semantics->minExponent)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001275 exponentChange = semantics->minExponent - exponent;
1276
1277 /* Shifting left is easy as we don't lose precision. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001278 if (exponentChange < 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001279 assert(lost_fraction == lfExactlyZero);
1280
1281 shiftSignificandLeft(-exponentChange);
1282
1283 return opOK;
1284 }
1285
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001286 if (exponentChange > 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001287 lostFraction lf;
1288
1289 /* Shift right and capture any new lost fraction. */
1290 lf = shiftSignificandRight(exponentChange);
1291
1292 lost_fraction = combineLostFractions(lf, lost_fraction);
1293
1294 /* Keep OMSB up-to-date. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001295 if (omsb > (unsigned) exponentChange)
Neil Boothb93d90e2007-10-12 16:02:31 +00001296 omsb -= exponentChange;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001297 else
Neil Booth9acbf5a2007-09-26 21:33:42 +00001298 omsb = 0;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001299 }
1300 }
1301
1302 /* Now round the number according to rounding_mode given the lost
1303 fraction. */
1304
1305 /* As specified in IEEE 754, since we do not trap we do not report
1306 underflow for exact results. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001307 if (lost_fraction == lfExactlyZero) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001308 /* Canonicalize zeroes. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001309 if (omsb == 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001310 category = fcZero;
1311
1312 return opOK;
1313 }
1314
1315 /* Increment the significand if we're rounding away from zero. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001316 if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1317 if (omsb == 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001318 exponent = semantics->minExponent;
1319
1320 incrementSignificand();
1321 omsb = significandMSB() + 1;
1322
1323 /* Did the significand increment overflow? */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001324 if (omsb == (unsigned) semantics->precision + 1) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001325 /* Renormalize by incrementing the exponent and shifting our
Neil Booth9acbf5a2007-09-26 21:33:42 +00001326 significand right one. However if we already have the
1327 maximum exponent we overflow to infinity. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001328 if (exponent == semantics->maxExponent) {
Neil Booth9acbf5a2007-09-26 21:33:42 +00001329 category = fcInfinity;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001330
Neil Booth9acbf5a2007-09-26 21:33:42 +00001331 return (opStatus) (opOverflow | opInexact);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001332 }
1333
1334 shiftSignificandRight(1);
1335
1336 return opInexact;
1337 }
1338 }
1339
1340 /* The normal case - we were and are not denormal, and any
1341 significand increment above didn't overflow. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001342 if (omsb == semantics->precision)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001343 return opInexact;
1344
1345 /* We have a non-zero denormal. */
1346 assert(omsb < semantics->precision);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001347
1348 /* Canonicalize zeroes. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001349 if (omsb == 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001350 category = fcZero;
1351
1352 /* The fcZero case is a denormal that underflowed to zero. */
1353 return (opStatus) (opUnderflow | opInexact);
1354}
1355
1356APFloat::opStatus
1357APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
1358{
Michael Gottesman9b877e12013-06-24 09:57:57 +00001359 switch (PackCategoriesIntoKey(category, rhs.category)) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001360 default:
Craig Topper2617dcc2014-04-15 06:32:26 +00001361 llvm_unreachable(nullptr);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001362
Michael Gottesman9b877e12013-06-24 09:57:57 +00001363 case PackCategoriesIntoKey(fcNaN, fcZero):
1364 case PackCategoriesIntoKey(fcNaN, fcNormal):
1365 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1366 case PackCategoriesIntoKey(fcNaN, fcNaN):
1367 case PackCategoriesIntoKey(fcNormal, fcZero):
1368 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1369 case PackCategoriesIntoKey(fcInfinity, fcZero):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001370 return opOK;
1371
Michael Gottesman9b877e12013-06-24 09:57:57 +00001372 case PackCategoriesIntoKey(fcZero, fcNaN):
1373 case PackCategoriesIntoKey(fcNormal, fcNaN):
1374 case PackCategoriesIntoKey(fcInfinity, fcNaN):
Stephen Canond3278282014-06-08 16:53:31 +00001375 // We need to be sure to flip the sign here for subtraction because we
1376 // don't have a separate negate operation so -NaN becomes 0 - NaN here.
1377 sign = rhs.sign ^ subtract;
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001378 category = fcNaN;
1379 copySignificand(rhs);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001380 return opOK;
1381
Michael Gottesman9b877e12013-06-24 09:57:57 +00001382 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1383 case PackCategoriesIntoKey(fcZero, fcInfinity):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001384 category = fcInfinity;
1385 sign = rhs.sign ^ subtract;
1386 return opOK;
1387
Michael Gottesman9b877e12013-06-24 09:57:57 +00001388 case PackCategoriesIntoKey(fcZero, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001389 assign(rhs);
1390 sign = rhs.sign ^ subtract;
1391 return opOK;
1392
Michael Gottesman9b877e12013-06-24 09:57:57 +00001393 case PackCategoriesIntoKey(fcZero, fcZero):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001394 /* Sign depends on rounding mode; handled by caller. */
1395 return opOK;
1396
Michael Gottesman9b877e12013-06-24 09:57:57 +00001397 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001398 /* Differently signed infinities can only be validly
1399 subtracted. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001400 if (((sign ^ rhs.sign)!=0) != subtract) {
Neil Booth5fe658b2007-10-14 10:39:51 +00001401 makeNaN();
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001402 return opInvalidOp;
1403 }
1404
1405 return opOK;
1406
Michael Gottesman9b877e12013-06-24 09:57:57 +00001407 case PackCategoriesIntoKey(fcNormal, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001408 return opDivByZero;
1409 }
1410}
1411
1412/* Add or subtract two normal numbers. */
1413lostFraction
1414APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
1415{
1416 integerPart carry;
1417 lostFraction lost_fraction;
1418 int bits;
1419
1420 /* Determine if the operation on the absolute values is effectively
1421 an addition or subtraction. */
Hartmut Kaiserfc69d322007-10-25 23:15:31 +00001422 subtract ^= (sign ^ rhs.sign) ? true : false;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001423
1424 /* Are we bigger exponent-wise than the RHS? */
1425 bits = exponent - rhs.exponent;
1426
1427 /* Subtraction is more subtle than one might naively expect. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001428 if (subtract) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001429 APFloat temp_rhs(rhs);
1430 bool reverse;
1431
Chris Lattner3da18eb2007-08-24 03:02:34 +00001432 if (bits == 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001433 reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
1434 lost_fraction = lfExactlyZero;
Chris Lattner3da18eb2007-08-24 03:02:34 +00001435 } else if (bits > 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001436 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1437 shiftSignificandLeft(1);
1438 reverse = false;
Chris Lattner3da18eb2007-08-24 03:02:34 +00001439 } else {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001440 lost_fraction = shiftSignificandRight(-bits - 1);
1441 temp_rhs.shiftSignificandLeft(1);
1442 reverse = true;
1443 }
1444
Chris Lattner3da18eb2007-08-24 03:02:34 +00001445 if (reverse) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001446 carry = temp_rhs.subtractSignificand
Neil Booth9acbf5a2007-09-26 21:33:42 +00001447 (*this, lost_fraction != lfExactlyZero);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001448 copySignificand(temp_rhs);
1449 sign = !sign;
1450 } else {
1451 carry = subtractSignificand
Neil Booth9acbf5a2007-09-26 21:33:42 +00001452 (temp_rhs, lost_fraction != lfExactlyZero);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001453 }
1454
1455 /* Invert the lost fraction - it was on the RHS and
1456 subtracted. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001457 if (lost_fraction == lfLessThanHalf)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001458 lost_fraction = lfMoreThanHalf;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001459 else if (lost_fraction == lfMoreThanHalf)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001460 lost_fraction = lfLessThanHalf;
1461
1462 /* The code above is intended to ensure that no borrow is
1463 necessary. */
1464 assert(!carry);
Duncan Sandsa41634e2011-08-12 14:54:45 +00001465 (void)carry;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001466 } else {
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001467 if (bits > 0) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001468 APFloat temp_rhs(rhs);
1469
1470 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1471 carry = addSignificand(temp_rhs);
1472 } else {
1473 lost_fraction = shiftSignificandRight(-bits);
1474 carry = addSignificand(rhs);
1475 }
1476
1477 /* We have a guard bit; generating a carry cannot happen. */
1478 assert(!carry);
Duncan Sandsa41634e2011-08-12 14:54:45 +00001479 (void)carry;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001480 }
1481
1482 return lost_fraction;
1483}
1484
1485APFloat::opStatus
1486APFloat::multiplySpecials(const APFloat &rhs)
1487{
Michael Gottesman9b877e12013-06-24 09:57:57 +00001488 switch (PackCategoriesIntoKey(category, rhs.category)) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001489 default:
Craig Topper2617dcc2014-04-15 06:32:26 +00001490 llvm_unreachable(nullptr);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001491
Michael Gottesman9b877e12013-06-24 09:57:57 +00001492 case PackCategoriesIntoKey(fcNaN, fcZero):
1493 case PackCategoriesIntoKey(fcNaN, fcNormal):
1494 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1495 case PackCategoriesIntoKey(fcNaN, fcNaN):
Michael Gottesmanb0e688e2013-07-27 21:49:25 +00001496 sign = false;
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001497 return opOK;
1498
Michael Gottesman9b877e12013-06-24 09:57:57 +00001499 case PackCategoriesIntoKey(fcZero, fcNaN):
1500 case PackCategoriesIntoKey(fcNormal, fcNaN):
1501 case PackCategoriesIntoKey(fcInfinity, fcNaN):
Michael Gottesmanb0e688e2013-07-27 21:49:25 +00001502 sign = false;
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001503 category = fcNaN;
1504 copySignificand(rhs);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001505 return opOK;
1506
Michael Gottesman9b877e12013-06-24 09:57:57 +00001507 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1508 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1509 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001510 category = fcInfinity;
1511 return opOK;
1512
Michael Gottesman9b877e12013-06-24 09:57:57 +00001513 case PackCategoriesIntoKey(fcZero, fcNormal):
1514 case PackCategoriesIntoKey(fcNormal, fcZero):
1515 case PackCategoriesIntoKey(fcZero, fcZero):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001516 category = fcZero;
1517 return opOK;
1518
Michael Gottesman9b877e12013-06-24 09:57:57 +00001519 case PackCategoriesIntoKey(fcZero, fcInfinity):
1520 case PackCategoriesIntoKey(fcInfinity, fcZero):
Neil Booth5fe658b2007-10-14 10:39:51 +00001521 makeNaN();
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001522 return opInvalidOp;
1523
Michael Gottesman9b877e12013-06-24 09:57:57 +00001524 case PackCategoriesIntoKey(fcNormal, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001525 return opOK;
1526 }
1527}
1528
1529APFloat::opStatus
1530APFloat::divideSpecials(const APFloat &rhs)
1531{
Michael Gottesman9b877e12013-06-24 09:57:57 +00001532 switch (PackCategoriesIntoKey(category, rhs.category)) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001533 default:
Craig Topper2617dcc2014-04-15 06:32:26 +00001534 llvm_unreachable(nullptr);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001535
Michael Gottesman9b877e12013-06-24 09:57:57 +00001536 case PackCategoriesIntoKey(fcZero, fcNaN):
1537 case PackCategoriesIntoKey(fcNormal, fcNaN):
1538 case PackCategoriesIntoKey(fcInfinity, fcNaN):
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001539 category = fcNaN;
1540 copySignificand(rhs);
Michael Gottesmanb0e688e2013-07-27 21:49:25 +00001541 case PackCategoriesIntoKey(fcNaN, fcZero):
1542 case PackCategoriesIntoKey(fcNaN, fcNormal):
1543 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1544 case PackCategoriesIntoKey(fcNaN, fcNaN):
1545 sign = false;
1546 case PackCategoriesIntoKey(fcInfinity, fcZero):
1547 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1548 case PackCategoriesIntoKey(fcZero, fcInfinity):
1549 case PackCategoriesIntoKey(fcZero, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001550 return opOK;
1551
Michael Gottesman9b877e12013-06-24 09:57:57 +00001552 case PackCategoriesIntoKey(fcNormal, fcInfinity):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001553 category = fcZero;
1554 return opOK;
1555
Michael Gottesman9b877e12013-06-24 09:57:57 +00001556 case PackCategoriesIntoKey(fcNormal, fcZero):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001557 category = fcInfinity;
1558 return opDivByZero;
1559
Michael Gottesman9b877e12013-06-24 09:57:57 +00001560 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1561 case PackCategoriesIntoKey(fcZero, fcZero):
Neil Booth5fe658b2007-10-14 10:39:51 +00001562 makeNaN();
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001563 return opInvalidOp;
1564
Michael Gottesman9b877e12013-06-24 09:57:57 +00001565 case PackCategoriesIntoKey(fcNormal, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001566 return opOK;
1567 }
1568}
1569
Dale Johannesenb5721632009-01-21 00:35:19 +00001570APFloat::opStatus
1571APFloat::modSpecials(const APFloat &rhs)
1572{
Michael Gottesman9b877e12013-06-24 09:57:57 +00001573 switch (PackCategoriesIntoKey(category, rhs.category)) {
Dale Johannesenb5721632009-01-21 00:35:19 +00001574 default:
Craig Topper2617dcc2014-04-15 06:32:26 +00001575 llvm_unreachable(nullptr);
Dale Johannesenb5721632009-01-21 00:35:19 +00001576
Michael Gottesman9b877e12013-06-24 09:57:57 +00001577 case PackCategoriesIntoKey(fcNaN, fcZero):
1578 case PackCategoriesIntoKey(fcNaN, fcNormal):
1579 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1580 case PackCategoriesIntoKey(fcNaN, fcNaN):
1581 case PackCategoriesIntoKey(fcZero, fcInfinity):
1582 case PackCategoriesIntoKey(fcZero, fcNormal):
1583 case PackCategoriesIntoKey(fcNormal, fcInfinity):
Dale Johannesenb5721632009-01-21 00:35:19 +00001584 return opOK;
1585
Michael Gottesman9b877e12013-06-24 09:57:57 +00001586 case PackCategoriesIntoKey(fcZero, fcNaN):
1587 case PackCategoriesIntoKey(fcNormal, fcNaN):
1588 case PackCategoriesIntoKey(fcInfinity, fcNaN):
Michael Gottesmanb0e688e2013-07-27 21:49:25 +00001589 sign = false;
Dale Johannesenb5721632009-01-21 00:35:19 +00001590 category = fcNaN;
1591 copySignificand(rhs);
1592 return opOK;
1593
Michael Gottesman9b877e12013-06-24 09:57:57 +00001594 case PackCategoriesIntoKey(fcNormal, fcZero):
1595 case PackCategoriesIntoKey(fcInfinity, fcZero):
1596 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1597 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1598 case PackCategoriesIntoKey(fcZero, fcZero):
Dale Johannesenb5721632009-01-21 00:35:19 +00001599 makeNaN();
1600 return opInvalidOp;
1601
Michael Gottesman9b877e12013-06-24 09:57:57 +00001602 case PackCategoriesIntoKey(fcNormal, fcNormal):
Dale Johannesenb5721632009-01-21 00:35:19 +00001603 return opOK;
1604 }
1605}
1606
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001607/* Change sign. */
1608void
1609APFloat::changeSign()
1610{
1611 /* Look mummy, this one's easy. */
1612 sign = !sign;
1613}
1614
Dale Johannesen689d17d2007-08-31 23:35:31 +00001615void
1616APFloat::clearSign()
1617{
1618 /* So is this one. */
1619 sign = 0;
1620}
1621
1622void
1623APFloat::copySign(const APFloat &rhs)
1624{
1625 /* And this one. */
1626 sign = rhs.sign;
1627}
1628
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001629/* Normalized addition or subtraction. */
1630APFloat::opStatus
1631APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
Neil Booth9acbf5a2007-09-26 21:33:42 +00001632 bool subtract)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001633{
1634 opStatus fs;
1635
1636 fs = addOrSubtractSpecials(rhs, subtract);
1637
1638 /* This return code means it was not a simple case. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001639 if (fs == opDivByZero) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001640 lostFraction lost_fraction;
1641
1642 lost_fraction = addOrSubtractSignificand(rhs, subtract);
1643 fs = normalize(rounding_mode, lost_fraction);
1644
1645 /* Can only be zero if we lost no fraction. */
1646 assert(category != fcZero || lost_fraction == lfExactlyZero);
1647 }
1648
1649 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1650 positive zero unless rounding to minus infinity, except that
1651 adding two like-signed zeroes gives that zero. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001652 if (category == fcZero) {
1653 if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001654 sign = (rounding_mode == rmTowardNegative);
1655 }
1656
1657 return fs;
1658}
1659
1660/* Normalized addition. */
1661APFloat::opStatus
1662APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
1663{
1664 return addOrSubtract(rhs, rounding_mode, false);
1665}
1666
1667/* Normalized subtraction. */
1668APFloat::opStatus
1669APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
1670{
1671 return addOrSubtract(rhs, rounding_mode, true);
1672}
1673
1674/* Normalized multiply. */
1675APFloat::opStatus
1676APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
1677{
1678 opStatus fs;
1679
1680 sign ^= rhs.sign;
1681 fs = multiplySpecials(rhs);
1682
Michael Gottesman8136c382013-06-26 23:17:28 +00001683 if (isFiniteNonZero()) {
Craig Topperc10719f2014-04-07 04:17:22 +00001684 lostFraction lost_fraction = multiplySignificand(rhs, nullptr);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001685 fs = normalize(rounding_mode, lost_fraction);
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001686 if (lost_fraction != lfExactlyZero)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001687 fs = (opStatus) (fs | opInexact);
1688 }
1689
1690 return fs;
1691}
1692
1693/* Normalized divide. */
1694APFloat::opStatus
1695APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
1696{
1697 opStatus fs;
1698
1699 sign ^= rhs.sign;
1700 fs = divideSpecials(rhs);
1701
Michael Gottesman8136c382013-06-26 23:17:28 +00001702 if (isFiniteNonZero()) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001703 lostFraction lost_fraction = divideSignificand(rhs);
1704 fs = normalize(rounding_mode, lost_fraction);
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001705 if (lost_fraction != lfExactlyZero)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001706 fs = (opStatus) (fs | opInexact);
1707 }
1708
1709 return fs;
1710}
1711
Dale Johannesenfe750172009-01-20 18:35:05 +00001712/* Normalized remainder. This is not currently correct in all cases. */
1713APFloat::opStatus
1714APFloat::remainder(const APFloat &rhs)
1715{
1716 opStatus fs;
1717 APFloat V = *this;
1718 unsigned int origSign = sign;
1719
Dale Johannesenfe750172009-01-20 18:35:05 +00001720 fs = V.divide(rhs, rmNearestTiesToEven);
1721 if (fs == opDivByZero)
1722 return fs;
1723
1724 int parts = partCount();
1725 integerPart *x = new integerPart[parts];
1726 bool ignored;
1727 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1728 rmNearestTiesToEven, &ignored);
1729 if (fs==opInvalidOp)
1730 return fs;
1731
1732 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1733 rmNearestTiesToEven);
1734 assert(fs==opOK); // should always work
1735
1736 fs = V.multiply(rhs, rmNearestTiesToEven);
1737 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1738
1739 fs = subtract(V, rmNearestTiesToEven);
1740 assert(fs==opOK || fs==opInexact); // likewise
1741
1742 if (isZero())
1743 sign = origSign; // IEEE754 requires this
1744 delete[] x;
1745 return fs;
1746}
1747
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001748/* Normalized llvm frem (C fmod).
Dale Johannesenfe750172009-01-20 18:35:05 +00001749 This is not currently correct in all cases. */
Dale Johannesen689d17d2007-08-31 23:35:31 +00001750APFloat::opStatus
1751APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
1752{
1753 opStatus fs;
Dale Johannesenb5721632009-01-21 00:35:19 +00001754 fs = modSpecials(rhs);
Dale Johannesen689d17d2007-08-31 23:35:31 +00001755
Michael Gottesman8136c382013-06-26 23:17:28 +00001756 if (isFiniteNonZero() && rhs.isFiniteNonZero()) {
Dale Johannesenb5721632009-01-21 00:35:19 +00001757 APFloat V = *this;
1758 unsigned int origSign = sign;
Dale Johannesen689d17d2007-08-31 23:35:31 +00001759
Dale Johannesenb5721632009-01-21 00:35:19 +00001760 fs = V.divide(rhs, rmNearestTiesToEven);
1761 if (fs == opDivByZero)
1762 return fs;
Dale Johannesen728687c2007-09-05 20:39:49 +00001763
Dale Johannesenb5721632009-01-21 00:35:19 +00001764 int parts = partCount();
1765 integerPart *x = new integerPart[parts];
1766 bool ignored;
1767 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1768 rmTowardZero, &ignored);
1769 if (fs==opInvalidOp)
1770 return fs;
Dale Johannesen728687c2007-09-05 20:39:49 +00001771
Dale Johannesenb5721632009-01-21 00:35:19 +00001772 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1773 rmNearestTiesToEven);
1774 assert(fs==opOK); // should always work
Dale Johannesen728687c2007-09-05 20:39:49 +00001775
Dale Johannesenb5721632009-01-21 00:35:19 +00001776 fs = V.multiply(rhs, rounding_mode);
1777 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1778
1779 fs = subtract(V, rounding_mode);
1780 assert(fs==opOK || fs==opInexact); // likewise
1781
1782 if (isZero())
1783 sign = origSign; // IEEE754 requires this
1784 delete[] x;
1785 }
Dale Johannesen689d17d2007-08-31 23:35:31 +00001786 return fs;
1787}
1788
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001789/* Normalized fused-multiply-add. */
1790APFloat::opStatus
1791APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
Neil Booth9acbf5a2007-09-26 21:33:42 +00001792 const APFloat &addend,
1793 roundingMode rounding_mode)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001794{
1795 opStatus fs;
1796
1797 /* Post-multiplication sign, before addition. */
1798 sign ^= multiplicand.sign;
1799
1800 /* If and only if all arguments are normal do we need to do an
1801 extended-precision calculation. */
Michael Gottesman8136c382013-06-26 23:17:28 +00001802 if (isFiniteNonZero() &&
1803 multiplicand.isFiniteNonZero() &&
1804 addend.isFiniteNonZero()) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001805 lostFraction lost_fraction;
1806
1807 lost_fraction = multiplySignificand(multiplicand, &addend);
1808 fs = normalize(rounding_mode, lost_fraction);
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001809 if (lost_fraction != lfExactlyZero)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001810 fs = (opStatus) (fs | opInexact);
1811
1812 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1813 positive zero unless rounding to minus infinity, except that
1814 adding two like-signed zeroes gives that zero. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001815 if (category == fcZero && sign != addend.sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001816 sign = (rounding_mode == rmTowardNegative);
1817 } else {
1818 fs = multiplySpecials(multiplicand);
1819
1820 /* FS can only be opOK or opInvalidOp. There is no more work
1821 to do in the latter case. The IEEE-754R standard says it is
1822 implementation-defined in this case whether, if ADDEND is a
Dale Johannesen3cf889f2007-08-31 04:03:46 +00001823 quiet NaN, we raise invalid op; this implementation does so.
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001824
1825 If we need to do the addition we can do so with normal
1826 precision. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001827 if (fs == opOK)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001828 fs = addOrSubtract(addend, rounding_mode, false);
1829 }
1830
1831 return fs;
1832}
1833
Owen Andersona40319b2012-08-13 23:32:49 +00001834/* Rounding-mode corrrect round to integral value. */
1835APFloat::opStatus APFloat::roundToIntegral(roundingMode rounding_mode) {
1836 opStatus fs;
Owen Andersona40319b2012-08-13 23:32:49 +00001837
Owen Anderson352dfff2012-08-15 18:28:45 +00001838 // If the exponent is large enough, we know that this value is already
1839 // integral, and the arithmetic below would potentially cause it to saturate
1840 // to +/-Inf. Bail out early instead.
Michael Gottesman8136c382013-06-26 23:17:28 +00001841 if (isFiniteNonZero() && exponent+1 >= (int)semanticsPrecision(*semantics))
Owen Anderson352dfff2012-08-15 18:28:45 +00001842 return opOK;
1843
Owen Andersona40319b2012-08-13 23:32:49 +00001844 // The algorithm here is quite simple: we add 2^(p-1), where p is the
1845 // precision of our format, and then subtract it back off again. The choice
1846 // of rounding modes for the addition/subtraction determines the rounding mode
1847 // for our integral rounding as well.
Owen Andersonbe7e2972012-08-15 16:42:53 +00001848 // NOTE: When the input value is negative, we do subtraction followed by
Owen Anderson1ff74b02012-08-15 05:39:46 +00001849 // addition instead.
Owen Anderson0b357222012-08-14 18:51:15 +00001850 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
1851 IntegerConstant <<= semanticsPrecision(*semantics)-1;
Owen Andersona40319b2012-08-13 23:32:49 +00001852 APFloat MagicConstant(*semantics);
1853 fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
1854 rmNearestTiesToEven);
Owen Anderson1ff74b02012-08-15 05:39:46 +00001855 MagicConstant.copySign(*this);
1856
Owen Andersona40319b2012-08-13 23:32:49 +00001857 if (fs != opOK)
1858 return fs;
1859
Owen Anderson1ff74b02012-08-15 05:39:46 +00001860 // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
1861 bool inputSign = isNegative();
1862
Owen Andersona40319b2012-08-13 23:32:49 +00001863 fs = add(MagicConstant, rounding_mode);
1864 if (fs != opOK && fs != opInexact)
1865 return fs;
1866
1867 fs = subtract(MagicConstant, rounding_mode);
Owen Anderson1ff74b02012-08-15 05:39:46 +00001868
1869 // Restore the input sign.
1870 if (inputSign != isNegative())
1871 changeSign();
1872
Owen Andersona40319b2012-08-13 23:32:49 +00001873 return fs;
1874}
1875
1876
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001877/* Comparison requires normalized numbers. */
1878APFloat::cmpResult
1879APFloat::compare(const APFloat &rhs) const
1880{
1881 cmpResult result;
1882
1883 assert(semantics == rhs.semantics);
1884
Michael Gottesman9b877e12013-06-24 09:57:57 +00001885 switch (PackCategoriesIntoKey(category, rhs.category)) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001886 default:
Craig Topper2617dcc2014-04-15 06:32:26 +00001887 llvm_unreachable(nullptr);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001888
Michael Gottesman9b877e12013-06-24 09:57:57 +00001889 case PackCategoriesIntoKey(fcNaN, fcZero):
1890 case PackCategoriesIntoKey(fcNaN, fcNormal):
1891 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1892 case PackCategoriesIntoKey(fcNaN, fcNaN):
1893 case PackCategoriesIntoKey(fcZero, fcNaN):
1894 case PackCategoriesIntoKey(fcNormal, fcNaN):
1895 case PackCategoriesIntoKey(fcInfinity, fcNaN):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001896 return cmpUnordered;
1897
Michael Gottesman9b877e12013-06-24 09:57:57 +00001898 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1899 case PackCategoriesIntoKey(fcInfinity, fcZero):
1900 case PackCategoriesIntoKey(fcNormal, fcZero):
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001901 if (sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001902 return cmpLessThan;
1903 else
1904 return cmpGreaterThan;
1905
Michael Gottesman9b877e12013-06-24 09:57:57 +00001906 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1907 case PackCategoriesIntoKey(fcZero, fcInfinity):
1908 case PackCategoriesIntoKey(fcZero, fcNormal):
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001909 if (rhs.sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001910 return cmpGreaterThan;
1911 else
1912 return cmpLessThan;
1913
Michael Gottesman9b877e12013-06-24 09:57:57 +00001914 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001915 if (sign == rhs.sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001916 return cmpEqual;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001917 else if (sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001918 return cmpLessThan;
1919 else
1920 return cmpGreaterThan;
1921
Michael Gottesman9b877e12013-06-24 09:57:57 +00001922 case PackCategoriesIntoKey(fcZero, fcZero):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001923 return cmpEqual;
1924
Michael Gottesman9b877e12013-06-24 09:57:57 +00001925 case PackCategoriesIntoKey(fcNormal, fcNormal):
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001926 break;
1927 }
1928
1929 /* Two normal numbers. Do they have the same sign? */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001930 if (sign != rhs.sign) {
1931 if (sign)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001932 result = cmpLessThan;
1933 else
1934 result = cmpGreaterThan;
1935 } else {
1936 /* Compare absolute values; invert result if negative. */
1937 result = compareAbsoluteValue(rhs);
1938
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001939 if (sign) {
1940 if (result == cmpLessThan)
Neil Booth9acbf5a2007-09-26 21:33:42 +00001941 result = cmpGreaterThan;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00001942 else if (result == cmpGreaterThan)
Neil Booth9acbf5a2007-09-26 21:33:42 +00001943 result = cmpLessThan;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001944 }
1945 }
1946
1947 return result;
1948}
1949
Dale Johannesen4f0bd682008-10-09 23:00:39 +00001950/// APFloat::convert - convert a value of one floating point type to another.
1951/// The return value corresponds to the IEEE754 exceptions. *losesInfo
1952/// records whether the transformation lost information, i.e. whether
1953/// converting the result back to the original type will produce the
1954/// original value (this is almost the same as return value==fsOK, but there
1955/// are edge cases where this is not so).
1956
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001957APFloat::opStatus
1958APFloat::convert(const fltSemantics &toSemantics,
Dale Johannesen4f0bd682008-10-09 23:00:39 +00001959 roundingMode rounding_mode, bool *losesInfo)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001960{
Neil Bootha8d72692007-09-22 02:56:19 +00001961 lostFraction lostFraction;
1962 unsigned int newPartCount, oldPartCount;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001963 opStatus fs;
Eli Friedmana84ad7d2011-11-26 03:38:02 +00001964 int shift;
1965 const fltSemantics &fromSemantics = *semantics;
Neil Booth9acbf5a2007-09-26 21:33:42 +00001966
Neil Bootha8d72692007-09-22 02:56:19 +00001967 lostFraction = lfExactlyZero;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001968 newPartCount = partCountForBits(toSemantics.precision + 1);
Neil Bootha8d72692007-09-22 02:56:19 +00001969 oldPartCount = partCount();
Eli Friedmana84ad7d2011-11-26 03:38:02 +00001970 shift = toSemantics.precision - fromSemantics.precision;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00001971
Eli Friedmana84ad7d2011-11-26 03:38:02 +00001972 bool X86SpecialNan = false;
1973 if (&fromSemantics == &APFloat::x87DoubleExtended &&
1974 &toSemantics != &APFloat::x87DoubleExtended && category == fcNaN &&
1975 (!(*significandParts() & 0x8000000000000000ULL) ||
1976 !(*significandParts() & 0x4000000000000000ULL))) {
1977 // x86 has some unusual NaNs which cannot be represented in any other
1978 // format; note them here.
1979 X86SpecialNan = true;
1980 }
1981
Ulrich Weigand1d4dbda2013-07-16 13:03:25 +00001982 // If this is a truncation of a denormal number, and the target semantics
1983 // has larger exponent range than the source semantics (this can happen
1984 // when truncating from PowerPC double-double to double format), the
1985 // right shift could lose result mantissa bits. Adjust exponent instead
1986 // of performing excessive shift.
1987 if (shift < 0 && isFiniteNonZero()) {
1988 int exponentChange = significandMSB() + 1 - fromSemantics.precision;
1989 if (exponent + exponentChange < toSemantics.minExponent)
1990 exponentChange = toSemantics.minExponent - exponent;
1991 if (exponentChange < shift)
1992 exponentChange = shift;
1993 if (exponentChange < 0) {
1994 shift -= exponentChange;
1995 exponent += exponentChange;
1996 }
1997 }
1998
Eli Friedmana84ad7d2011-11-26 03:38:02 +00001999 // If this is a truncation, perform the shift before we narrow the storage.
Michael Gottesman8136c382013-06-26 23:17:28 +00002000 if (shift < 0 && (isFiniteNonZero() || category==fcNaN))
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002001 lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
2002
2003 // Fix the storage so it can hold to new value.
Neil Bootha8d72692007-09-22 02:56:19 +00002004 if (newPartCount > oldPartCount) {
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002005 // The new type requires more storage; make it available.
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002006 integerPart *newParts;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002007 newParts = new integerPart[newPartCount];
2008 APInt::tcSet(newParts, 0, newPartCount);
Michael Gottesman8136c382013-06-26 23:17:28 +00002009 if (isFiniteNonZero() || category==fcNaN)
Dale Johannesen4f55d9f2007-09-25 17:25:00 +00002010 APInt::tcAssign(newParts, significandParts(), oldPartCount);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002011 freeSignificand();
2012 significand.parts = newParts;
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002013 } else if (newPartCount == 1 && oldPartCount != 1) {
2014 // Switch to built-in storage for a single part.
2015 integerPart newPart = 0;
Michael Gottesman8136c382013-06-26 23:17:28 +00002016 if (isFiniteNonZero() || category==fcNaN)
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002017 newPart = significandParts()[0];
2018 freeSignificand();
2019 significand.part = newPart;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002020 }
2021
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002022 // Now that we have the right storage, switch the semantics.
2023 semantics = &toSemantics;
2024
2025 // If this is an extension, perform the shift now that the storage is
2026 // available.
Michael Gottesman8136c382013-06-26 23:17:28 +00002027 if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002028 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
2029
Michael Gottesman8136c382013-06-26 23:17:28 +00002030 if (isFiniteNonZero()) {
Neil Bootha8d72692007-09-22 02:56:19 +00002031 fs = normalize(rounding_mode, lostFraction);
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002032 *losesInfo = (fs != opOK);
Dale Johannesen4f55d9f2007-09-25 17:25:00 +00002033 } else if (category == fcNaN) {
Eli Friedmana84ad7d2011-11-26 03:38:02 +00002034 *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
Benjamin Kramerb361adb2013-01-25 17:01:00 +00002035
2036 // For x87 extended precision, we want to make a NaN, not a special NaN if
2037 // the input wasn't special either.
2038 if (!X86SpecialNan && semantics == &APFloat::x87DoubleExtended)
2039 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2040
Dale Johannesen4f55d9f2007-09-25 17:25:00 +00002041 // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
2042 // does not give you back the same bits. This is dubious, and we
2043 // don't currently do it. You're really supposed to get
2044 // an invalid operation signal at runtime, but nobody does that.
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002045 fs = opOK;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002046 } else {
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002047 *losesInfo = false;
Eli Friedman31f01162011-11-28 18:50:37 +00002048 fs = opOK;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002049 }
2050
2051 return fs;
2052}
2053
2054/* Convert a floating point number to an integer according to the
2055 rounding mode. If the rounded integer value is out of range this
Neil Booth618d0fc2007-11-01 22:43:37 +00002056 returns an invalid operation exception and the contents of the
2057 destination parts are unspecified. If the rounded value is in
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002058 range but the floating point number is not the exact integer, the C
2059 standard doesn't require an inexact exception to be raised. IEEE
2060 854 does require it so we do that.
2061
2062 Note that for conversions to integer type the C standard requires
2063 round-to-zero to always be used. */
2064APFloat::opStatus
Neil Booth618d0fc2007-11-01 22:43:37 +00002065APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
2066 bool isSigned,
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002067 roundingMode rounding_mode,
2068 bool *isExact) const
Neil Booth618d0fc2007-11-01 22:43:37 +00002069{
2070 lostFraction lost_fraction;
2071 const integerPart *src;
2072 unsigned int dstPartsCount, truncatedBits;
2073
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002074 *isExact = false;
2075
Neil Booth618d0fc2007-11-01 22:43:37 +00002076 /* Handle the three special cases first. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002077 if (category == fcInfinity || category == fcNaN)
Neil Booth618d0fc2007-11-01 22:43:37 +00002078 return opInvalidOp;
2079
2080 dstPartsCount = partCountForBits(width);
2081
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002082 if (category == fcZero) {
Neil Booth618d0fc2007-11-01 22:43:37 +00002083 APInt::tcSet(parts, 0, dstPartsCount);
Dale Johannesen7221af32008-10-07 00:40:01 +00002084 // Negative zero can't be represented as an int.
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002085 *isExact = !sign;
2086 return opOK;
Neil Booth618d0fc2007-11-01 22:43:37 +00002087 }
2088
2089 src = significandParts();
2090
2091 /* Step 1: place our absolute value, with any fraction truncated, in
2092 the destination. */
2093 if (exponent < 0) {
2094 /* Our absolute value is less than one; truncate everything. */
2095 APInt::tcSet(parts, 0, dstPartsCount);
Dale Johannesen740e9872009-01-19 21:17:05 +00002096 /* For exponent -1 the integer bit represents .5, look at that.
2097 For smaller exponents leftmost truncated bit is 0. */
2098 truncatedBits = semantics->precision -1U - exponent;
Neil Booth618d0fc2007-11-01 22:43:37 +00002099 } else {
2100 /* We want the most significant (exponent + 1) bits; the rest are
2101 truncated. */
2102 unsigned int bits = exponent + 1U;
2103
2104 /* Hopelessly large in magnitude? */
2105 if (bits > width)
2106 return opInvalidOp;
2107
2108 if (bits < semantics->precision) {
2109 /* We truncate (semantics->precision - bits) bits. */
2110 truncatedBits = semantics->precision - bits;
2111 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
2112 } else {
2113 /* We want at least as many bits as are available. */
2114 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
2115 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2116 truncatedBits = 0;
2117 }
2118 }
2119
2120 /* Step 2: work out any lost fraction, and increment the absolute
2121 value if we would round away from zero. */
2122 if (truncatedBits) {
2123 lost_fraction = lostFractionThroughTruncation(src, partCount(),
2124 truncatedBits);
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002125 if (lost_fraction != lfExactlyZero &&
2126 roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
Neil Booth618d0fc2007-11-01 22:43:37 +00002127 if (APInt::tcIncrement(parts, dstPartsCount))
2128 return opInvalidOp; /* Overflow. */
2129 }
2130 } else {
2131 lost_fraction = lfExactlyZero;
2132 }
2133
2134 /* Step 3: check if we fit in the destination. */
2135 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2136
2137 if (sign) {
2138 if (!isSigned) {
2139 /* Negative numbers cannot be represented as unsigned. */
2140 if (omsb != 0)
2141 return opInvalidOp;
2142 } else {
2143 /* It takes omsb bits to represent the unsigned integer value.
2144 We lose a bit for the sign, but care is needed as the
2145 maximally negative integer is a special case. */
2146 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2147 return opInvalidOp;
2148
2149 /* This case can happen because of rounding. */
2150 if (omsb > width)
2151 return opInvalidOp;
2152 }
2153
2154 APInt::tcNegate (parts, dstPartsCount);
2155 } else {
2156 if (omsb >= width + !isSigned)
2157 return opInvalidOp;
2158 }
2159
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002160 if (lost_fraction == lfExactlyZero) {
2161 *isExact = true;
Neil Booth618d0fc2007-11-01 22:43:37 +00002162 return opOK;
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002163 } else
Neil Booth618d0fc2007-11-01 22:43:37 +00002164 return opInexact;
2165}
2166
2167/* Same as convertToSignExtendedInteger, except we provide
2168 deterministic values in case of an invalid operation exception,
2169 namely zero for NaNs and the minimal or maximal value respectively
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002170 for underflow or overflow.
2171 The *isExact output tells whether the result is exact, in the sense
2172 that converting it back to the original floating point type produces
2173 the original value. This is almost equivalent to result==opOK,
2174 except for negative zeroes.
2175*/
Neil Booth618d0fc2007-11-01 22:43:37 +00002176APFloat::opStatus
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002177APFloat::convertToInteger(integerPart *parts, unsigned int width,
Neil Booth9acbf5a2007-09-26 21:33:42 +00002178 bool isSigned,
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002179 roundingMode rounding_mode, bool *isExact) const
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002180{
Neil Booth618d0fc2007-11-01 22:43:37 +00002181 opStatus fs;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002182
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002183 fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
Dale Johannesen4f0bd682008-10-09 23:00:39 +00002184 isExact);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002185
Neil Booth618d0fc2007-11-01 22:43:37 +00002186 if (fs == opInvalidOp) {
2187 unsigned int bits, dstPartsCount;
2188
2189 dstPartsCount = partCountForBits(width);
2190
2191 if (category == fcNaN)
2192 bits = 0;
2193 else if (sign)
2194 bits = isSigned;
2195 else
2196 bits = width - isSigned;
2197
2198 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2199 if (sign && isSigned)
2200 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002201 }
2202
Neil Booth618d0fc2007-11-01 22:43:37 +00002203 return fs;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002204}
2205
Jeffrey Yasskin03b81a22011-07-15 07:04:56 +00002206/* Same as convertToInteger(integerPart*, ...), except the result is returned in
2207 an APSInt, whose initial bit-width and signed-ness are used to determine the
2208 precision of the conversion.
2209 */
2210APFloat::opStatus
2211APFloat::convertToInteger(APSInt &result,
2212 roundingMode rounding_mode, bool *isExact) const
2213{
2214 unsigned bitWidth = result.getBitWidth();
2215 SmallVector<uint64_t, 4> parts(result.getNumWords());
2216 opStatus status = convertToInteger(
2217 parts.data(), bitWidth, result.isSigned(), rounding_mode, isExact);
2218 // Keeps the original signed-ness.
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00002219 result = APInt(bitWidth, parts);
Jeffrey Yasskin03b81a22011-07-15 07:04:56 +00002220 return status;
2221}
2222
Neil Booth6c1c8582007-10-07 12:07:53 +00002223/* Convert an unsigned integer SRC to a floating point number,
2224 rounding according to ROUNDING_MODE. The sign of the floating
2225 point number is not modified. */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002226APFloat::opStatus
Neil Booth6c1c8582007-10-07 12:07:53 +00002227APFloat::convertFromUnsignedParts(const integerPart *src,
2228 unsigned int srcCount,
2229 roundingMode rounding_mode)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002230{
Neil Booth49c6aab2007-10-08 14:39:42 +00002231 unsigned int omsb, precision, dstCount;
Neil Booth6c1c8582007-10-07 12:07:53 +00002232 integerPart *dst;
Neil Booth49c6aab2007-10-08 14:39:42 +00002233 lostFraction lost_fraction;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002234
2235 category = fcNormal;
Neil Booth49c6aab2007-10-08 14:39:42 +00002236 omsb = APInt::tcMSB(src, srcCount) + 1;
Neil Booth6c1c8582007-10-07 12:07:53 +00002237 dst = significandParts();
2238 dstCount = partCount();
Neil Booth49c6aab2007-10-08 14:39:42 +00002239 precision = semantics->precision;
Neil Booth6c1c8582007-10-07 12:07:53 +00002240
Nick Lewyckyf66daac2011-10-03 21:30:08 +00002241 /* We want the most significant PRECISION bits of SRC. There may not
Neil Booth49c6aab2007-10-08 14:39:42 +00002242 be that many; extract what we can. */
2243 if (precision <= omsb) {
2244 exponent = omsb - 1;
Neil Booth6c1c8582007-10-07 12:07:53 +00002245 lost_fraction = lostFractionThroughTruncation(src, srcCount,
Neil Booth49c6aab2007-10-08 14:39:42 +00002246 omsb - precision);
2247 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2248 } else {
2249 exponent = precision - 1;
2250 lost_fraction = lfExactlyZero;
2251 APInt::tcExtract(dst, dstCount, src, omsb, 0);
Neil Booth6c1c8582007-10-07 12:07:53 +00002252 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002253
2254 return normalize(rounding_mode, lost_fraction);
2255}
2256
Dan Gohman35723eb2008-02-29 01:26:11 +00002257APFloat::opStatus
2258APFloat::convertFromAPInt(const APInt &Val,
2259 bool isSigned,
2260 roundingMode rounding_mode)
2261{
2262 unsigned int partCount = Val.getNumWords();
2263 APInt api = Val;
2264
2265 sign = false;
2266 if (isSigned && api.isNegative()) {
2267 sign = true;
2268 api = -api;
2269 }
2270
2271 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2272}
2273
Neil Booth03f58ab2007-10-07 12:15:41 +00002274/* Convert a two's complement integer SRC to a floating point number,
2275 rounding according to ROUNDING_MODE. ISSIGNED is true if the
2276 integer is signed, in which case it must be sign-extended. */
2277APFloat::opStatus
2278APFloat::convertFromSignExtendedInteger(const integerPart *src,
2279 unsigned int srcCount,
2280 bool isSigned,
2281 roundingMode rounding_mode)
2282{
2283 opStatus status;
2284
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002285 if (isSigned &&
2286 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
Neil Booth03f58ab2007-10-07 12:15:41 +00002287 integerPart *copy;
2288
2289 /* If we're signed and negative negate a copy. */
2290 sign = true;
2291 copy = new integerPart[srcCount];
2292 APInt::tcAssign(copy, src, srcCount);
2293 APInt::tcNegate(copy, srcCount);
2294 status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
2295 delete [] copy;
2296 } else {
2297 sign = false;
2298 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2299 }
2300
2301 return status;
2302}
2303
Neil Booth5f009732007-10-07 11:45:55 +00002304/* FIXME: should this just take a const APInt reference? */
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002305APFloat::opStatus
Neil Booth5f009732007-10-07 11:45:55 +00002306APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
2307 unsigned int width, bool isSigned,
2308 roundingMode rounding_mode)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002309{
Dale Johannesen42305122007-09-21 22:09:37 +00002310 unsigned int partCount = partCountForBits(width);
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00002311 APInt api = APInt(width, makeArrayRef(parts, partCount));
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002312
2313 sign = false;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002314 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
Dale Johannesen28a2c4a2007-09-30 18:17:01 +00002315 sign = true;
2316 api = -api;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002317 }
2318
Neil Boothba205222007-10-07 12:10:57 +00002319 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002320}
2321
2322APFloat::opStatus
Benjamin Kramer92d89982010-07-14 22:38:02 +00002323APFloat::convertFromHexadecimalString(StringRef s, roundingMode rounding_mode)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002324{
Erick Tryzelaara9680df2009-08-18 18:20:37 +00002325 lostFraction lost_fraction = lfExactlyZero;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002326
Michael Gottesman30a90eb2013-07-27 21:49:21 +00002327 category = fcNormal;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002328 zeroSignificand();
2329 exponent = 0;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002330
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002331 integerPart *significand = significandParts();
2332 unsigned partsCount = partCount();
2333 unsigned bitPos = partsCount * integerPartWidth;
2334 bool computedTrailingFraction = false;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002335
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002336 // Skip leading zeroes and any (hexa)decimal point.
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002337 StringRef::iterator begin = s.begin();
2338 StringRef::iterator end = s.end();
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002339 StringRef::iterator dot;
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002340 StringRef::iterator p = skipLeadingZeroesAndAnyDot(begin, end, &dot);
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002341 StringRef::iterator firstSignificantDigit = p;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002342
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002343 while (p != end) {
Dale Johannesenfa483722008-05-14 22:53:25 +00002344 integerPart hex_value;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002345
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002346 if (*p == '.') {
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002347 assert(dot == end && "String contains multiple dots");
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002348 dot = p++;
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002349 continue;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002350 }
2351
2352 hex_value = hexDigitValue(*p);
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002353 if (hex_value == -1U)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002354 break;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002355
2356 p++;
2357
Eli Friedmand2eb07a2013-07-17 22:17:29 +00002358 // Store the number while we have space.
2359 if (bitPos) {
2360 bitPos -= 4;
2361 hex_value <<= bitPos % integerPartWidth;
2362 significand[bitPos / integerPartWidth] |= hex_value;
2363 } else if (!computedTrailingFraction) {
2364 lost_fraction = trailingHexadecimalFraction(p, end, hex_value);
2365 computedTrailingFraction = true;
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002366 }
2367 }
2368
2369 /* Hex floats require an exponent but not a hexadecimal point. */
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002370 assert(p != end && "Hex strings require an exponent");
2371 assert((*p == 'p' || *p == 'P') && "Invalid character in significand");
2372 assert(p != begin && "Significand has no digits");
2373 assert((dot == end || p - begin != 1) && "Significand has no digits");
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002374
2375 /* Ignore the exponent if we are zero. */
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002376 if (p != firstSignificantDigit) {
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002377 int expAdjustment;
2378
2379 /* Implicit hexadecimal point? */
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002380 if (dot == end)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002381 dot = p;
2382
2383 /* Calculate the exponent adjustment implicit in the number of
2384 significant digits. */
Evan Cheng82b9e962008-05-02 21:15:08 +00002385 expAdjustment = static_cast<int>(dot - firstSignificantDigit);
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002386 if (expAdjustment < 0)
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002387 expAdjustment++;
2388 expAdjustment = expAdjustment * 4 - 1;
2389
2390 /* Adjust for writing the significand starting at the most
2391 significant nibble. */
2392 expAdjustment += semantics->precision;
2393 expAdjustment -= partsCount * integerPartWidth;
2394
2395 /* Adjust for the given exponent. */
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002396 exponent = totalExponent(p + 1, end, expAdjustment);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002397 }
2398
2399 return normalize(rounding_mode, lost_fraction);
2400}
2401
2402APFloat::opStatus
Neil Boothb93d90e2007-10-12 16:02:31 +00002403APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
2404 unsigned sigPartCount, int exp,
2405 roundingMode rounding_mode)
2406{
2407 unsigned int parts, pow5PartCount;
Ulrich Weigand908c9362012-10-29 18:18:44 +00002408 fltSemantics calcSemantics = { 32767, -32767, 0 };
Neil Boothb93d90e2007-10-12 16:02:31 +00002409 integerPart pow5Parts[maxPowerOfFiveParts];
2410 bool isNearest;
2411
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002412 isNearest = (rounding_mode == rmNearestTiesToEven ||
2413 rounding_mode == rmNearestTiesToAway);
Neil Boothb93d90e2007-10-12 16:02:31 +00002414
2415 parts = partCountForBits(semantics->precision + 11);
2416
2417 /* Calculate pow(5, abs(exp)). */
2418 pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2419
2420 for (;; parts *= 2) {
2421 opStatus sigStatus, powStatus;
2422 unsigned int excessPrecision, truncatedBits;
2423
2424 calcSemantics.precision = parts * integerPartWidth - 1;
2425 excessPrecision = calcSemantics.precision - semantics->precision;
2426 truncatedBits = excessPrecision;
2427
Michael Gottesman79b09672013-06-27 21:58:19 +00002428 APFloat decSig = APFloat::getZero(calcSemantics, sign);
2429 APFloat pow5(calcSemantics);
Neil Boothb93d90e2007-10-12 16:02:31 +00002430
2431 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2432 rmNearestTiesToEven);
2433 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2434 rmNearestTiesToEven);
2435 /* Add exp, as 10^n = 5^n * 2^n. */
2436 decSig.exponent += exp;
2437
2438 lostFraction calcLostFraction;
Evan Cheng82b9e962008-05-02 21:15:08 +00002439 integerPart HUerr, HUdistance;
2440 unsigned int powHUerr;
Neil Boothb93d90e2007-10-12 16:02:31 +00002441
2442 if (exp >= 0) {
2443 /* multiplySignificand leaves the precision-th bit set to 1. */
Craig Topperc10719f2014-04-07 04:17:22 +00002444 calcLostFraction = decSig.multiplySignificand(pow5, nullptr);
Neil Boothb93d90e2007-10-12 16:02:31 +00002445 powHUerr = powStatus != opOK;
2446 } else {
2447 calcLostFraction = decSig.divideSignificand(pow5);
2448 /* Denormal numbers have less precision. */
2449 if (decSig.exponent < semantics->minExponent) {
2450 excessPrecision += (semantics->minExponent - decSig.exponent);
2451 truncatedBits = excessPrecision;
2452 if (excessPrecision > calcSemantics.precision)
2453 excessPrecision = calcSemantics.precision;
2454 }
2455 /* Extra half-ulp lost in reciprocal of exponent. */
Evan Cheng82b9e962008-05-02 21:15:08 +00002456 powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
Neil Boothb93d90e2007-10-12 16:02:31 +00002457 }
2458
2459 /* Both multiplySignificand and divideSignificand return the
2460 result with the integer bit set. */
Evan Cheng67c90212009-10-27 21:35:42 +00002461 assert(APInt::tcExtractBit
2462 (decSig.significandParts(), calcSemantics.precision - 1) == 1);
Neil Boothb93d90e2007-10-12 16:02:31 +00002463
2464 HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
2465 powHUerr);
2466 HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
2467 excessPrecision, isNearest);
2468
2469 /* Are we guaranteed to round correctly if we truncate? */
2470 if (HUdistance >= HUerr) {
2471 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2472 calcSemantics.precision - excessPrecision,
2473 excessPrecision);
2474 /* Take the exponent of decSig. If we tcExtract-ed less bits
2475 above we must adjust our exponent to compensate for the
2476 implicit right shift. */
2477 exponent = (decSig.exponent + semantics->precision
2478 - (calcSemantics.precision - excessPrecision));
2479 calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
2480 decSig.partCount(),
2481 truncatedBits);
2482 return normalize(rounding_mode, calcLostFraction);
2483 }
2484 }
2485}
2486
2487APFloat::opStatus
Benjamin Kramer92d89982010-07-14 22:38:02 +00002488APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
Neil Boothb93d90e2007-10-12 16:02:31 +00002489{
Neil Booth4ed401b2007-10-14 10:16:12 +00002490 decimalInfo D;
Neil Boothb93d90e2007-10-12 16:02:31 +00002491 opStatus fs;
2492
Neil Booth4ed401b2007-10-14 10:16:12 +00002493 /* Scan the text. */
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002494 StringRef::iterator p = str.begin();
2495 interpretDecimal(p, str.end(), &D);
Neil Boothb93d90e2007-10-12 16:02:31 +00002496
Neil Booth91305512007-10-15 15:00:55 +00002497 /* Handle the quick cases. First the case of no significant digits,
2498 i.e. zero, and then exponents that are obviously too large or too
2499 small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
2500 definitely overflows if
2501
2502 (exp - 1) * L >= maxExponent
2503
2504 and definitely underflows to zero where
2505
2506 (exp + 1) * L <= minExponent - precision
2507
2508 With integer arithmetic the tightest bounds for L are
2509
2510 93/28 < L < 196/59 [ numerator <= 256 ]
2511 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
2512 */
2513
Michael Gottesman228156c2013-07-01 23:54:08 +00002514 // Test if we have a zero number allowing for strings with no null terminators
2515 // and zero decimals with non-zero exponents.
2516 //
2517 // We computed firstSigDigit by ignoring all zeros and dots. Thus if
2518 // D->firstSigDigit equals str.end(), every digit must be a zero and there can
2519 // be at most one dot. On the other hand, if we have a zero with a non-zero
2520 // exponent, then we know that D.firstSigDigit will be non-numeric.
Michael Gottesman94d61952013-07-02 15:50:05 +00002521 if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
Neil Boothb93d90e2007-10-12 16:02:31 +00002522 category = fcZero;
2523 fs = opOK;
John McCallb42cc682010-02-26 22:20:41 +00002524
2525 /* Check whether the normalized exponent is high enough to overflow
2526 max during the log-rebasing in the max-exponent check below. */
2527 } else if (D.normalizedExponent - 1 > INT_MAX / 42039) {
2528 fs = handleOverflow(rounding_mode);
2529
2530 /* If it wasn't, then it also wasn't high enough to overflow max
2531 during the log-rebasing in the min-exponent check. Check that it
2532 won't overflow min in either check, then perform the min-exponent
2533 check. */
2534 } else if (D.normalizedExponent - 1 < INT_MIN / 42039 ||
2535 (D.normalizedExponent + 1) * 28738 <=
2536 8651 * (semantics->minExponent - (int) semantics->precision)) {
Neil Booth91305512007-10-15 15:00:55 +00002537 /* Underflow to zero and round. */
Michael Gottesman30a90eb2013-07-27 21:49:21 +00002538 category = fcNormal;
Neil Booth91305512007-10-15 15:00:55 +00002539 zeroSignificand();
2540 fs = normalize(rounding_mode, lfLessThanHalf);
John McCallb42cc682010-02-26 22:20:41 +00002541
2542 /* We can finally safely perform the max-exponent check. */
Neil Booth91305512007-10-15 15:00:55 +00002543 } else if ((D.normalizedExponent - 1) * 42039
2544 >= 12655 * semantics->maxExponent) {
2545 /* Overflow and round. */
2546 fs = handleOverflow(rounding_mode);
Neil Boothb93d90e2007-10-12 16:02:31 +00002547 } else {
Neil Booth4ed401b2007-10-14 10:16:12 +00002548 integerPart *decSignificand;
2549 unsigned int partCount;
Neil Boothb93d90e2007-10-12 16:02:31 +00002550
Neil Booth4ed401b2007-10-14 10:16:12 +00002551 /* A tight upper bound on number of bits required to hold an
Neil Booth91305512007-10-15 15:00:55 +00002552 N-digit decimal integer is N * 196 / 59. Allocate enough space
Neil Booth4ed401b2007-10-14 10:16:12 +00002553 to hold the full significand, and an extra part required by
2554 tcMultiplyPart. */
Evan Cheng82b9e962008-05-02 21:15:08 +00002555 partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
Neil Booth91305512007-10-15 15:00:55 +00002556 partCount = partCountForBits(1 + 196 * partCount / 59);
Neil Booth4ed401b2007-10-14 10:16:12 +00002557 decSignificand = new integerPart[partCount + 1];
2558 partCount = 0;
Neil Boothb93d90e2007-10-12 16:02:31 +00002559
Neil Booth4ed401b2007-10-14 10:16:12 +00002560 /* Convert to binary efficiently - we do almost all multiplication
2561 in an integerPart. When this would overflow do we do a single
2562 bignum multiplication, and then revert again to multiplication
2563 in an integerPart. */
2564 do {
2565 integerPart decValue, val, multiplier;
2566
2567 val = 0;
2568 multiplier = 1;
2569
2570 do {
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002571 if (*p == '.') {
Neil Booth4ed401b2007-10-14 10:16:12 +00002572 p++;
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002573 if (p == str.end()) {
2574 break;
2575 }
2576 }
Neil Booth4ed401b2007-10-14 10:16:12 +00002577 decValue = decDigitValue(*p++);
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002578 assert(decValue < 10U && "Invalid character in significand");
Neil Booth4ed401b2007-10-14 10:16:12 +00002579 multiplier *= 10;
2580 val = val * 10 + decValue;
2581 /* The maximum number that can be multiplied by ten with any
2582 digit added without overflowing an integerPart. */
2583 } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
2584
2585 /* Multiply out the current part. */
2586 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2587 partCount, partCount + 1, false);
2588
2589 /* If we used another part (likely but not guaranteed), increase
2590 the count. */
2591 if (decSignificand[partCount])
2592 partCount++;
2593 } while (p <= D.lastSigDigit);
Neil Boothb93d90e2007-10-12 16:02:31 +00002594
Neil Boothae077d22007-11-01 22:51:07 +00002595 category = fcNormal;
Neil Boothb93d90e2007-10-12 16:02:31 +00002596 fs = roundSignificandWithExponent(decSignificand, partCount,
Neil Booth4ed401b2007-10-14 10:16:12 +00002597 D.exponent, rounding_mode);
Neil Boothb93d90e2007-10-12 16:02:31 +00002598
Neil Booth4ed401b2007-10-14 10:16:12 +00002599 delete [] decSignificand;
2600 }
Neil Boothb93d90e2007-10-12 16:02:31 +00002601
2602 return fs;
2603}
2604
Michael Gottesman40e8a182013-06-24 09:58:05 +00002605bool
2606APFloat::convertFromStringSpecials(StringRef str) {
2607 if (str.equals("inf") || str.equals("INFINITY")) {
2608 makeInf(false);
2609 return true;
2610 }
2611
2612 if (str.equals("-inf") || str.equals("-INFINITY")) {
2613 makeInf(true);
2614 return true;
2615 }
2616
2617 if (str.equals("nan") || str.equals("NaN")) {
2618 makeNaN(false, false);
2619 return true;
2620 }
2621
2622 if (str.equals("-nan") || str.equals("-NaN")) {
2623 makeNaN(false, true);
2624 return true;
2625 }
2626
2627 return false;
2628}
2629
Neil Boothb93d90e2007-10-12 16:02:31 +00002630APFloat::opStatus
Benjamin Kramer92d89982010-07-14 22:38:02 +00002631APFloat::convertFromString(StringRef str, roundingMode rounding_mode)
Neil Booth9acbf5a2007-09-26 21:33:42 +00002632{
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002633 assert(!str.empty() && "Invalid string length");
Neil Booth06077e72007-10-14 10:29:28 +00002634
Michael Gottesman40e8a182013-06-24 09:58:05 +00002635 // Handle special cases.
2636 if (convertFromStringSpecials(str))
2637 return opOK;
2638
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002639 /* Handle a leading minus sign. */
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002640 StringRef::iterator p = str.begin();
2641 size_t slen = str.size();
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002642 sign = *p == '-' ? 1 : 0;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002643 if (*p == '-' || *p == '+') {
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002644 p++;
2645 slen--;
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002646 assert(slen && "String has no digits");
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002647 }
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002648
Dan Gohmanb452d4e2010-03-24 19:38:02 +00002649 if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002650 assert(slen - 2 && "Invalid string");
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002651 return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
Erick Tryzelaar19f63b22009-08-16 23:36:19 +00002652 rounding_mode);
2653 }
Bill Wendlingc6075402008-11-27 08:00:12 +00002654
Erick Tryzelaarda666c82009-08-20 23:30:43 +00002655 return convertFromDecimalString(StringRef(p, slen), rounding_mode);
Chris Lattnerfe02c1f2007-08-20 22:49:32 +00002656}
Dale Johannesena719a602007-08-24 00:56:33 +00002657
Neil Booth8f1946f2007-10-03 22:26:02 +00002658/* Write out a hexadecimal representation of the floating point value
2659 to DST, which must be of sufficient size, in the C99 form
2660 [-]0xh.hhhhp[+-]d. Return the number of characters written,
2661 excluding the terminating NUL.
2662
2663 If UPPERCASE, the output is in upper case, otherwise in lower case.
2664
2665 HEXDIGITS digits appear altogether, rounding the value if
2666 necessary. If HEXDIGITS is 0, the minimal precision to display the
2667 number precisely is used instead. If nothing would appear after
2668 the decimal point it is suppressed.
2669
2670 The decimal exponent is always printed and has at least one digit.
2671 Zero values display an exponent of zero. Infinities and NaNs
2672 appear as "infinity" or "nan" respectively.
2673
2674 The above rules are as specified by C99. There is ambiguity about
2675 what the leading hexadecimal digit should be. This implementation
2676 uses whatever is necessary so that the exponent is displayed as
2677 stored. This implies the exponent will fall within the IEEE format
2678 range, and the leading hexadecimal digit will be 0 (for denormals),
2679 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
2680 any other digits zero).
2681*/
2682unsigned int
2683APFloat::convertToHexString(char *dst, unsigned int hexDigits,
2684 bool upperCase, roundingMode rounding_mode) const
2685{
2686 char *p;
2687
2688 p = dst;
2689 if (sign)
2690 *dst++ = '-';
2691
2692 switch (category) {
2693 case fcInfinity:
2694 memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
2695 dst += sizeof infinityL - 1;
2696 break;
2697
2698 case fcNaN:
2699 memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
2700 dst += sizeof NaNU - 1;
2701 break;
2702
2703 case fcZero:
2704 *dst++ = '0';
2705 *dst++ = upperCase ? 'X': 'x';
2706 *dst++ = '0';
2707 if (hexDigits > 1) {
2708 *dst++ = '.';
2709 memset (dst, '0', hexDigits - 1);
2710 dst += hexDigits - 1;
2711 }
2712 *dst++ = upperCase ? 'P': 'p';
2713 *dst++ = '0';
2714 break;
2715
2716 case fcNormal:
2717 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
2718 break;
2719 }
2720
2721 *dst = 0;
2722
Evan Cheng82b9e962008-05-02 21:15:08 +00002723 return static_cast<unsigned int>(dst - p);
Neil Booth8f1946f2007-10-03 22:26:02 +00002724}
2725
2726/* Does the hard work of outputting the correctly rounded hexadecimal
2727 form of a normal floating point number with the specified number of
2728 hexadecimal digits. If HEXDIGITS is zero the minimum number of
2729 digits necessary to print the value precisely is output. */
2730char *
2731APFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
2732 bool upperCase,
2733 roundingMode rounding_mode) const
2734{
2735 unsigned int count, valueBits, shift, partsCount, outputDigits;
2736 const char *hexDigitChars;
2737 const integerPart *significand;
2738 char *p;
2739 bool roundUp;
2740
2741 *dst++ = '0';
2742 *dst++ = upperCase ? 'X': 'x';
2743
2744 roundUp = false;
2745 hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;
2746
2747 significand = significandParts();
2748 partsCount = partCount();
2749
2750 /* +3 because the first digit only uses the single integer bit, so
2751 we have 3 virtual zero most-significant-bits. */
2752 valueBits = semantics->precision + 3;
2753 shift = integerPartWidth - valueBits % integerPartWidth;
2754
2755 /* The natural number of digits required ignoring trailing
2756 insignificant zeroes. */
2757 outputDigits = (valueBits - significandLSB () + 3) / 4;
2758
2759 /* hexDigits of zero means use the required number for the
2760 precision. Otherwise, see if we are truncating. If we are,
Neil Booth0ea72a92007-10-06 00:24:48 +00002761 find out if we need to round away from zero. */
Neil Booth8f1946f2007-10-03 22:26:02 +00002762 if (hexDigits) {
2763 if (hexDigits < outputDigits) {
2764 /* We are dropping non-zero bits, so need to check how to round.
2765 "bits" is the number of dropped bits. */
2766 unsigned int bits;
2767 lostFraction fraction;
2768
2769 bits = valueBits - hexDigits * 4;
2770 fraction = lostFractionThroughTruncation (significand, partsCount, bits);
2771 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
2772 }
2773 outputDigits = hexDigits;
2774 }
2775
2776 /* Write the digits consecutively, and start writing in the location
2777 of the hexadecimal point. We move the most significant digit
2778 left and add the hexadecimal point later. */
2779 p = ++dst;
2780
2781 count = (valueBits + integerPartWidth - 1) / integerPartWidth;
2782
2783 while (outputDigits && count) {
2784 integerPart part;
2785
2786 /* Put the most significant integerPartWidth bits in "part". */
2787 if (--count == partsCount)
2788 part = 0; /* An imaginary higher zero part. */
2789 else
2790 part = significand[count] << shift;
2791
2792 if (count && shift)
2793 part |= significand[count - 1] >> (integerPartWidth - shift);
2794
2795 /* Convert as much of "part" to hexdigits as we can. */
2796 unsigned int curDigits = integerPartWidth / 4;
2797
2798 if (curDigits > outputDigits)
2799 curDigits = outputDigits;
2800 dst += partAsHex (dst, part, curDigits, hexDigitChars);
2801 outputDigits -= curDigits;
2802 }
2803
2804 if (roundUp) {
2805 char *q = dst;
2806
2807 /* Note that hexDigitChars has a trailing '0'. */
2808 do {
2809 q--;
2810 *q = hexDigitChars[hexDigitValue (*q) + 1];
Neil Booth0ea72a92007-10-06 00:24:48 +00002811 } while (*q == '0');
Evan Cheng67c90212009-10-27 21:35:42 +00002812 assert(q >= p);
Neil Booth8f1946f2007-10-03 22:26:02 +00002813 } else {
2814 /* Add trailing zeroes. */
2815 memset (dst, '0', outputDigits);
2816 dst += outputDigits;
2817 }
2818
2819 /* Move the most significant digit to before the point, and if there
2820 is something after the decimal point add it. This must come
2821 after rounding above. */
2822 p[-1] = p[0];
2823 if (dst -1 == p)
2824 dst--;
2825 else
2826 p[0] = '.';
2827
2828 /* Finally output the exponent. */
2829 *dst++ = upperCase ? 'P': 'p';
2830
Neil Booth32897f52007-10-06 07:29:25 +00002831 return writeSignedDecimal (dst, exponent);
Neil Booth8f1946f2007-10-03 22:26:02 +00002832}
2833
Chandler Carruth71bd7d12012-03-04 12:02:57 +00002834hash_code llvm::hash_value(const APFloat &Arg) {
Michael Gottesman8136c382013-06-26 23:17:28 +00002835 if (!Arg.isFiniteNonZero())
Chandler Carruth71bd7d12012-03-04 12:02:57 +00002836 return hash_combine((uint8_t)Arg.category,
2837 // NaN has no sign, fix it at zero.
2838 Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
2839 Arg.semantics->precision);
2840
2841 // Normal floats need their exponent and significand hashed.
2842 return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
2843 Arg.semantics->precision, Arg.exponent,
2844 hash_combine_range(
2845 Arg.significandParts(),
2846 Arg.significandParts() + Arg.partCount()));
Dale Johannesena719a602007-08-24 00:56:33 +00002847}
2848
2849// Conversion from APFloat to/from host float/double. It may eventually be
2850// possible to eliminate these and have everybody deal with APFloats, but that
2851// will take a while. This approach will not easily extend to long double.
Dale Johannesen146a0ea2007-09-20 23:47:58 +00002852// Current implementation requires integerPartWidth==64, which is correct at
2853// the moment but could be made more general.
Dale Johannesena719a602007-08-24 00:56:33 +00002854
Dale Johannesen728687c2007-09-05 20:39:49 +00002855// Denormals have exponent minExponent in APFloat, but minExponent-1 in
Dale Johannesen146a0ea2007-09-20 23:47:58 +00002856// the actual IEEE respresentations. We compensate for that here.
Dale Johannesen728687c2007-09-05 20:39:49 +00002857
Dale Johannesen245dceb2007-09-11 18:32:33 +00002858APInt
Neil Booth9acbf5a2007-09-26 21:33:42 +00002859APFloat::convertF80LongDoubleAPFloatToAPInt() const
2860{
Dan Gohmanb456a152008-01-29 12:08:20 +00002861 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
Evan Cheng67c90212009-10-27 21:35:42 +00002862 assert(partCount()==2);
Dale Johannesen245dceb2007-09-11 18:32:33 +00002863
2864 uint64_t myexponent, mysignificand;
2865
Michael Gottesman8136c382013-06-26 23:17:28 +00002866 if (isFiniteNonZero()) {
Dale Johannesen245dceb2007-09-11 18:32:33 +00002867 myexponent = exponent+16383; //bias
Dale Johannesen146a0ea2007-09-20 23:47:58 +00002868 mysignificand = significandParts()[0];
Dale Johannesen245dceb2007-09-11 18:32:33 +00002869 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
2870 myexponent = 0; // denormal
2871 } else if (category==fcZero) {
2872 myexponent = 0;
2873 mysignificand = 0;
2874 } else if (category==fcInfinity) {
2875 myexponent = 0x7fff;
2876 mysignificand = 0x8000000000000000ULL;
Chris Lattner2a9bcb92007-10-06 06:13:42 +00002877 } else {
2878 assert(category == fcNaN && "Unknown category");
Dale Johannesen245dceb2007-09-11 18:32:33 +00002879 myexponent = 0x7fff;
Dale Johannesen146a0ea2007-09-20 23:47:58 +00002880 mysignificand = significandParts()[0];
Chris Lattner2a9bcb92007-10-06 06:13:42 +00002881 }
Dale Johannesen245dceb2007-09-11 18:32:33 +00002882
2883 uint64_t words[2];
Dale Johannesen93eefa02009-03-23 21:16:53 +00002884 words[0] = mysignificand;
2885 words[1] = ((uint64_t)(sign & 1) << 15) |
2886 (myexponent & 0x7fffLL);
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00002887 return APInt(80, words);
Dale Johannesen245dceb2007-09-11 18:32:33 +00002888}
2889
2890APInt
Dale Johannesen007aa372007-10-11 18:07:22 +00002891APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
2892{
Dan Gohmanb456a152008-01-29 12:08:20 +00002893 assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
Evan Cheng67c90212009-10-27 21:35:42 +00002894 assert(partCount()==2);
Dale Johannesen007aa372007-10-11 18:07:22 +00002895
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002896 uint64_t words[2];
2897 opStatus fs;
2898 bool losesInfo;
Dale Johannesen007aa372007-10-11 18:07:22 +00002899
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002900 // Convert number to double. To avoid spurious underflows, we re-
2901 // normalize against the "double" minExponent first, and only *then*
2902 // truncate the mantissa. The result of that second conversion
2903 // may be inexact, but should never underflow.
Alexey Samsonov2b431d92012-11-30 22:27:54 +00002904 // Declare fltSemantics before APFloat that uses it (and
2905 // saves pointer to it) to ensure correct destruction order.
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002906 fltSemantics extendedSemantics = *semantics;
2907 extendedSemantics.minExponent = IEEEdouble.minExponent;
Alexey Samsonov2b431d92012-11-30 22:27:54 +00002908 APFloat extended(*this);
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002909 fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2910 assert(fs == opOK && !losesInfo);
2911 (void)fs;
2912
2913 APFloat u(extended);
2914 fs = u.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2915 assert(fs == opOK || fs == opInexact);
2916 (void)fs;
2917 words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
2918
2919 // If conversion was exact or resulted in a special case, we're done;
2920 // just set the second double to zero. Otherwise, re-convert back to
2921 // the extended format and compute the difference. This now should
2922 // convert exactly to double.
Michael Gottesman8136c382013-06-26 23:17:28 +00002923 if (u.isFiniteNonZero() && losesInfo) {
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002924 fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2925 assert(fs == opOK && !losesInfo);
2926 (void)fs;
2927
2928 APFloat v(extended);
2929 v.subtract(u, rmNearestTiesToEven);
2930 fs = v.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2931 assert(fs == opOK && !losesInfo);
2932 (void)fs;
2933 words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
Dale Johannesen007aa372007-10-11 18:07:22 +00002934 } else {
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00002935 words[1] = 0;
Dale Johannesen007aa372007-10-11 18:07:22 +00002936 }
2937
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00002938 return APInt(128, words);
Dale Johannesen007aa372007-10-11 18:07:22 +00002939}
2940
2941APInt
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00002942APFloat::convertQuadrupleAPFloatToAPInt() const
2943{
2944 assert(semantics == (const llvm::fltSemantics*)&IEEEquad);
Evan Cheng67c90212009-10-27 21:35:42 +00002945 assert(partCount()==2);
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00002946
2947 uint64_t myexponent, mysignificand, mysignificand2;
2948
Michael Gottesman8136c382013-06-26 23:17:28 +00002949 if (isFiniteNonZero()) {
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00002950 myexponent = exponent+16383; //bias
2951 mysignificand = significandParts()[0];
2952 mysignificand2 = significandParts()[1];
2953 if (myexponent==1 && !(mysignificand2 & 0x1000000000000LL))
2954 myexponent = 0; // denormal
2955 } else if (category==fcZero) {
2956 myexponent = 0;
2957 mysignificand = mysignificand2 = 0;
2958 } else if (category==fcInfinity) {
2959 myexponent = 0x7fff;
2960 mysignificand = mysignificand2 = 0;
2961 } else {
2962 assert(category == fcNaN && "Unknown category!");
2963 myexponent = 0x7fff;
2964 mysignificand = significandParts()[0];
2965 mysignificand2 = significandParts()[1];
2966 }
2967
2968 uint64_t words[2];
2969 words[0] = mysignificand;
2970 words[1] = ((uint64_t)(sign & 1) << 63) |
2971 ((myexponent & 0x7fff) << 48) |
Anton Korobeynikov876955c2009-08-21 23:09:47 +00002972 (mysignificand2 & 0xffffffffffffLL);
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00002973
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00002974 return APInt(128, words);
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00002975}
2976
2977APInt
Neil Booth9acbf5a2007-09-26 21:33:42 +00002978APFloat::convertDoubleAPFloatToAPInt() const
2979{
Dan Gohman58c468f2007-09-14 20:08:19 +00002980 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
Evan Cheng67c90212009-10-27 21:35:42 +00002981 assert(partCount()==1);
Dale Johannesena719a602007-08-24 00:56:33 +00002982
Dale Johannesen3cf889f2007-08-31 04:03:46 +00002983 uint64_t myexponent, mysignificand;
Dale Johannesena719a602007-08-24 00:56:33 +00002984
Michael Gottesman8136c382013-06-26 23:17:28 +00002985 if (isFiniteNonZero()) {
Dale Johannesena719a602007-08-24 00:56:33 +00002986 myexponent = exponent+1023; //bias
Dale Johannesen728687c2007-09-05 20:39:49 +00002987 mysignificand = *significandParts();
2988 if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2989 myexponent = 0; // denormal
Dale Johannesena719a602007-08-24 00:56:33 +00002990 } else if (category==fcZero) {
Dale Johannesena719a602007-08-24 00:56:33 +00002991 myexponent = 0;
2992 mysignificand = 0;
2993 } else if (category==fcInfinity) {
Dale Johannesena719a602007-08-24 00:56:33 +00002994 myexponent = 0x7ff;
2995 mysignificand = 0;
Chris Lattner2a9bcb92007-10-06 06:13:42 +00002996 } else {
2997 assert(category == fcNaN && "Unknown category!");
Dale Johannesena719a602007-08-24 00:56:33 +00002998 myexponent = 0x7ff;
Dale Johannesen3cf889f2007-08-31 04:03:46 +00002999 mysignificand = *significandParts();
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003000 }
Dale Johannesena719a602007-08-24 00:56:33 +00003001
Evan Cheng82b9e962008-05-02 21:15:08 +00003002 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003003 ((myexponent & 0x7ff) << 52) |
3004 (mysignificand & 0xfffffffffffffLL))));
Dale Johannesena719a602007-08-24 00:56:33 +00003005}
3006
Dale Johannesen245dceb2007-09-11 18:32:33 +00003007APInt
Neil Booth9acbf5a2007-09-26 21:33:42 +00003008APFloat::convertFloatAPFloatToAPInt() const
3009{
Dan Gohman58c468f2007-09-14 20:08:19 +00003010 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
Evan Cheng67c90212009-10-27 21:35:42 +00003011 assert(partCount()==1);
Neil Booth9acbf5a2007-09-26 21:33:42 +00003012
Dale Johannesen3cf889f2007-08-31 04:03:46 +00003013 uint32_t myexponent, mysignificand;
Dale Johannesena719a602007-08-24 00:56:33 +00003014
Michael Gottesman8136c382013-06-26 23:17:28 +00003015 if (isFiniteNonZero()) {
Dale Johannesena719a602007-08-24 00:56:33 +00003016 myexponent = exponent+127; //bias
Evan Cheng82b9e962008-05-02 21:15:08 +00003017 mysignificand = (uint32_t)*significandParts();
Dale Johannesen06a10df2007-11-17 01:02:27 +00003018 if (myexponent == 1 && !(mysignificand & 0x800000))
Dale Johannesen728687c2007-09-05 20:39:49 +00003019 myexponent = 0; // denormal
Dale Johannesena719a602007-08-24 00:56:33 +00003020 } else if (category==fcZero) {
Dale Johannesena719a602007-08-24 00:56:33 +00003021 myexponent = 0;
3022 mysignificand = 0;
3023 } else if (category==fcInfinity) {
Dale Johannesena719a602007-08-24 00:56:33 +00003024 myexponent = 0xff;
3025 mysignificand = 0;
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003026 } else {
3027 assert(category == fcNaN && "Unknown category!");
Dale Johannesen728687c2007-09-05 20:39:49 +00003028 myexponent = 0xff;
Evan Cheng82b9e962008-05-02 21:15:08 +00003029 mysignificand = (uint32_t)*significandParts();
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003030 }
Dale Johannesena719a602007-08-24 00:56:33 +00003031
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003032 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
3033 (mysignificand & 0x7fffff)));
Dale Johannesena719a602007-08-24 00:56:33 +00003034}
3035
Chris Lattner4794b2b2009-10-16 02:13:51 +00003036APInt
3037APFloat::convertHalfAPFloatToAPInt() const
3038{
3039 assert(semantics == (const llvm::fltSemantics*)&IEEEhalf);
Evan Cheng67c90212009-10-27 21:35:42 +00003040 assert(partCount()==1);
Chris Lattner4794b2b2009-10-16 02:13:51 +00003041
3042 uint32_t myexponent, mysignificand;
3043
Michael Gottesman8136c382013-06-26 23:17:28 +00003044 if (isFiniteNonZero()) {
Chris Lattner4794b2b2009-10-16 02:13:51 +00003045 myexponent = exponent+15; //bias
3046 mysignificand = (uint32_t)*significandParts();
3047 if (myexponent == 1 && !(mysignificand & 0x400))
3048 myexponent = 0; // denormal
3049 } else if (category==fcZero) {
3050 myexponent = 0;
3051 mysignificand = 0;
3052 } else if (category==fcInfinity) {
Dale Johannesen0d670b52009-10-23 04:02:51 +00003053 myexponent = 0x1f;
Chris Lattner4794b2b2009-10-16 02:13:51 +00003054 mysignificand = 0;
3055 } else {
3056 assert(category == fcNaN && "Unknown category!");
Dale Johannesen0d670b52009-10-23 04:02:51 +00003057 myexponent = 0x1f;
Chris Lattner4794b2b2009-10-16 02:13:51 +00003058 mysignificand = (uint32_t)*significandParts();
3059 }
3060
3061 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
3062 (mysignificand & 0x3ff)));
3063}
3064
Dale Johannesen007aa372007-10-11 18:07:22 +00003065// This function creates an APInt that is just a bit map of the floating
3066// point constant as it would appear in memory. It is not a conversion,
3067// and treating the result as a normal integer is unlikely to be useful.
3068
Dale Johannesen245dceb2007-09-11 18:32:33 +00003069APInt
Dale Johannesen54306fe2008-10-09 18:53:47 +00003070APFloat::bitcastToAPInt() const
Neil Booth9acbf5a2007-09-26 21:33:42 +00003071{
Chris Lattner4794b2b2009-10-16 02:13:51 +00003072 if (semantics == (const llvm::fltSemantics*)&IEEEhalf)
3073 return convertHalfAPFloatToAPInt();
3074
Dan Gohmanb456a152008-01-29 12:08:20 +00003075 if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
Dale Johannesen245dceb2007-09-11 18:32:33 +00003076 return convertFloatAPFloatToAPInt();
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00003077
Dan Gohmanb456a152008-01-29 12:08:20 +00003078 if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
Dale Johannesen245dceb2007-09-11 18:32:33 +00003079 return convertDoubleAPFloatToAPInt();
Neil Booth9acbf5a2007-09-26 21:33:42 +00003080
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00003081 if (semantics == (const llvm::fltSemantics*)&IEEEquad)
3082 return convertQuadrupleAPFloatToAPInt();
3083
Dan Gohmanb456a152008-01-29 12:08:20 +00003084 if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
Dale Johannesen007aa372007-10-11 18:07:22 +00003085 return convertPPCDoubleDoubleAPFloatToAPInt();
3086
Dan Gohmanb456a152008-01-29 12:08:20 +00003087 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
Chris Lattner2a9bcb92007-10-06 06:13:42 +00003088 "unknown format!");
3089 return convertF80LongDoubleAPFloatToAPInt();
Dale Johannesen245dceb2007-09-11 18:32:33 +00003090}
3091
Neil Booth9acbf5a2007-09-26 21:33:42 +00003092float
3093APFloat::convertToFloat() const
3094{
Chris Lattner688f9912009-09-24 21:44:20 +00003095 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle &&
3096 "Float semantics are not IEEEsingle");
Dale Johannesen54306fe2008-10-09 18:53:47 +00003097 APInt api = bitcastToAPInt();
Dale Johannesen245dceb2007-09-11 18:32:33 +00003098 return api.bitsToFloat();
3099}
3100
Neil Booth9acbf5a2007-09-26 21:33:42 +00003101double
3102APFloat::convertToDouble() const
3103{
Chris Lattner688f9912009-09-24 21:44:20 +00003104 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble &&
3105 "Float semantics are not IEEEdouble");
Dale Johannesen54306fe2008-10-09 18:53:47 +00003106 APInt api = bitcastToAPInt();
Dale Johannesen245dceb2007-09-11 18:32:33 +00003107 return api.bitsToDouble();
3108}
3109
Dale Johannesenfff29952008-10-06 18:22:29 +00003110/// Integer bit is explicit in this format. Intel hardware (387 and later)
3111/// does not support these bit patterns:
3112/// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
3113/// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
3114/// exponent = 0, integer bit 1 ("pseudodenormal")
3115/// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
3116/// At the moment, the first two are treated as NaNs, the second two as Normal.
Dale Johannesen245dceb2007-09-11 18:32:33 +00003117void
Neil Booth9acbf5a2007-09-26 21:33:42 +00003118APFloat::initFromF80LongDoubleAPInt(const APInt &api)
3119{
Dale Johannesen245dceb2007-09-11 18:32:33 +00003120 assert(api.getBitWidth()==80);
3121 uint64_t i1 = api.getRawData()[0];
3122 uint64_t i2 = api.getRawData()[1];
Dale Johannesen93eefa02009-03-23 21:16:53 +00003123 uint64_t myexponent = (i2 & 0x7fff);
3124 uint64_t mysignificand = i1;
Dale Johannesen245dceb2007-09-11 18:32:33 +00003125
3126 initialize(&APFloat::x87DoubleExtended);
Dale Johannesen146a0ea2007-09-20 23:47:58 +00003127 assert(partCount()==2);
Dale Johannesen245dceb2007-09-11 18:32:33 +00003128
Dale Johannesen93eefa02009-03-23 21:16:53 +00003129 sign = static_cast<unsigned int>(i2>>15);
Dale Johannesen245dceb2007-09-11 18:32:33 +00003130 if (myexponent==0 && mysignificand==0) {
3131 // exponent, significand meaningless
3132 category = fcZero;
3133 } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3134 // exponent, significand meaningless
3135 category = fcInfinity;
3136 } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
3137 // exponent meaningless
3138 category = fcNaN;
Dale Johannesen146a0ea2007-09-20 23:47:58 +00003139 significandParts()[0] = mysignificand;
3140 significandParts()[1] = 0;
Dale Johannesen245dceb2007-09-11 18:32:33 +00003141 } else {
3142 category = fcNormal;
3143 exponent = myexponent - 16383;
Dale Johannesen146a0ea2007-09-20 23:47:58 +00003144 significandParts()[0] = mysignificand;
3145 significandParts()[1] = 0;
Dale Johannesen245dceb2007-09-11 18:32:33 +00003146 if (myexponent==0) // denormal
3147 exponent = -16382;
Neil Booth9acbf5a2007-09-26 21:33:42 +00003148 }
Dale Johannesen245dceb2007-09-11 18:32:33 +00003149}
3150
3151void
Dale Johannesen007aa372007-10-11 18:07:22 +00003152APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3153{
3154 assert(api.getBitWidth()==128);
3155 uint64_t i1 = api.getRawData()[0];
3156 uint64_t i2 = api.getRawData()[1];
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00003157 opStatus fs;
3158 bool losesInfo;
Dale Johannesen007aa372007-10-11 18:07:22 +00003159
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00003160 // Get the first double and convert to our format.
3161 initFromDoubleAPInt(APInt(64, i1));
3162 fs = convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3163 assert(fs == opOK && !losesInfo);
3164 (void)fs;
Dale Johannesen007aa372007-10-11 18:07:22 +00003165
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00003166 // Unless we have a special case, add in second double.
Michael Gottesman8136c382013-06-26 23:17:28 +00003167 if (isFiniteNonZero()) {
Tim Northover29178a32013-01-22 09:46:31 +00003168 APFloat v(IEEEdouble, APInt(64, i2));
Ulrich Weigandd9f7e252012-10-29 18:09:01 +00003169 fs = v.convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3170 assert(fs == opOK && !losesInfo);
3171 (void)fs;
3172
3173 add(v, rmNearestTiesToEven);
Dale Johannesen007aa372007-10-11 18:07:22 +00003174 }
3175}
3176
3177void
Anton Korobeynikov13e8c7e2009-08-21 22:10:30 +00003178APFloat::initFromQuadrupleAPInt(const APInt &api)
3179{
3180 assert(api.getBitWidth()==128);
3181 uint64_t i1 = api.getRawData()[0];
3182 uint64_t i2 = api.getRawData()[1];
3183 uint64_t myexponent = (i2 >> 48) & 0x7fff;
3184 uint64_t mysignificand = i1;
3185 uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
3186
3187 initialize(&APFloat::IEEEquad);
3188 assert(partCount()==2);
3189
3190 sign = static_cast<unsigned int>(i2>>63);
3191 if (myexponent==0 &&
3192 (mysignificand==0 && mysignificand2==0)) {
3193 // exponent, significand meaningless
3194 category = fcZero;
3195 } else if (myexponent==0x7fff &&
3196 (mysignificand==0 && mysignificand2==0)) {
3197 // exponent, significand meaningless
3198 category = fcInfinity;
3199 } else if (myexponent==0x7fff &&
3200 (mysignificand!=0 || mysignificand2 !=0)) {
3201 // exponent meaningless
3202 category = fcNaN;
3203 significandParts()[0] = mysignificand;
3204 significandParts()[1] = mysignificand2;
3205 } else {
3206 category = fcNormal;
3207 exponent = myexponent - 16383;
3208 significandParts()[0] = mysignificand;
3209 significandParts()[1] = mysignificand2;
3210 if (myexponent==0) // denormal
3211 exponent = -16382;
3212 else
3213 significandParts()[1] |= 0x1000000000000LL; // integer bit
3214 }
3215}
3216
3217void
Neil Booth9acbf5a2007-09-26 21:33:42 +00003218APFloat::initFromDoubleAPInt(const APInt &api)
3219{
Dale Johannesen245dceb2007-09-11 18:32:33 +00003220 assert(api.getBitWidth()==64);
3221 uint64_t i = *api.getRawData();
Dale Johannesen918c33c2007-08-24 05:08:11 +00003222 uint64_t myexponent = (i >> 52) & 0x7ff;
3223 uint64_t mysignificand = i & 0xfffffffffffffLL;
3224
Dale Johannesena719a602007-08-24 00:56:33 +00003225 initialize(&APFloat::IEEEdouble);
Dale Johannesena719a602007-08-24 00:56:33 +00003226 assert(partCount()==1);
3227
Evan Cheng82b9e962008-05-02 21:15:08 +00003228 sign = static_cast<unsigned int>(i>>63);
Dale Johannesena719a602007-08-24 00:56:33 +00003229 if (myexponent==0 && mysignificand==0) {
3230 // exponent, significand meaningless
3231 category = fcZero;
Dale Johannesena719a602007-08-24 00:56:33 +00003232 } else if (myexponent==0x7ff && mysignificand==0) {
3233 // exponent, significand meaningless
3234 category = fcInfinity;
Dale Johannesen3cf889f2007-08-31 04:03:46 +00003235 } else if (myexponent==0x7ff && mysignificand!=0) {
3236 // exponent meaningless
3237 category = fcNaN;
3238 *significandParts() = mysignificand;
Dale Johannesena719a602007-08-24 00:56:33 +00003239 } else {
Dale Johannesena719a602007-08-24 00:56:33 +00003240 category = fcNormal;
3241 exponent = myexponent - 1023;
Dale Johannesen728687c2007-09-05 20:39:49 +00003242 *significandParts() = mysignificand;
3243 if (myexponent==0) // denormal
3244 exponent = -1022;
3245 else
3246 *significandParts() |= 0x10000000000000LL; // integer bit
Neil Booth9acbf5a2007-09-26 21:33:42 +00003247 }
Dale Johannesena719a602007-08-24 00:56:33 +00003248}
3249
Dale Johannesen245dceb2007-09-11 18:32:33 +00003250void
Neil Booth9acbf5a2007-09-26 21:33:42 +00003251APFloat::initFromFloatAPInt(const APInt & api)
3252{
Dale Johannesen245dceb2007-09-11 18:32:33 +00003253 assert(api.getBitWidth()==32);
3254 uint32_t i = (uint32_t)*api.getRawData();
Dale Johannesen918c33c2007-08-24 05:08:11 +00003255 uint32_t myexponent = (i >> 23) & 0xff;
3256 uint32_t mysignificand = i & 0x7fffff;
3257
Dale Johannesena719a602007-08-24 00:56:33 +00003258 initialize(&APFloat::IEEEsingle);
Dale Johannesena719a602007-08-24 00:56:33 +00003259 assert(partCount()==1);
3260
Dale Johannesen3cf889f2007-08-31 04:03:46 +00003261 sign = i >> 31;
Dale Johannesena719a602007-08-24 00:56:33 +00003262 if (myexponent==0 && mysignificand==0) {
3263 // exponent, significand meaningless
3264 category = fcZero;
Dale Johannesena719a602007-08-24 00:56:33 +00003265 } else if (myexponent==0xff && mysignificand==0) {
3266 // exponent, significand meaningless
3267 category = fcInfinity;
Dale Johannesen4f55d9f2007-09-25 17:25:00 +00003268 } else if (myexponent==0xff && mysignificand!=0) {
Dale Johannesena719a602007-08-24 00:56:33 +00003269 // sign, exponent, significand meaningless
Dale Johannesen3cf889f2007-08-31 04:03:46 +00003270 category = fcNaN;
3271 *significandParts() = mysignificand;
Dale Johannesena719a602007-08-24 00:56:33 +00003272 } else {
3273 category = fcNormal;
Dale Johannesena719a602007-08-24 00:56:33 +00003274 exponent = myexponent - 127; //bias
Dale Johannesen728687c2007-09-05 20:39:49 +00003275 *significandParts() = mysignificand;
3276 if (myexponent==0) // denormal
3277 exponent = -126;
3278 else
3279 *significandParts() |= 0x800000; // integer bit
Dale Johannesena719a602007-08-24 00:56:33 +00003280 }
3281}
Dale Johannesen245dceb2007-09-11 18:32:33 +00003282
Chris Lattner4794b2b2009-10-16 02:13:51 +00003283void
3284APFloat::initFromHalfAPInt(const APInt & api)
3285{
3286 assert(api.getBitWidth()==16);
3287 uint32_t i = (uint32_t)*api.getRawData();
Dale Johannesen0d670b52009-10-23 04:02:51 +00003288 uint32_t myexponent = (i >> 10) & 0x1f;
Chris Lattner4794b2b2009-10-16 02:13:51 +00003289 uint32_t mysignificand = i & 0x3ff;
3290
3291 initialize(&APFloat::IEEEhalf);
3292 assert(partCount()==1);
3293
3294 sign = i >> 15;
3295 if (myexponent==0 && mysignificand==0) {
3296 // exponent, significand meaningless
3297 category = fcZero;
3298 } else if (myexponent==0x1f && mysignificand==0) {
3299 // exponent, significand meaningless
3300 category = fcInfinity;
3301 } else if (myexponent==0x1f && mysignificand!=0) {
3302 // sign, exponent, significand meaningless
3303 category = fcNaN;
3304 *significandParts() = mysignificand;
3305 } else {
3306 category = fcNormal;
3307 exponent = myexponent - 15; //bias
3308 *significandParts() = mysignificand;
3309 if (myexponent==0) // denormal
3310 exponent = -14;
3311 else
3312 *significandParts() |= 0x400; // integer bit
3313 }
3314}
3315
Dale Johannesen245dceb2007-09-11 18:32:33 +00003316/// Treat api as containing the bits of a floating point number. Currently
Dale Johannesen007aa372007-10-11 18:07:22 +00003317/// we infer the floating point type from the size of the APInt. The
3318/// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
3319/// when the size is anything else).
Dale Johannesen245dceb2007-09-11 18:32:33 +00003320void
Tim Northover29178a32013-01-22 09:46:31 +00003321APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
Neil Booth9acbf5a2007-09-26 21:33:42 +00003322{
Tim Northover29178a32013-01-22 09:46:31 +00003323 if (Sem == &IEEEhalf)
Chris Lattner4794b2b2009-10-16 02:13:51 +00003324 return initFromHalfAPInt(api);
Tim Northover29178a32013-01-22 09:46:31 +00003325 if (Sem == &IEEEsingle)
Dale Johannesen245dceb2007-09-11 18:32:33 +00003326 return initFromFloatAPInt(api);
Tim Northover29178a32013-01-22 09:46:31 +00003327 if (Sem == &IEEEdouble)
Dale Johannesen245dceb2007-09-11 18:32:33 +00003328 return initFromDoubleAPInt(api);
Tim Northover29178a32013-01-22 09:46:31 +00003329 if (Sem == &x87DoubleExtended)
Dale Johannesen245dceb2007-09-11 18:32:33 +00003330 return initFromF80LongDoubleAPInt(api);
Tim Northover29178a32013-01-22 09:46:31 +00003331 if (Sem == &IEEEquad)
3332 return initFromQuadrupleAPInt(api);
3333 if (Sem == &PPCDoubleDouble)
3334 return initFromPPCDoubleDoubleAPInt(api);
3335
Craig Topper2617dcc2014-04-15 06:32:26 +00003336 llvm_unreachable(nullptr);
Dale Johannesen245dceb2007-09-11 18:32:33 +00003337}
3338
Nadav Rotem7cc6d122011-02-17 21:22:27 +00003339APFloat
3340APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE)
3341{
Tim Northover29178a32013-01-22 09:46:31 +00003342 switch (BitWidth) {
3343 case 16:
3344 return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
3345 case 32:
3346 return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
3347 case 64:
3348 return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
3349 case 80:
3350 return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
3351 case 128:
3352 if (isIEEE)
3353 return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
3354 return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
3355 default:
3356 llvm_unreachable("Unknown floating bit width");
3357 }
Nadav Rotem7cc6d122011-02-17 21:22:27 +00003358}
3359
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003360/// Make this number the largest magnitude normal number in the given
3361/// semantics.
3362void APFloat::makeLargest(bool Negative) {
John McCall29b5c282009-12-24 08:56:26 +00003363 // We want (in interchange format):
3364 // sign = {Negative}
3365 // exponent = 1..10
3366 // significand = 1..1
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003367 category = fcNormal;
3368 sign = Negative;
3369 exponent = semantics->maxExponent;
John McCall29b5c282009-12-24 08:56:26 +00003370
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003371 // Use memset to set all but the highest integerPart to all ones.
3372 integerPart *significand = significandParts();
3373 unsigned PartCount = partCount();
3374 memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));
John McCall29b5c282009-12-24 08:56:26 +00003375
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003376 // Set the high integerPart especially setting all unused top bits for
3377 // internal consistency.
3378 const unsigned NumUnusedHighBits =
3379 PartCount*integerPartWidth - semantics->precision;
3380 significand[PartCount - 1] = ~integerPart(0) >> NumUnusedHighBits;
John McCall29b5c282009-12-24 08:56:26 +00003381}
3382
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003383/// Make this number the smallest magnitude denormal number in the given
3384/// semantics.
3385void APFloat::makeSmallest(bool Negative) {
John McCall29b5c282009-12-24 08:56:26 +00003386 // We want (in interchange format):
3387 // sign = {Negative}
3388 // exponent = 0..0
3389 // significand = 0..01
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003390 category = fcNormal;
3391 sign = Negative;
3392 exponent = semantics->minExponent;
3393 APInt::tcSet(significandParts(), 1, partCount());
3394}
John McCall29b5c282009-12-24 08:56:26 +00003395
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003396
3397APFloat APFloat::getLargest(const fltSemantics &Sem, bool Negative) {
3398 // We want (in interchange format):
3399 // sign = {Negative}
3400 // exponent = 1..10
3401 // significand = 1..1
3402 APFloat Val(Sem, uninitialized);
3403 Val.makeLargest(Negative);
3404 return Val;
3405}
3406
3407APFloat APFloat::getSmallest(const fltSemantics &Sem, bool Negative) {
3408 // We want (in interchange format):
3409 // sign = {Negative}
3410 // exponent = 0..0
3411 // significand = 0..01
3412 APFloat Val(Sem, uninitialized);
3413 Val.makeSmallest(Negative);
John McCall29b5c282009-12-24 08:56:26 +00003414 return Val;
3415}
3416
3417APFloat APFloat::getSmallestNormalized(const fltSemantics &Sem, bool Negative) {
Michael Gottesman79b09672013-06-27 21:58:19 +00003418 APFloat Val(Sem, uninitialized);
John McCall29b5c282009-12-24 08:56:26 +00003419
3420 // We want (in interchange format):
3421 // sign = {Negative}
3422 // exponent = 0..0
3423 // significand = 10..0
3424
Michael Gottesman30a90eb2013-07-27 21:49:21 +00003425 Val.category = fcNormal;
Michael Gottesmanccaf3322013-06-27 20:40:11 +00003426 Val.zeroSignificand();
Michael Gottesman79b09672013-06-27 21:58:19 +00003427 Val.sign = Negative;
3428 Val.exponent = Sem.minExponent;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00003429 Val.significandParts()[partCountForBits(Sem.precision)-1] |=
Eli Friedmand4330422011-10-12 21:56:19 +00003430 (((integerPart) 1) << ((Sem.precision - 1) % integerPartWidth));
John McCall29b5c282009-12-24 08:56:26 +00003431
3432 return Val;
3433}
3434
Tim Northover29178a32013-01-22 09:46:31 +00003435APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
3436 initFromAPInt(&Sem, API);
Dale Johannesen245dceb2007-09-11 18:32:33 +00003437}
3438
Ulrich Weigande1d62f92012-10-29 18:17:42 +00003439APFloat::APFloat(float f) {
Tim Northover29178a32013-01-22 09:46:31 +00003440 initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
Dale Johannesen245dceb2007-09-11 18:32:33 +00003441}
3442
Ulrich Weigande1d62f92012-10-29 18:17:42 +00003443APFloat::APFloat(double d) {
Tim Northover29178a32013-01-22 09:46:31 +00003444 initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
Dale Johannesen245dceb2007-09-11 18:32:33 +00003445}
John McCall29b5c282009-12-24 08:56:26 +00003446
3447namespace {
David Blaikie70fdf722012-07-25 18:04:24 +00003448 void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
3449 Buffer.append(Str.begin(), Str.end());
John McCall29b5c282009-12-24 08:56:26 +00003450 }
3451
John McCalle6212ace2009-12-24 12:16:56 +00003452 /// Removes data from the given significand until it is no more
3453 /// precise than is required for the desired precision.
3454 void AdjustToPrecision(APInt &significand,
3455 int &exp, unsigned FormatPrecision) {
3456 unsigned bits = significand.getActiveBits();
3457
3458 // 196/59 is a very slight overestimate of lg_2(10).
3459 unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
3460
3461 if (bits <= bitsRequired) return;
3462
3463 unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
3464 if (!tensRemovable) return;
3465
3466 exp += tensRemovable;
3467
3468 APInt divisor(significand.getBitWidth(), 1);
3469 APInt powten(significand.getBitWidth(), 10);
3470 while (true) {
3471 if (tensRemovable & 1)
3472 divisor *= powten;
3473 tensRemovable >>= 1;
3474 if (!tensRemovable) break;
3475 powten *= powten;
3476 }
3477
3478 significand = significand.udiv(divisor);
3479
Hao Liube99cc32013-03-20 01:46:36 +00003480 // Truncate the significand down to its active bit count.
3481 significand = significand.trunc(significand.getActiveBits());
John McCalle6212ace2009-12-24 12:16:56 +00003482 }
3483
3484
John McCall29b5c282009-12-24 08:56:26 +00003485 void AdjustToPrecision(SmallVectorImpl<char> &buffer,
3486 int &exp, unsigned FormatPrecision) {
3487 unsigned N = buffer.size();
3488 if (N <= FormatPrecision) return;
3489
3490 // The most significant figures are the last ones in the buffer.
3491 unsigned FirstSignificant = N - FormatPrecision;
3492
3493 // Round.
3494 // FIXME: this probably shouldn't use 'round half up'.
3495
3496 // Rounding down is just a truncation, except we also want to drop
3497 // trailing zeros from the new result.
3498 if (buffer[FirstSignificant - 1] < '5') {
NAKAMURA Takumi5adeb932012-02-19 03:18:29 +00003499 while (FirstSignificant < N && buffer[FirstSignificant] == '0')
John McCall29b5c282009-12-24 08:56:26 +00003500 FirstSignificant++;
3501
3502 exp += FirstSignificant;
3503 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3504 return;
3505 }
3506
3507 // Rounding up requires a decimal add-with-carry. If we continue
3508 // the carry, the newly-introduced zeros will just be truncated.
3509 for (unsigned I = FirstSignificant; I != N; ++I) {
3510 if (buffer[I] == '9') {
3511 FirstSignificant++;
3512 } else {
3513 buffer[I]++;
3514 break;
3515 }
3516 }
3517
3518 // If we carried through, we have exactly one digit of precision.
3519 if (FirstSignificant == N) {
3520 exp += FirstSignificant;
3521 buffer.clear();
3522 buffer.push_back('1');
3523 return;
3524 }
3525
3526 exp += FirstSignificant;
3527 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3528 }
3529}
3530
3531void APFloat::toString(SmallVectorImpl<char> &Str,
3532 unsigned FormatPrecision,
Chris Lattner4c1e4db2010-03-06 19:20:13 +00003533 unsigned FormatMaxPadding) const {
John McCall29b5c282009-12-24 08:56:26 +00003534 switch (category) {
3535 case fcInfinity:
3536 if (isNegative())
3537 return append(Str, "-Inf");
3538 else
3539 return append(Str, "+Inf");
3540
3541 case fcNaN: return append(Str, "NaN");
3542
3543 case fcZero:
3544 if (isNegative())
3545 Str.push_back('-');
3546
3547 if (!FormatMaxPadding)
3548 append(Str, "0.0E+0");
3549 else
3550 Str.push_back('0');
3551 return;
3552
3553 case fcNormal:
3554 break;
3555 }
3556
3557 if (isNegative())
3558 Str.push_back('-');
3559
3560 // Decompose the number into an APInt and an exponent.
3561 int exp = exponent - ((int) semantics->precision - 1);
3562 APInt significand(semantics->precision,
Jeffrey Yasskin7a162882011-07-18 21:45:40 +00003563 makeArrayRef(significandParts(),
3564 partCountForBits(semantics->precision)));
John McCall29b5c282009-12-24 08:56:26 +00003565
John McCalldd5044a2009-12-24 23:18:09 +00003566 // Set FormatPrecision if zero. We want to do this before we
3567 // truncate trailing zeros, as those are part of the precision.
3568 if (!FormatPrecision) {
Eli Friedmane72f1322013-08-29 23:44:34 +00003569 // We use enough digits so the number can be round-tripped back to an
3570 // APFloat. The formula comes from "How to Print Floating-Point Numbers
3571 // Accurately" by Steele and White.
3572 // FIXME: Using a formula based purely on the precision is conservative;
3573 // we can print fewer digits depending on the actual value being printed.
John McCalldd5044a2009-12-24 23:18:09 +00003574
Eli Friedmane72f1322013-08-29 23:44:34 +00003575 // FormatPrecision = 2 + floor(significandBits / lg_2(10))
3576 FormatPrecision = 2 + semantics->precision * 59 / 196;
John McCalldd5044a2009-12-24 23:18:09 +00003577 }
3578
John McCall29b5c282009-12-24 08:56:26 +00003579 // Ignore trailing binary zeros.
3580 int trailingZeros = significand.countTrailingZeros();
3581 exp += trailingZeros;
3582 significand = significand.lshr(trailingZeros);
3583
3584 // Change the exponent from 2^e to 10^e.
3585 if (exp == 0) {
3586 // Nothing to do.
3587 } else if (exp > 0) {
3588 // Just shift left.
Jay Foad583abbc2010-12-07 08:25:19 +00003589 significand = significand.zext(semantics->precision + exp);
John McCall29b5c282009-12-24 08:56:26 +00003590 significand <<= exp;
3591 exp = 0;
3592 } else { /* exp < 0 */
3593 int texp = -exp;
3594
3595 // We transform this using the identity:
3596 // (N)(2^-e) == (N)(5^e)(10^-e)
3597 // This means we have to multiply N (the significand) by 5^e.
3598 // To avoid overflow, we have to operate on numbers large
3599 // enough to store N * 5^e:
3600 // log2(N * 5^e) == log2(N) + e * log2(5)
John McCalldd5044a2009-12-24 23:18:09 +00003601 // <= semantics->precision + e * 137 / 59
3602 // (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)
Dan Gohmanb452d4e2010-03-24 19:38:02 +00003603
Eli Friedman19546412011-10-07 23:40:49 +00003604 unsigned precision = semantics->precision + (137 * texp + 136) / 59;
John McCall29b5c282009-12-24 08:56:26 +00003605
3606 // Multiply significand by 5^e.
3607 // N * 5^0101 == N * 5^(1*1) * 5^(0*2) * 5^(1*4) * 5^(0*8)
Jay Foad583abbc2010-12-07 08:25:19 +00003608 significand = significand.zext(precision);
John McCall29b5c282009-12-24 08:56:26 +00003609 APInt five_to_the_i(precision, 5);
3610 while (true) {
3611 if (texp & 1) significand *= five_to_the_i;
Dan Gohmanb452d4e2010-03-24 19:38:02 +00003612
John McCall29b5c282009-12-24 08:56:26 +00003613 texp >>= 1;
3614 if (!texp) break;
3615 five_to_the_i *= five_to_the_i;
3616 }
3617 }
3618
John McCalle6212ace2009-12-24 12:16:56 +00003619 AdjustToPrecision(significand, exp, FormatPrecision);
3620
Dmitri Gribenko226fea52013-01-13 16:01:15 +00003621 SmallVector<char, 256> buffer;
John McCall29b5c282009-12-24 08:56:26 +00003622
3623 // Fill the buffer.
3624 unsigned precision = significand.getBitWidth();
3625 APInt ten(precision, 10);
3626 APInt digit(precision, 0);
3627
3628 bool inTrail = true;
3629 while (significand != 0) {
3630 // digit <- significand % 10
3631 // significand <- significand / 10
3632 APInt::udivrem(significand, ten, significand, digit);
3633
3634 unsigned d = digit.getZExtValue();
3635
3636 // Drop trailing zeros.
3637 if (inTrail && !d) exp++;
3638 else {
3639 buffer.push_back((char) ('0' + d));
3640 inTrail = false;
3641 }
3642 }
3643
3644 assert(!buffer.empty() && "no characters in buffer!");
3645
3646 // Drop down to FormatPrecision.
3647 // TODO: don't do more precise calculations above than are required.
3648 AdjustToPrecision(buffer, exp, FormatPrecision);
3649
3650 unsigned NDigits = buffer.size();
3651
John McCalldd5044a2009-12-24 23:18:09 +00003652 // Check whether we should use scientific notation.
John McCall29b5c282009-12-24 08:56:26 +00003653 bool FormatScientific;
3654 if (!FormatMaxPadding)
3655 FormatScientific = true;
3656 else {
John McCall29b5c282009-12-24 08:56:26 +00003657 if (exp >= 0) {
John McCalldd5044a2009-12-24 23:18:09 +00003658 // 765e3 --> 765000
3659 // ^^^
3660 // But we shouldn't make the number look more precise than it is.
3661 FormatScientific = ((unsigned) exp > FormatMaxPadding ||
3662 NDigits + (unsigned) exp > FormatPrecision);
John McCall29b5c282009-12-24 08:56:26 +00003663 } else {
John McCalldd5044a2009-12-24 23:18:09 +00003664 // Power of the most significant digit.
3665 int MSD = exp + (int) (NDigits - 1);
3666 if (MSD >= 0) {
John McCall29b5c282009-12-24 08:56:26 +00003667 // 765e-2 == 7.65
John McCalldd5044a2009-12-24 23:18:09 +00003668 FormatScientific = false;
John McCall29b5c282009-12-24 08:56:26 +00003669 } else {
3670 // 765e-5 == 0.00765
3671 // ^ ^^
John McCalldd5044a2009-12-24 23:18:09 +00003672 FormatScientific = ((unsigned) -MSD) > FormatMaxPadding;
John McCall29b5c282009-12-24 08:56:26 +00003673 }
3674 }
John McCall29b5c282009-12-24 08:56:26 +00003675 }
3676
3677 // Scientific formatting is pretty straightforward.
3678 if (FormatScientific) {
3679 exp += (NDigits - 1);
3680
3681 Str.push_back(buffer[NDigits-1]);
3682 Str.push_back('.');
3683 if (NDigits == 1)
3684 Str.push_back('0');
3685 else
3686 for (unsigned I = 1; I != NDigits; ++I)
3687 Str.push_back(buffer[NDigits-1-I]);
3688 Str.push_back('E');
3689
3690 Str.push_back(exp >= 0 ? '+' : '-');
3691 if (exp < 0) exp = -exp;
3692 SmallVector<char, 6> expbuf;
3693 do {
3694 expbuf.push_back((char) ('0' + (exp % 10)));
3695 exp /= 10;
3696 } while (exp);
3697 for (unsigned I = 0, E = expbuf.size(); I != E; ++I)
3698 Str.push_back(expbuf[E-1-I]);
3699 return;
3700 }
3701
3702 // Non-scientific, positive exponents.
3703 if (exp >= 0) {
3704 for (unsigned I = 0; I != NDigits; ++I)
3705 Str.push_back(buffer[NDigits-1-I]);
3706 for (unsigned I = 0; I != (unsigned) exp; ++I)
3707 Str.push_back('0');
3708 return;
3709 }
3710
3711 // Non-scientific, negative exponents.
3712
3713 // The number of digits to the left of the decimal point.
3714 int NWholeDigits = exp + (int) NDigits;
3715
3716 unsigned I = 0;
3717 if (NWholeDigits > 0) {
3718 for (; I != (unsigned) NWholeDigits; ++I)
3719 Str.push_back(buffer[NDigits-I-1]);
3720 Str.push_back('.');
3721 } else {
3722 unsigned NZeros = 1 + (unsigned) -NWholeDigits;
3723
3724 Str.push_back('0');
3725 Str.push_back('.');
3726 for (unsigned Z = 1; Z != NZeros; ++Z)
3727 Str.push_back('0');
3728 }
3729
3730 for (; I != NDigits; ++I)
3731 Str.push_back(buffer[NDigits-I-1]);
3732}
Benjamin Kramer03fd6722011-03-30 15:42:27 +00003733
3734bool APFloat::getExactInverse(APFloat *inv) const {
Benjamin Kramer03fd6722011-03-30 15:42:27 +00003735 // Special floats and denormals have no exact inverse.
Michael Gottesman8136c382013-06-26 23:17:28 +00003736 if (!isFiniteNonZero())
Benjamin Kramer03fd6722011-03-30 15:42:27 +00003737 return false;
3738
3739 // Check that the number is a power of two by making sure that only the
3740 // integer bit is set in the significand.
3741 if (significandLSB() != semantics->precision - 1)
3742 return false;
3743
3744 // Get the inverse.
3745 APFloat reciprocal(*semantics, 1ULL);
3746 if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
3747 return false;
3748
Benjamin Krameraf0ed952011-03-30 17:02:54 +00003749 // Avoid multiplication with a denormal, it is not safe on all platforms and
3750 // may be slower than a normal division.
Benjamin Kramer6bef24f2013-06-01 11:26:33 +00003751 if (reciprocal.isDenormal())
Benjamin Krameraf0ed952011-03-30 17:02:54 +00003752 return false;
3753
Michael Gottesman8136c382013-06-26 23:17:28 +00003754 assert(reciprocal.isFiniteNonZero() &&
Benjamin Krameraf0ed952011-03-30 17:02:54 +00003755 reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
3756
Benjamin Kramer03fd6722011-03-30 15:42:27 +00003757 if (inv)
3758 *inv = reciprocal;
3759
3760 return true;
3761}
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003762
3763bool APFloat::isSignaling() const {
3764 if (!isNaN())
3765 return false;
3766
3767 // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
3768 // first bit of the trailing significand being 0.
3769 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3770}
3771
3772/// IEEE-754R 2008 5.3.1: nextUp/nextDown.
3773///
3774/// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
3775/// appropriate sign switching before/after the computation.
3776APFloat::opStatus APFloat::next(bool nextDown) {
3777 // If we are performing nextDown, swap sign so we have -x.
3778 if (nextDown)
3779 changeSign();
3780
3781 // Compute nextUp(x)
3782 opStatus result = opOK;
3783
3784 // Handle each float category separately.
3785 switch (category) {
3786 case fcInfinity:
3787 // nextUp(+inf) = +inf
3788 if (!isNegative())
3789 break;
3790 // nextUp(-inf) = -getLargest()
3791 makeLargest(true);
3792 break;
3793 case fcNaN:
3794 // IEEE-754R 2008 6.2 Par 2: nextUp(sNaN) = qNaN. Set Invalid flag.
3795 // IEEE-754R 2008 6.2: nextUp(qNaN) = qNaN. Must be identity so we do not
3796 // change the payload.
3797 if (isSignaling()) {
3798 result = opInvalidOp;
Alp Tokercb402912014-01-24 17:20:08 +00003799 // For consistency, propagate the sign of the sNaN to the qNaN.
Craig Topperc10719f2014-04-07 04:17:22 +00003800 makeNaN(false, isNegative(), nullptr);
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003801 }
3802 break;
3803 case fcZero:
3804 // nextUp(pm 0) = +getSmallest()
3805 makeSmallest(false);
3806 break;
3807 case fcNormal:
3808 // nextUp(-getSmallest()) = -0
3809 if (isSmallest() && isNegative()) {
3810 APInt::tcSet(significandParts(), 0, partCount());
3811 category = fcZero;
3812 exponent = 0;
3813 break;
3814 }
3815
3816 // nextUp(getLargest()) == INFINITY
3817 if (isLargest() && !isNegative()) {
3818 APInt::tcSet(significandParts(), 0, partCount());
3819 category = fcInfinity;
3820 exponent = semantics->maxExponent + 1;
3821 break;
3822 }
3823
3824 // nextUp(normal) == normal + inc.
3825 if (isNegative()) {
3826 // If we are negative, we need to decrement the significand.
3827
3828 // We only cross a binade boundary that requires adjusting the exponent
3829 // if:
3830 // 1. exponent != semantics->minExponent. This implies we are not in the
3831 // smallest binade or are dealing with denormals.
3832 // 2. Our significand excluding the integral bit is all zeros.
3833 bool WillCrossBinadeBoundary =
3834 exponent != semantics->minExponent && isSignificandAllZeros();
3835
3836 // Decrement the significand.
3837 //
3838 // We always do this since:
Alp Tokerf907b892013-12-05 05:44:44 +00003839 // 1. If we are dealing with a non-binade decrement, by definition we
Michael Gottesman0c622ea2013-05-30 18:07:13 +00003840 // just decrement the significand.
3841 // 2. If we are dealing with a normal -> normal binade decrement, since
3842 // we have an explicit integral bit the fact that all bits but the
3843 // integral bit are zero implies that subtracting one will yield a
3844 // significand with 0 integral bit and 1 in all other spots. Thus we
3845 // must just adjust the exponent and set the integral bit to 1.
3846 // 3. If we are dealing with a normal -> denormal binade decrement,
3847 // since we set the integral bit to 0 when we represent denormals, we
3848 // just decrement the significand.
3849 integerPart *Parts = significandParts();
3850 APInt::tcDecrement(Parts, partCount());
3851
3852 if (WillCrossBinadeBoundary) {
3853 // Our result is a normal number. Do the following:
3854 // 1. Set the integral bit to 1.
3855 // 2. Decrement the exponent.
3856 APInt::tcSetBit(Parts, semantics->precision - 1);
3857 exponent--;
3858 }
3859 } else {
3860 // If we are positive, we need to increment the significand.
3861
3862 // We only cross a binade boundary that requires adjusting the exponent if
3863 // the input is not a denormal and all of said input's significand bits
3864 // are set. If all of said conditions are true: clear the significand, set
3865 // the integral bit to 1, and increment the exponent. If we have a
3866 // denormal always increment since moving denormals and the numbers in the
3867 // smallest normal binade have the same exponent in our representation.
3868 bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();
3869
3870 if (WillCrossBinadeBoundary) {
3871 integerPart *Parts = significandParts();
3872 APInt::tcSet(Parts, 0, partCount());
3873 APInt::tcSetBit(Parts, semantics->precision - 1);
3874 assert(exponent != semantics->maxExponent &&
3875 "We can not increment an exponent beyond the maxExponent allowed"
3876 " by the given floating point semantics.");
3877 exponent++;
3878 } else {
3879 incrementSignificand();
3880 }
3881 }
3882 break;
3883 }
3884
3885 // If we are performing nextDown, swap sign so we have -nextUp(-x)
3886 if (nextDown)
3887 changeSign();
3888
3889 return result;
3890}
Michael Gottesmanc4facdf2013-06-24 09:58:02 +00003891
3892void
3893APFloat::makeInf(bool Negative) {
3894 category = fcInfinity;
3895 sign = Negative;
3896 exponent = semantics->maxExponent + 1;
3897 APInt::tcSet(significandParts(), 0, partCount());
3898}
3899
3900void
3901APFloat::makeZero(bool Negative) {
3902 category = fcZero;
3903 sign = Negative;
3904 exponent = semantics->minExponent-1;
3905 APInt::tcSet(significandParts(), 0, partCount());
3906}