strtod.cc 15.5 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include "src/numbers/strtod.h"
6

7
#include <stdarg.h>
8
#include <cmath>
9

10
#include "src/common/globals.h"
11 12 13
#include "src/numbers/bignum.h"
#include "src/numbers/cached-powers.h"
#include "src/numbers/double.h"
14
#include "src/utils/utils.h"
15 16 17 18

namespace v8 {
namespace internal {

19 20 21 22
// 2^53 = 9007199254740992.
// Any integer with at most 15 decimal digits will hence fit into a double
// (which has a 53bit significand) without loss of precision.
static const int kMaxExactDoubleIntegerDecimalDigits = 15;
23
// 2^64 = 18446744073709551616 > 10^19
24
static const int kMaxUint64DecimalDigits = 19;
25

26 27 28 29 30 31 32 33
// Max double: 1.7976931348623157 x 10^308
// Min non-zero double: 4.9406564584124654 x 10^-324
// Any x >= 10^309 is interpreted as +infinity.
// Any x <= 10^-324 is interpreted as 0.
// Note that 2.5e-324 (despite being smaller than the min double) will be read
// as non-zero (equal to the min non-zero double).
static const int kMaxDecimalPower = 309;
static const int kMinDecimalPower = -324;
34

35 36 37
// 2^64 = 18446744073709551616
static const uint64_t kMaxUint64 = V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF);

38
// clang-format off
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
static const double exact_powers_of_ten[] = {
  1.0,  // 10^0
  10.0,
  100.0,
  1000.0,
  10000.0,
  100000.0,
  1000000.0,
  10000000.0,
  100000000.0,
  1000000000.0,
  10000000000.0,  // 10^10
  100000000000.0,
  1000000000000.0,
  10000000000000.0,
  100000000000000.0,
  1000000000000000.0,
  10000000000000000.0,
  100000000000000000.0,
  1000000000000000000.0,
  10000000000000000000.0,
  100000000000000000000.0,  // 10^20
  1000000000000000000000.0,
62
  // 10^22 = 0x21E19E0C9BAB2400000 = 0x878678326EAC9 * 2^22
63 64
  10000000000000000000000.0
};
65
// clang-format on
66
static const int kExactPowersOfTenSize = arraysize(exact_powers_of_ten);
67

68 69 70 71
// Maximum number of significant digits in the decimal representation.
// In fact the value is 772 (see conversions.cc), but to give us some margin
// we round up to 780.
static const int kMaxSignificantDecimalDigits = 780;
72

73 74 75
static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
  for (int i = 0; i < buffer.length(); i++) {
    if (buffer[i] != '0') {
76
      return buffer.SubVector(i, buffer.length());
77 78
    }
  }
79
  return Vector<const char>(buffer.begin(), 0);
80 81 82
}

static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
83 84
  for (int i = buffer.length() - 1; i >= 0; --i) {
    if (buffer[i] != '0') {
85
      return buffer.SubVector(0, i + 1);
86 87
    }
  }
88
  return Vector<const char>(buffer.begin(), 0);
89 90
}

91
static void TrimToMaxSignificantDigits(Vector<const char> buffer, int exponent,
92 93 94 95 96 97 98
                                       char* significant_buffer,
                                       int* significant_exponent) {
  for (int i = 0; i < kMaxSignificantDecimalDigits - 1; ++i) {
    significant_buffer[i] = buffer[i];
  }
  // The input buffer has been trimmed. Therefore the last digit must be
  // different from '0'.
99
  DCHECK_NE(buffer[buffer.length() - 1], '0');
100 101 102 103 104 105 106
  // Set the last digit to be non-zero. This is sufficient to guarantee
  // correct rounding.
  significant_buffer[kMaxSignificantDecimalDigits - 1] = '1';
  *significant_exponent =
      exponent + (buffer.length() - kMaxSignificantDecimalDigits);
}

107 108 109 110 111 112 113
// Reads digits from the buffer and converts them to a uint64.
// Reads in as many digits as fit into a uint64.
// When the string starts with "1844674407370955161" no further digit is read.
// Since 2^64 = 18446744073709551616 it would still be possible read another
// digit if it was less or equal than 6, but this would complicate the code.
static uint64_t ReadUint64(Vector<const char> buffer,
                           int* number_of_read_digits) {
114
  uint64_t result = 0;
115 116 117
  int i = 0;
  while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
    int digit = buffer[i++] - '0';
118
    DCHECK(0 <= digit && digit <= 9);
119 120
    result = 10 * result + digit;
  }
121
  *number_of_read_digits = i;
122 123 124
  return result;
}

125 126 127 128
// Reads a DiyFp from the buffer.
// The returned DiyFp is not necessarily normalized.
// If remaining_decimals is zero then the returned DiyFp is accurate.
// Otherwise it has been rounded and has error of at most 1/2 ulp.
129
static void ReadDiyFp(Vector<const char> buffer, DiyFp* result,
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
                      int* remaining_decimals) {
  int read_digits;
  uint64_t significand = ReadUint64(buffer, &read_digits);
  if (buffer.length() == read_digits) {
    *result = DiyFp(significand, 0);
    *remaining_decimals = 0;
  } else {
    // Round the significand.
    if (buffer[read_digits] >= '5') {
      significand++;
    }
    // Compute the binary exponent.
    int exponent = 0;
    *result = DiyFp(significand, exponent);
    *remaining_decimals = buffer.length() - read_digits;
  }
}

148
static bool DoubleStrtod(Vector<const char> trimmed, int exponent,
149
                         double* result) {
Jakob Kummerow's avatar
Jakob Kummerow committed
150
#if (V8_TARGET_ARCH_IA32 || defined(USE_SIMULATOR)) && !defined(_MSC_VER)
151 152 153
  // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
  // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
  // result is not accurate.
154 155 156 157
  // We know that Windows32 with MSVC, unlike with MinGW32, uses 64 bits and is
  // therefore accurate.
  // Note that the ARM and MIPS simulators are compiled for 32bits. They
  // therefore exhibit the same problem.
158
  USE(exact_powers_of_ten);
159 160
  USE(kMaxExactDoubleIntegerDecimalDigits);
  USE(kExactPowersOfTenSize);
161
  return false;
162
#else
163
  if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
164
    int read_digits;
165 166 167 168 169 170 171 172
    // The trimmed input fits into a double.
    // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
    // can compute the result-double simply by multiplying (resp. dividing) the
    // two numbers.
    // This is possible because IEEE guarantees that floating-point operations
    // return the best possible approximation.
    if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
      // 10^-exponent fits into a double.
173
      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
174
      DCHECK(read_digits == trimmed.length());
175 176
      *result /= exact_powers_of_ten[-exponent];
      return true;
177 178 179
    }
    if (0 <= exponent && exponent < kExactPowersOfTenSize) {
      // 10^exponent fits into a double.
180
      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
181
      DCHECK(read_digits == trimmed.length());
182 183
      *result *= exact_powers_of_ten[exponent];
      return true;
184 185 186 187 188 189 190 191
    }
    int remaining_digits =
        kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
    if ((0 <= exponent) &&
        (exponent - remaining_digits < kExactPowersOfTenSize)) {
      // The trimmed string was short and we can multiply it with
      // 10^remaining_digits. As a result the remaining exponent now fits
      // into a double too.
192
      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
193
      DCHECK(read_digits == trimmed.length());
194 195 196
      *result *= exact_powers_of_ten[remaining_digits];
      *result *= exact_powers_of_ten[exponent - remaining_digits];
      return true;
197 198
    }
  }
199
  return false;
200
#endif
201 202
}

203 204 205
// Returns 10^exponent as an exact DiyFp.
// The given exponent must be in the range [1; kDecimalExponentDistance[.
static DiyFp AdjustmentPowerOfTen(int exponent) {
206 207
  DCHECK_LT(0, exponent);
  DCHECK_LT(exponent, PowersOfTenCache::kDecimalExponentDistance);
208 209
  // Simply hardcode the remaining powers for the given decimal exponent
  // distance.
210
  DCHECK_EQ(PowersOfTenCache::kDecimalExponentDistance, 8);
211
  switch (exponent) {
212 213 214 215 216 217 218 219 220 221 222 223 224 225
    case 1:
      return DiyFp(V8_2PART_UINT64_C(0xA0000000, 00000000), -60);
    case 2:
      return DiyFp(V8_2PART_UINT64_C(0xC8000000, 00000000), -57);
    case 3:
      return DiyFp(V8_2PART_UINT64_C(0xFA000000, 00000000), -54);
    case 4:
      return DiyFp(V8_2PART_UINT64_C(0x9C400000, 00000000), -50);
    case 5:
      return DiyFp(V8_2PART_UINT64_C(0xC3500000, 00000000), -47);
    case 6:
      return DiyFp(V8_2PART_UINT64_C(0xF4240000, 00000000), -44);
    case 7:
      return DiyFp(V8_2PART_UINT64_C(0x98968000, 00000000), -40);
226 227 228 229 230 231 232 233
    default:
      UNREACHABLE();
  }
}

// If the function returns true then the result is the correct double.
// Otherwise it is either the correct double or the double that is just below
// the correct double.
234
static bool DiyFpStrtod(Vector<const char> buffer, int exponent,
235 236 237 238 239 240 241 242 243 244 245 246 247
                        double* result) {
  DiyFp input;
  int remaining_decimals;
  ReadDiyFp(buffer, &input, &remaining_decimals);
  // Since we may have dropped some digits the input is not accurate.
  // If remaining_decimals is different than 0 than the error is at most
  // .5 ulp (unit in the last place).
  // We don't want to deal with fractions and therefore keep a common
  // denominator.
  const int kDenominatorLog = 3;
  const int kDenominator = 1 << kDenominatorLog;
  // Move the remaining decimals into the exponent.
  exponent += remaining_decimals;
248
  int64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
249 250 251 252 253

  int old_e = input.e();
  input.Normalize();
  error <<= old_e - input.e();

254
  DCHECK_LE(exponent, PowersOfTenCache::kMaxDecimalExponent);
255 256 257 258 259 260
  if (exponent < PowersOfTenCache::kMinDecimalExponent) {
    *result = 0.0;
    return true;
  }
  DiyFp cached_power;
  int cached_decimal_exponent;
261
  PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent, &cached_power,
262 263 264 265 266 267 268 269 270
                                                     &cached_decimal_exponent);

  if (cached_decimal_exponent != exponent) {
    int adjustment_exponent = exponent - cached_decimal_exponent;
    DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
    input.Multiply(adjustment_power);
    if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
      // The product of input with the adjustment power fits into a 64 bit
      // integer.
271
      DCHECK_EQ(DiyFp::kSignificandSize, 64);
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
    } else {
      // The adjustment power is exact. There is hence only an error of 0.5.
      error += kDenominator / 2;
    }
  }

  input.Multiply(cached_power);
  // The error introduced by a multiplication of a*b equals
  //   error_a + error_b + error_a*error_b/2^64 + 0.5
  // Substituting a with 'input' and b with 'cached_power' we have
  //   error_b = 0.5  (all cached powers have an error of less than 0.5 ulp),
  //   error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64
  int error_b = kDenominator / 2;
  int error_ab = (error == 0 ? 0 : 1);  // We round up to 1.
  int fixed_error = kDenominator / 2;
  error += error_b + error_ab + fixed_error;

  old_e = input.e();
  input.Normalize();
  error <<= old_e - input.e();

  // See if the double's significand changes if we add/subtract the error.
  int order_of_magnitude = DiyFp::kSignificandSize + input.e();
  int effective_significand_size =
      Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
  int precision_digits_count =
      DiyFp::kSignificandSize - effective_significand_size;
  if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
    // This can only happen for very small denormals. In this case the
    // half-way multiplied by the denominator exceeds the range of an uint64.
    // Simply shift everything to the right.
    int shift_amount = (precision_digits_count + kDenominatorLog) -
304
                       DiyFp::kSignificandSize + 1;
305 306 307 308 309 310 311 312
    input.set_f(input.f() >> shift_amount);
    input.set_e(input.e() + shift_amount);
    // We add 1 for the lost precision of error, and kDenominator for
    // the lost precision of input.f().
    error = (error >> shift_amount) + 1 + kDenominator;
    precision_digits_count -= shift_amount;
  }
  // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
313 314
  DCHECK_EQ(DiyFp::kSignificandSize, 64);
  DCHECK_LT(precision_digits_count, 64);
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
  uint64_t one64 = 1;
  uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
  uint64_t precision_bits = input.f() & precision_bits_mask;
  uint64_t half_way = one64 << (precision_digits_count - 1);
  precision_bits *= kDenominator;
  half_way *= kDenominator;
  DiyFp rounded_input(input.f() >> precision_digits_count,
                      input.e() + precision_digits_count);
  if (precision_bits >= half_way + error) {
    rounded_input.set_f(rounded_input.f() + 1);
  }
  // If the last_bits are too close to the half-way case than we are too
  // inaccurate and round down. In this case we return false so that we can
  // fall back to a more precise algorithm.

  *result = Double(rounded_input).value();
  if (half_way - error < precision_bits && precision_bits < half_way + error) {
    // Too imprecise. The caller will have to fall back to a slower version.
    // However the returned number is guaranteed to be either the correct
    // double, or the next-lower double.
    return false;
  } else {
    return true;
  }
}

341 342 343 344 345 346 347
// Returns the correct double for the buffer*10^exponent.
// The variable guess should be a close guess that is either the correct double
// or its lower neighbor (the nearest double less than the correct one).
// Preconditions:
//   buffer.length() + exponent <= kMaxDecimalPower + 1
//   buffer.length() + exponent > kMinDecimalPower
//   buffer.length() <= kMaxDecimalSignificantDigits
348
static double BignumStrtod(Vector<const char> buffer, int exponent,
349
                           double guess) {
350
  if (guess == V8_INFINITY) {
351 352 353 354 355
    return guess;
  }

  DiyFp upper_boundary = Double(guess).UpperBoundary();

356
  DCHECK(buffer.length() + exponent <= kMaxDecimalPower + 1);
357 358
  DCHECK_GT(buffer.length() + exponent, kMinDecimalPower);
  DCHECK_LE(buffer.length(), kMaxSignificantDecimalDigits);
359 360 361 362
  // Make sure that the Bignum will be able to hold all our numbers.
  // Our Bignum implementation has a separate field for exponents. Shifts will
  // consume at most one bigit (< 64 bits).
  // ln(10) == 3.3219...
363
  DCHECK_LT((kMaxDecimalPower + 1) * 333 / 100, Bignum::kMaxSignificantBits);
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
  Bignum input;
  Bignum boundary;
  input.AssignDecimalString(buffer);
  boundary.AssignUInt64(upper_boundary.f());
  if (exponent >= 0) {
    input.MultiplyByPowerOfTen(exponent);
  } else {
    boundary.MultiplyByPowerOfTen(-exponent);
  }
  if (upper_boundary.e() > 0) {
    boundary.ShiftLeft(upper_boundary.e());
  } else {
    input.ShiftLeft(-upper_boundary.e());
  }
  int comparison = Bignum::Compare(input, boundary);
  if (comparison < 0) {
    return guess;
  } else if (comparison > 0) {
    return Double(guess).NextDouble();
  } else if ((Double(guess).Significand() & 1) == 0) {
    // Round towards even.
    return guess;
  } else {
    return Double(guess).NextDouble();
  }
}

391 392 393 394 395
double Strtod(Vector<const char> buffer, int exponent) {
  Vector<const char> left_trimmed = TrimLeadingZeros(buffer);
  Vector<const char> trimmed = TrimTrailingZeros(left_trimmed);
  exponent += left_trimmed.length() - trimmed.length();
  if (trimmed.length() == 0) return 0.0;
396 397 398
  if (trimmed.length() > kMaxSignificantDecimalDigits) {
    char significant_buffer[kMaxSignificantDecimalDigits];
    int significant_exponent;
399 400 401 402 403
    TrimToMaxSignificantDigits(trimmed, exponent, significant_buffer,
                               &significant_exponent);
    return Strtod(
        Vector<const char>(significant_buffer, kMaxSignificantDecimalDigits),
        significant_exponent);
404
  }
405
  if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) return V8_INFINITY;
406
  if (exponent + trimmed.length() <= kMinDecimalPower) return 0.0;
407

408 409 410 411
  double guess;
  if (DoubleStrtod(trimmed, exponent, &guess) ||
      DiyFpStrtod(trimmed, exponent, &guess)) {
    return guess;
412
  }
413
  return BignumStrtod(trimmed, exponent, guess);
414 415
}

416 417
}  // namespace internal
}  // namespace v8