Dtoa for fixed notation.

Review URL: http://codereview.chromium.org/1956005

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@4596 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/SConscript

@@ -58,6 +58,7 @@ SOURCES = {
     debug.cc
     disassembler.cc
     diy-fp.cc
+    dtoa.cc
     execution.cc
     factory.cc
     flags.cc
@@ -68,6 +69,7 @@ SOURCES = {
     func-name-inferrer.cc
     global-handles.cc
     fast-dtoa.cc
+    fixed-dtoa.cc
     handles.cc
     hashmap.cc
     heap-profiler.cc

src/conversions.cc

@@ -31,8 +31,8 @@
 #include "v8.h"
 
 #include "conversions-inl.h"
+#include "dtoa.h"
 #include "factory.h"
-#include "fast-dtoa.h"
 #include "scanner.h"
 
 namespace v8 {
@@ -766,15 +766,16 @@ const char* DoubleToCString(double v, Vector<char> buffer) {
     default: {
       int decimal_point;
       int sign;
-
       char* decimal_rep;
       bool used_gay_dtoa = false;
-      const int kFastDtoaBufferCapacity = kFastDtoaMaximalLength + 1;
-      char fast_dtoa_buffer[kFastDtoaBufferCapacity];
+      const int kV8DtoaBufferCapacity = kBase10MaximalLength + 1;
+      char v8_dtoa_buffer[kV8DtoaBufferCapacity];
       int length;
-      if (FastDtoa(v, Vector<char>(fast_dtoa_buffer, kFastDtoaBufferCapacity),
-                   &sign, &length, &decimal_point)) {
-        decimal_rep = fast_dtoa_buffer;
+
+      if (DoubleToAscii(v, DTOA_SHORTEST, 0,
+                        Vector<char>(v8_dtoa_buffer, kV8DtoaBufferCapacity),
+                        &sign, &length, &decimal_point)) {
+        decimal_rep = v8_dtoa_buffer;
       } else {
         decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
         used_gay_dtoa = true;
@@ -842,7 +843,11 @@ const char* IntToCString(int n, Vector<char> buffer) {
 
 
 char* DoubleToFixedCString(double value, int f) {
+  const int kMaxDigitsBeforePoint = 20;
+  const double kFirstNonFixed = 1e21;
+  const int kMaxDigitsAfterPoint = 20;
   ASSERT(f >= 0);
+  ASSERT(f <= kMaxDigitsAfterPoint);
 
   bool negative = false;
   double abs_value = value;
@@ -851,7 +856,9 @@ char* DoubleToFixedCString(double value, int f) {
     negative = true;
   }
 
-  if (abs_value >= 1e21) {
+  // If abs_value has more than kMaxDigitsBeforePoint digits before the point
+  // use the non-fixed conversion routine.
+  if (abs_value >= kFirstNonFixed) {
     char arr[100];
     Vector<char> buffer(arr, ARRAY_SIZE(arr));
     return StrDup(DoubleToCString(value, buffer));
@@ -860,8 +867,16 @@ char* DoubleToFixedCString(double value, int f) {
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
-  char* decimal_rep = dtoa(abs_value, 3, f, &decimal_point, &sign, NULL);
-  int decimal_rep_length = StrLength(decimal_rep);
+  // Add space for the '.' and the '\0' byte.
+  const int kDecimalRepCapacity =
+      kMaxDigitsBeforePoint + kMaxDigitsAfterPoint + 2;
+  char decimal_rep[kDecimalRepCapacity];
+  int decimal_rep_length;
+  bool status = DoubleToAscii(value, DTOA_FIXED, f,
+                              Vector<char>(decimal_rep, kDecimalRepCapacity),
+                              &sign, &decimal_rep_length, &decimal_point);
+  USE(status);
+  ASSERT(status);
 
   // Create a representation that is padded with zeros if needed.
   int zero_prefix_length = 0;
@@ -884,7 +899,6 @@ char* DoubleToFixedCString(double value, int f) {
   rep_builder.AddString(decimal_rep);
   rep_builder.AddPadding('0', zero_postfix_length);
   char* rep = rep_builder.Finalize();
-  freedtoa(decimal_rep);
 
   // Create the result string by appending a minus and putting in a
   // decimal point if needed.

src/dtoa.cc

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <math.h>
+
+#include "v8.h"
+#include "dtoa.h"
+
+#include "double.h"
+#include "fast-dtoa.h"
+#include "fixed-dtoa.h"
+
+namespace v8 {
+namespace internal {
+
+bool DoubleToAscii(double v, DtoaMode mode, int requested_digits,
+                   Vector<char> buffer, int* sign, int* length, int* point) {
+  ASSERT(!Double(v).IsSpecial());
+  ASSERT(mode == DTOA_SHORTEST || requested_digits >= 0);
+
+  if (Double(v).Sign() < 0) {
+    *sign = 1;
+    v = -v;
+  } else {
+    *sign = 0;
+  }
+
+  if (v == 0) {
+    buffer[0] = '0';
+    buffer[1] = '\0';
+    *length = 1;
+    *point = 1;
+    return true;
+  }
+
+  if (mode == DTOA_PRECISION && requested_digits == 0) {
+    buffer[0] = '\0';
+    *length = 0;
+    return true;
+  }
+
+  switch (mode) {
+    case DTOA_SHORTEST:
+      return FastDtoa(v, buffer, length, point);
+    case DTOA_FIXED:
+      return FastFixedDtoa(v, requested_digits, buffer, length, point);
+    default:
+      break;
+  }
+  return false;
+}
+
+} }  // namespace v8::internal

src/dtoa.h

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef V8_DTOA_H_
+#define V8_DTOA_H_
+
+namespace v8 {
+namespace internal {
+
+enum DtoaMode {
+  // 0.9999999999999999 becomes 0.1
+  DTOA_SHORTEST,
+  // Fixed number of digits after the decimal point.
+  // For instance fixed(0.1, 4) becomes 0.1000
+  // If the input number is big, the output will be big.
+  DTOA_FIXED,
+  // Fixed number of digits (independent of the decimal point).
+  DTOA_PRECISION
+};
+
+// The maximal length of digits a double can have in base 10.
+// Note that DoubleToAscii null-terminates its input. So the given buffer should
+// be at least kBase10MaximalLength + 1 characters long.
+static const int kBase10MaximalLength = 17;
+
+// Converts the given double 'v' to ascii.
+// The result should be interpreted as buffer * 10^(point-length).
+//
+// The output depends on the given mode:
+//  - SHORTEST: produce the least amount of digits for which the internal
+//   identity requirement is still satisfied. If the digits are printed
+//   (together with the correct exponent) then reading this number will give
+//   'v' again. The buffer will choose the representation that is closest to
+//   'v'. If there are two at the same distance, than the one farther away
+//   from 0 is chosen (halfway cases - ending with 5 - are rounded up).
+//   In this mode the 'requested_digits' parameter is ignored.
+//  - FIXED: produces digits necessary to print a given number with
+//   'requested_digits' digits after the decimal point. The produced digits
+//   might be too short in which case the caller has to fill the gaps with '0's.
+//   Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
+//   Halfway cases are rounded towards +/-Infinity (away from 0). The call
+//   toFixed(0.15, 2) thus returns buffer="2", point=0.
+//   The returned buffer may contain digits that would be truncated from the
+//   shortest representation of the input.
+//  - PRECISION: produces 'requested_digits' where the first digit is not '0'.
+//   Even though the length of produced digits usually equals
+//   'requested_digits', the function is allowed to return fewer digits, in
+//   which case the caller has to fill the missing digits with '0's.
+//   Halfway cases are again rounded away from 0.
+// 'DoubleToAscii' expects the given buffer to be big enough to hold all digits
+// and a terminating null-character.
+bool DoubleToAscii(double v, DtoaMode mode, int requested_digits,
+                   Vector<char> buffer, int* sign, int* length, int* point);
+
+} }  // namespace v8::internal
+
+#endif  // V8_DTOA_H_

src/fast-dtoa.cc

@@ -314,7 +314,7 @@ static void BiggestPowerTen(uint32_t number,
 //  w's fractional part is therefore 0x567890abcdef.
 // Printing w's integral part is easy (simply print 0x1234 in decimal).
 // In order to print its fraction we repeatedly multiply the fraction by 10 and
-// get each digit. Example the first digit after the comma would be computed by
+// get each digit. Example the first digit after the point would be computed by
 //   (0x567890abcdef * 10) >> 48. -> 3
 // The whole thing becomes slightly more complicated because we want to stop
 // once we have enough digits. That is, once the digits inside the buffer
@@ -490,18 +490,11 @@ bool grisu3(double v, Vector<char> buffer, int* length, int* decimal_exponent) {
 
 bool FastDtoa(double v,
               Vector<char> buffer,
-              int* sign,
               int* length,
               int* point) {
-  ASSERT(v != 0);
+  ASSERT(v > 0);
   ASSERT(!Double(v).IsSpecial());
 
-  if (v < 0) {
-    v = -v;
-    *sign = 1;
-  } else {
-    *sign = 0;
-  }
   int decimal_exponent;
   bool result = grisu3(v, buffer, length, &decimal_exponent);
   *point = *length + decimal_exponent;

src/fast-dtoa.h

@@ -36,7 +36,7 @@ namespace internal {
 static const int kFastDtoaMaximalLength = 17;
 
 // Provides a decimal representation of v.
-// v must not be (positive or negative) zero and it must not be Infinity or NaN.
+// v must be a strictly positive finite double.
 // Returns true if it succeeds, otherwise the result can not be trusted.
 // There will be *length digits inside the buffer followed by a null terminator.
 // If the function returns true then
@@ -50,7 +50,6 @@ static const int kFastDtoaMaximalLength = 17;
 //   otherwise.
 bool FastDtoa(double d,
               Vector<char> buffer,
-              int* sign,
               int* length,
               int* point);
 

src/fixed-dtoa.cc

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <math.h>
+
+#include "v8.h"
+
+#include "double.h"
+#include "fixed-dtoa.h"
+
+namespace v8 {
+namespace internal {
+
+// Represents a 128bit type. This class should be replaced by a native type on
+// platforms that support 128bit integers.
+class UInt128 {
+ public:
+  UInt128() : high_bits_(0), low_bits_(0) { }
+  UInt128(uint64_t high, uint64_t low) : high_bits_(high), low_bits_(low) { }
+
+  void Multiply(uint32_t multiplicand) {
+    uint64_t accumulator;
+
+    accumulator = (low_bits_ & kMask32) * multiplicand;
+    uint32_t part = static_cast<uint32_t>(accumulator & kMask32);
+    accumulator >>= 32;
+    accumulator = accumulator + (low_bits_ >> 32) * multiplicand;
+    low_bits_ = (accumulator << 32) + part;
+    accumulator >>= 32;
+    accumulator = accumulator + (high_bits_ & kMask32) * multiplicand;
+    part = static_cast<uint32_t>(accumulator & kMask32);
+    accumulator >>= 32;
+    accumulator = accumulator + (high_bits_ >> 32) * multiplicand;
+    high_bits_ = (accumulator << 32) + part;
+    ASSERT((accumulator >> 32) == 0);
+  }
+
+  void Shift(int shift_amount) {
+    ASSERT(-64 <= shift_amount && shift_amount <= 64);
+    if (shift_amount == 0) {
+      return;
+    } else if (shift_amount == -64) {
+      high_bits_ = low_bits_;
+      low_bits_ = 0;
+    } else if (shift_amount == 64) {
+      low_bits_ = high_bits_;
+      high_bits_ = 0;
+    } else if (shift_amount <= 0) {
+      high_bits_ <<= -shift_amount;
+      high_bits_ += low_bits_ >> (64 + shift_amount);
+      low_bits_ <<= -shift_amount;
+    } else {
+      low_bits_ >>= shift_amount;
+      low_bits_ += high_bits_ << (64 - shift_amount);
+      high_bits_ >>= shift_amount;
+    }
+  }
+
+  // Modifies *this to *this MOD (2^power).
+  // Returns *this DIV (2^power).
+  int DivModPowerOf2(int power) {
+    if (power >= 64) {
+      int result = static_cast<int>(high_bits_ >> (power - 64));
+      high_bits_ -= static_cast<uint64_t>(result) << (power - 64);
+      return result;
+    } else {
+      uint64_t part_low = low_bits_ >> power;
+      uint64_t part_high = high_bits_ << (64 - power);
+      int result = static_cast<int>(part_low + part_high);
+      high_bits_ = 0;
+      low_bits_ -= part_low << power;
+      return result;
+    }
+  }
+
+  bool IsZero() const {
+    return high_bits_ == 0 && low_bits_ == 0;
+  }
+
+  int BitAt(int position) {
+    if (position >= 64) {
+      return static_cast<int>(high_bits_ >> (position - 64)) & 1;
+    } else {
+      return static_cast<int>(low_bits_ >> position) & 1;
+    }
+  }
+
+ private:
+  static const uint64_t kMask32 = 0xFFFFFFFF;
+  // Value == (high_bits_ << 64) + low_bits_
+  uint64_t high_bits_;
+  uint64_t low_bits_;
+};
+
+
+static const int kDoubleSignificandSize = 53;  // Includes the hidden bit.
+
+
+static void FillDigits32FixedLength(uint32_t number, int requested_length,
+                                    Vector<char> buffer, int* length) {
+  for (int i = requested_length - 1; i >= 0; --i) {
+    buffer[(*length) + i] = '0' + number % 10;
+    number /= 10;
+  }
+  *length += requested_length;
+}
+
+
+static void FillDigits32(uint32_t number, Vector<char> buffer, int* length) {
+  int number_length = 0;
+  // We fill the digits in reverse order and exchange them afterwards.
+  while (number != 0) {
+    int digit = number % 10;
+    number /= 10;
+    buffer[(*length) + number_length] = '0' + digit;
+    number_length++;
+  }
+  // Exchange the digits.
+  int i = *length;
+  int j = *length + number_length - 1;
+  while (i < j) {
+    char tmp = buffer[i];
+    buffer[i] = buffer[j];
+    buffer[j] = tmp;
+    i++;
+    j--;
+  }
+  *length += number_length;
+}
+
+
+static void FillDigits64FixedLength(uint64_t number, int requested_length,
+                                    Vector<char> buffer, int* length) {
+  const uint32_t kTen7 = 10000000;
+  // For efficiency cut the number into 3 uint32_t parts, and print those.
+  uint32_t part2 = static_cast<uint32_t>(number % kTen7);
+  number /= kTen7;
+  uint32_t part1 = static_cast<uint32_t>(number % kTen7);
+  uint32_t part0 = static_cast<uint32_t>(number / kTen7);
+
+  FillDigits32FixedLength(part0, 3, buffer, length);
+  FillDigits32FixedLength(part1, 7, buffer, length);
+  FillDigits32FixedLength(part2, 7, buffer, length);
+}
+
+
+static void FillDigits64(uint64_t number, Vector<char> buffer, int* length) {
+  const uint32_t kTen7 = 10000000;
+  // For efficiency cut the number into 3 uint32_t parts, and print those.
+  uint32_t part2 = static_cast<uint32_t>(number % kTen7);
+  number /= kTen7;
+  uint32_t part1 = static_cast<uint32_t>(number % kTen7);
+  uint32_t part0 = static_cast<uint32_t>(number / kTen7);
+
+  if (part0 != 0) {
+    FillDigits32(part0, buffer, length);
+    FillDigits32FixedLength(part1, 7, buffer, length);
+    FillDigits32FixedLength(part2, 7, buffer, length);
+  } else if (part1 != 0) {
+    FillDigits32(part1, buffer, length);
+    FillDigits32FixedLength(part2, 7, buffer, length);
+  } else {
+    FillDigits32(part2, buffer, length);
+  }
+}
+
+
+static void RoundUp(Vector<char> buffer, int* length, int* decimal_point) {
+  // An empty buffer represents 0.
+  if (*length == 0) {
+    buffer[0] = '1';
+    *decimal_point = 1;
+    *length = 1;
+    return;
+  }
+  // Round the last digit until we either have a digit that was not '9' or until
+  // we reached the first digit.
+  buffer[(*length) - 1]++;
+  for (int i = (*length) - 1; i > 0; --i) {
+    if (buffer[i] != '0' + 10) {
+      return;
+    }
+    buffer[i] = '0';
+    buffer[i - 1]++;
+  }
+  // If the first digit is now '0' + 10, we would need to set it to '0' and add
+  // a '1' in front. However we reach the first digit only if all following
+  // digits had been '9' before rounding up. Now all trailing digits are '0' and
+  // we simply switch the first digit to '1' and update the decimal-point
+  // (indicating that the point is now one digit to the right).
+  if (buffer[0] == '0' + 10) {
+    buffer[0] = '1';
+    (*decimal_point)++;
+  }
+}
+
+
+// The given fractionals number represents a fixed-point number with binary
+// point at bit (-exponent).
+// Preconditions:
+//   -128 <= exponent <= 0.
+//   0 <= fractionals * 2^exponent < 1
+//   The buffer holds the result.
+// The function will round its result. During the rounding-process digits not
+// generated by this function might be updated, and the decimal-point variable
+// might be updated. If this function generates the digits 99 and the buffer
+// already contained "199" (thus yielding a buffer of "19999") then a
+// rounding-up will change the contents of the buffer to "20000".
+static void FillFractionals(uint64_t fractionals, int exponent,
+                            int fractional_count, Vector<char> buffer,
+                            int* length, int* decimal_point) {
+  ASSERT(-128 <= exponent && exponent <= 0);
+  // 'fractionals' is a fixed-point number, with binary point at bit
+  // (-exponent). Inside the function the non-converted remainder of fractionals
+  // is a fixed-point number, with binary point at bit 'point'.
+  if (-exponent <= 64) {
+    // One 64 bit number is sufficient.
+    ASSERT(fractionals >> 56 == 0);
+    int point = -exponent;
+    for (int i = 0; i < fractional_count; ++i) {
+      if (fractionals == 0) break;
+      // Instead of multiplying by 10 we multiply by 5 and adjust the point
+      // location. This way the fractionals variable will not overflow.
+      // Invariant at the beginning of the loop: fractionals < 2^point.
+      // Initially we have: point <= 64 and fractionals < 2^56
+      // After each iteration the point is decremented by one.
+      // Note that 5^3 = 125 < 128 = 2^7.
+      // Therefore three iterations of this loop will not overflow fractionals
+      // (even without the subtraction at the end of the loop body). At this
+      // time point will satisfy point <= 61 and therefore fractionals < 2^point
+      // and any further multiplication of fractionals by 5 will not overflow.
+      fractionals *= 5;
+      point--;
+      int digit = static_cast<int>(fractionals >> point);
+      buffer[*length] = '0' + digit;
+      (*length)++;
+      fractionals -= static_cast<uint64_t>(digit) << point;
+    }
+    // If the first bit after the point is set we have to round up.
+    if (((fractionals >> (point - 1)) & 1) == 1) {
+      RoundUp(buffer, length, decimal_point);
+    }
+  } else {  // We need 128 bits.
+    ASSERT(64 < -exponent && -exponent <= 128);
+    UInt128 fractionals128 = UInt128(fractionals, 0);
+    fractionals128.Shift(-exponent - 64);
+    int point = 128;
+    for (int i = 0; i < fractional_count; ++i) {
+      if (fractionals128.IsZero()) break;
+      // As before: instead of multiplying by 10 we multiply by 5 and adjust the
+      // point location.
+      // This multiplication will not overflow for the same reasons as before.
+      fractionals128.Multiply(5);
+      point--;
+      int digit = fractionals128.DivModPowerOf2(point);
+      buffer[*length] = '0' + digit;
+      (*length)++;
+    }
+    if (fractionals128.BitAt(point - 1) == 1) {
+      RoundUp(buffer, length, decimal_point);
+    }
+  }
+}
+
+
+// Removes leading and trailing zeros.
+// If leading zeros are removed then the decimal point position is adjusted.
+static void TrimZeros(Vector<char> buffer, int* length, int* decimal_point) {
+  while (*length > 0 && buffer[(*length) - 1] == '0') {
+    (*length)--;
+  }
+  int first_non_zero = 0;
+  while (first_non_zero < *length && buffer[first_non_zero] == '0') {
+    first_non_zero++;
+  }
+  if (first_non_zero != 0) {
+    for (int i = first_non_zero; i < *length; ++i) {
+      buffer[i - first_non_zero] = buffer[i];
+    }
+    *length -= first_non_zero;
+    *decimal_point -= first_non_zero;
+  }
+}
+
+
+bool FastFixedDtoa(double v,
+                   int fractional_count,
+                   Vector<char> buffer,
+                   int* length,
+                   int* decimal_point) {
+  const uint32_t kMaxUInt32 = 0xFFFFFFFF;
+  uint64_t significand = Double(v).Significand();
+  int exponent = Double(v).Exponent();
+  // v = significand * 2^exponent (with significand a 53bit integer).
+  // If the exponent is larger than 20 (i.e. we may have a 73bit number) then we
+  // don't know how to compute the representation. 2^73 ~= 9.5*10^21.
+  // If necessary this limit could probably be increased, but we don't need
+  // more.
+  if (exponent > 20) return false;
+  if (fractional_count > 20) return false;
+  *length = 0;
+  // At most kDoubleSignificandSize bits of the significand are non-zero.
+  // Given a 64 bit integer we have 11 0s followed by 53 potentially non-zero
+  // bits:  0..11*..0xxx..53*..xx
+  if (exponent + kDoubleSignificandSize > 64) {
+    // The exponent must be > 11.
+    //
+    // We know that v = significand * 2^exponent.
+    // And the exponent > 11.
+    // We simplify the task by dividing v by 10^17.
+    // The quotient delivers the first digits, and the remainder fits into a 64
+    // bit number.
+    // Dividing by 10^17 is equivalent to dividing by 5^17*2^17.
+    const uint64_t kFive17 = V8_2PART_UINT64_C(0xB1, A2BC2EC5);  // 5^17
+    uint64_t divisor = kFive17;
+    int divisor_power = 17;
+    uint64_t dividend = significand;
+    uint32_t quotient;
+    uint64_t remainder;
+    // Let v = f * 2^e with f == significand and e == exponent.
+    // Then need q (quotient) and r (remainder) as follows:
+    //   v            = q * 10^17       + r
+    //   f * 2^e      = q * 10^17       + r
+    //   f * 2^e      = q * 5^17 * 2^17 + r
+    // If e > 17 then
+    //   f * 2^(e-17) = q * 5^17        + r/2^17
+    // else
+    //   f  = q * 5^17 * 2^(17-e) + r/2^e
+    if (exponent > divisor_power) {
+      // We only allow exponents of up to 20 and therefore (17 - e) <= 3
+      dividend <<= exponent - divisor_power;
+      quotient = static_cast<uint32_t>(dividend / divisor);
+      remainder = (dividend % divisor) << divisor_power;
+    } else {
+      divisor <<= divisor_power - exponent;
+      quotient = static_cast<uint32_t>(dividend / divisor);
+      remainder = (dividend % divisor) << exponent;
+    }
+    FillDigits32(quotient, buffer, length);
+    FillDigits64FixedLength(remainder, divisor_power, buffer, length);
+    *decimal_point = *length;
+  } else if (exponent >= 0) {
+    // 0 <= exponent <= 11
+    significand <<= exponent;
+    FillDigits64(significand, buffer, length);
+    *decimal_point = *length;
+  } else if (exponent > -kDoubleSignificandSize) {
+    // We have to cut the number.
+    uint64_t integrals = significand >> -exponent;
+    uint64_t fractionals = significand - (integrals << -exponent);
+    if (integrals > kMaxUInt32) {
+      FillDigits64(integrals, buffer, length);
+    } else {
+      FillDigits32(static_cast<uint32_t>(integrals), buffer, length);
+    }
+    *decimal_point = *length;
+    FillFractionals(fractionals, exponent, fractional_count,
+                    buffer, length, decimal_point);
+  } else if (exponent < -128) {
+    // This configuration (with at most 20 digits) means that all digits must be
+    // 0.
+    ASSERT(fractional_count <= 20);
+    buffer[0] = '\0';
+    *length = 0;
+    *decimal_point = -fractional_count;
+  } else {
+    *decimal_point = 0;
+    FillFractionals(significand, exponent, fractional_count,
+                    buffer, length, decimal_point);
+  }
+  TrimZeros(buffer, length, decimal_point);
+  buffer[*length] = '\0';
+  if ((*length) == 0) {
+    // The string is empty and the decimal_point thus has no importance. Mimick
+    // Gay's dtoa and and set it to -fractional_count.
+    *decimal_point = -fractional_count;
+  }
+  return true;
+}
+
+} }  // namespace v8::internal

src/fixed-dtoa.h

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef V8_FIXED_DTOA_H_
+#define V8_FIXED_DTOA_H_
+
+namespace v8 {
+namespace internal {
+
+// Produces digits necessary to print a given number with
+// 'fractional_count' digits after the decimal point.
+// The buffer must be big enough to hold the result plus one terminating null
+// character.
+//
+// The produced digits might be too short in which case the caller has to fill
+// the gaps with '0's.
+// Example: FastFixedDtoa(0.001, 5, ...) is allowed to return buffer = "1", and
+// decimal_point = -2.
+// Halfway cases are rounded towards +/-Infinity (away from 0). The call
+// FastFixedDtoa(0.15, 2, ...) thus returns buffer = "2", decimal_point = 0.
+// The returned buffer may contain digits that would be truncated from the
+// shortest representation of the input.
+//
+// This method only works for some parameters. If it can't handle the input it
+// returns false. The output is null-terminated when the function succeeds.
+bool FastFixedDtoa(double v, int fractional_count,
+                   Vector<char> buffer, int* length, int* decimal_point);
+
+} }  // namespace v8::internal
+
+#endif  // V8_FIXED_DTOA_H_

test/cctest/SConscript

@@ -34,6 +34,7 @@ Import('context object_files')
 
 SOURCES = {
   'all': [
+    'gay-fixed.cc',
     'gay-shortest.cc',
     'test-accessors.cc',
     'test-alloc.cc',
@@ -49,6 +50,7 @@ SOURCES = {
     'test-diy-fp.cc',
     'test-double.cc',
     'test-fast-dtoa.cc',
+    'test-fixed-dtoa.cc',
     'test-flags.cc',
     'test-func-name-inference.cc',
     'test-hashmap.cc',

test/cctest/gay-fixed.h

+// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GAY_FIXED_H_
+#define GAY_FIXED_H_
+
+namespace v8 {
+namespace internal {
+
+struct PrecomputedFixed {
+  double v;
+  int number_digits;
+  const char* representation;
+  int decimal_point;
+};
+
+// Returns precomputed values of dtoa. The strings have been generated using
+// Gay's dtoa in mode "fixed".
+Vector<const PrecomputedFixed> PrecomputedFixedRepresentations();
+
+} }  // namespace v8::internal
+
+#endif  // GAY_FIXED_H_

test/cctest/gay-shortest.cc

@@ -36,7 +36,7 @@
 namespace v8 {
 namespace internal {
 
-static const GayShortest kShortestTestNumbers[] = {
+static const PrecomputedShortest kShortestTestNumbers[] = {
   {1.3252057186783201350530603e-106, "13252057186783201", -105},
   {1.6899223998841386493367055e-33, "16899223998841386", -32},
   {1.0077972445720390730768089e+138, "1007797244572039", 139},
@@ -100040,9 +100040,11 @@ static const GayShortest kShortestTestNumbers[] = {
 };
 
 
-Vector<const GayShortest> PrecomputedShortestRepresentations() {
-  int number_elements = sizeof(kShortestTestNumbers) / sizeof(GayShortest);
-  return Vector<const GayShortest>(kShortestTestNumbers, number_elements);
+Vector<const PrecomputedShortest> PrecomputedShortestRepresentations() {
+  int number_elements =
+      sizeof(kShortestTestNumbers) / sizeof(PrecomputedShortest);
+  return Vector<const PrecomputedShortest>(kShortestTestNumbers,
+                                           number_elements);
 }
 
 } }  // namespace v8::internal

test/cctest/gay-shortest.h

@@ -31,13 +31,13 @@
 namespace v8 {
 namespace internal {
 
-struct GayShortest {
+struct PrecomputedShortest {
   double v;
   const char* representation;
   int decimal_point;
 };
 
-Vector<const GayShortest> PrecomputedShortestRepresentations();
+Vector<const PrecomputedShortest> PrecomputedShortestRepresentations();
 
 } }  // namespace v8::internal
 

test/cctest/test-fast-dtoa.cc

@@ -18,70 +18,60 @@ static const int kBufferSize = 100;
 TEST(FastDtoaVariousDoubles) {
   char buffer_container[kBufferSize];
   Vector<char> buffer(buffer_container, kBufferSize);
-  int sign;
   int length;
   int point;
   int status;
 
   double min_double = 5e-324;
-  status = FastDtoa(min_double, buffer, &sign, &length, &point);
+  status = FastDtoa(min_double, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("5", buffer.start());
   CHECK_EQ(-323, point);
 
   double max_double = 1.7976931348623157e308;
-  status = FastDtoa(max_double, buffer, &sign, &length, &point);
+  status = FastDtoa(max_double, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("17976931348623157", buffer.start());
   CHECK_EQ(309, point);
 
-  status = FastDtoa(4294967272.0, buffer, &sign, &length, &point);
+  status = FastDtoa(4294967272.0, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("4294967272", buffer.start());
   CHECK_EQ(10, point);
 
-  status = FastDtoa(4.1855804968213567e298, buffer, &sign, &length, &point);
+  status = FastDtoa(4.1855804968213567e298, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("4185580496821357", buffer.start());
   CHECK_EQ(299, point);
 
-  status = FastDtoa(5.5626846462680035e-309, buffer, &sign, &length, &point);
+  status = FastDtoa(5.5626846462680035e-309, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("5562684646268003", buffer.start());
   CHECK_EQ(-308, point);
 
-  status = FastDtoa(2147483648.0, buffer, &sign, &length, &point);
+  status = FastDtoa(2147483648.0, buffer, &length, &point);
   CHECK(status);
-  CHECK_EQ(0, sign);
   CHECK_EQ("2147483648", buffer.start());
   CHECK_EQ(10, point);
 
-  status = FastDtoa(3.5844466002796428e+298, buffer, &sign, &length, &point);
+  status = FastDtoa(3.5844466002796428e+298, buffer, &length, &point);
   if (status) {  // Not all FastDtoa variants manage to compute this number.
     CHECK_EQ("35844466002796428", buffer.start());
-    CHECK_EQ(0, sign);
     CHECK_EQ(299, point);
   }
 
   uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000);
   double v = Double(smallest_normal64).value();
-  status = FastDtoa(v, buffer, &sign, &length, &point);
+  status = FastDtoa(v, buffer, &length, &point);
   if (status) {
-    CHECK_EQ(0, sign);
     CHECK_EQ("22250738585072014", buffer.start());
     CHECK_EQ(-307, point);
   }
 
   uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
   v = Double(largest_denormal64).value();
-  status = FastDtoa(v, buffer, &sign, &length, &point);
+  status = FastDtoa(v, buffer, &length, &point);
   if (status) {
-    CHECK_EQ(0, sign);
     CHECK_EQ("2225073858507201", buffer.start());
     CHECK_EQ(-307, point);
   }
@@ -92,24 +82,23 @@ TEST(FastDtoaGayShortest) {
   char buffer_container[kBufferSize];
   Vector<char> buffer(buffer_container, kBufferSize);
   bool status;
-  int sign;
   int length;
   int point;
   int succeeded = 0;
   int total = 0;
   bool needed_max_length = false;
 
-  Vector<const GayShortest> precomputed = PrecomputedShortestRepresentations();
+  Vector<const PrecomputedShortest> precomputed =
+      PrecomputedShortestRepresentations();
   for (int i = 0; i < precomputed.length(); ++i) {
-    const GayShortest current_test = precomputed[i];
+    const PrecomputedShortest current_test = precomputed[i];
     total++;
     double v = current_test.v;
-    status = FastDtoa(v, buffer, &sign, &length, &point);
+    status = FastDtoa(v, buffer, &length, &point);
     CHECK_GE(kFastDtoaMaximalLength, length);
     if (!status) continue;
     if (length == kFastDtoaMaximalLength) needed_max_length = true;
     succeeded++;
-    CHECK_EQ(0, sign);  // All precomputed numbers are positive.
     CHECK_EQ(current_test.decimal_point, point);
     CHECK_EQ(current_test.representation, buffer.start());
   }

test/cctest/test-fixed-dtoa.cc

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "platform.h"
+#include "cctest.h"
+#include "double.h"
+#include "fixed-dtoa.h"
+#include "gay-fixed.h"
+
+using namespace v8::internal;
+
+static const int kBufferSize = 500;
+
+TEST(FastFixedVariousDoubles) {
+  char buffer_container[kBufferSize];
+  Vector<char> buffer(buffer_container, kBufferSize);
+  int length;
+  int point;
+
+  CHECK(FastFixedDtoa(1.0, 1, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1.0, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1.0, 0, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0xFFFFFFFF, 5, buffer, &length, &point));
+  CHECK_EQ("4294967295", buffer.start());
+  CHECK_EQ(10, point);
+
+  CHECK(FastFixedDtoa(4294967296.0, 5, buffer, &length, &point));
+  CHECK_EQ("4294967296", buffer.start());
+  CHECK_EQ(10, point);
+
+  CHECK(FastFixedDtoa(1e21, 5, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  // CHECK_EQ(22, point);
+  CHECK_EQ(22, point);
+
+  CHECK(FastFixedDtoa(999999999999999868928.00, 2, buffer, &length, &point));
+  CHECK_EQ("999999999999999868928", buffer.start());
+  CHECK_EQ(21, point);
+
+  CHECK(FastFixedDtoa(6.9999999999999989514240000e+21, 5, buffer,
+                      &length, &point));
+  CHECK_EQ("6999999999999998951424", buffer.start());
+  CHECK_EQ(22, point);
+
+  CHECK(FastFixedDtoa(1.5, 5, buffer, &length, &point));
+  CHECK_EQ("15", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1.55, 5, buffer, &length, &point));
+  CHECK_EQ("155", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1.55, 1, buffer, &length, &point));
+  CHECK_EQ("16", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1.00000001, 15, buffer, &length, &point));
+  CHECK_EQ("100000001", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.1, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(0, point);
+
+  CHECK(FastFixedDtoa(0.01, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-1, point);
+
+  CHECK(FastFixedDtoa(0.001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-2, point);
+
+  CHECK(FastFixedDtoa(0.0001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-3, point);
+
+  CHECK(FastFixedDtoa(0.00001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-4, point);
+
+  CHECK(FastFixedDtoa(0.000001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-5, point);
+
+  CHECK(FastFixedDtoa(0.0000001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-6, point);
+
+  CHECK(FastFixedDtoa(0.00000001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-7, point);
+
+  CHECK(FastFixedDtoa(0.000000001, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-8, point);
+
+  CHECK(FastFixedDtoa(0.0000000001, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-9, point);
+
+  CHECK(FastFixedDtoa(0.00000000001, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-10, point);
+
+  CHECK(FastFixedDtoa(0.000000000001, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-11, point);
+
+  CHECK(FastFixedDtoa(0.0000000000001, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-12, point);
+
+  CHECK(FastFixedDtoa(0.00000000000001, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-13, point);
+
+  CHECK(FastFixedDtoa(0.000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-14, point);
+
+  CHECK(FastFixedDtoa(0.0000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-15, point);
+
+  CHECK(FastFixedDtoa(0.00000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-16, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-17, point);
+
+  CHECK(FastFixedDtoa(0.0000000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-18, point);
+
+  CHECK(FastFixedDtoa(0.00000000000000000001, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-19, point);
+
+  CHECK(FastFixedDtoa(0.10000000004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(0, point);
+
+  CHECK(FastFixedDtoa(0.01000000004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-1, point);
+
+  CHECK(FastFixedDtoa(0.00100000004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-2, point);
+
+  CHECK(FastFixedDtoa(0.00010000004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-3, point);
+
+  CHECK(FastFixedDtoa(0.00001000004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-4, point);
+
+  CHECK(FastFixedDtoa(0.00000100004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-5, point);
+
+  CHECK(FastFixedDtoa(0.00000010004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-6, point);
+
+  CHECK(FastFixedDtoa(0.00000001004, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-7, point);
+
+  CHECK(FastFixedDtoa(0.00000000104, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-8, point);
+
+  CHECK(FastFixedDtoa(0.0000000001000004, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-9, point);
+
+  CHECK(FastFixedDtoa(0.0000000000100004, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-10, point);
+
+  CHECK(FastFixedDtoa(0.0000000000010004, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-11, point);
+
+  CHECK(FastFixedDtoa(0.0000000000001004, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-12, point);
+
+  CHECK(FastFixedDtoa(0.0000000000000104, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-13, point);
+
+  CHECK(FastFixedDtoa(0.000000000000001000004, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-14, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000100004, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-15, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000010004, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-16, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000001004, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-17, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000000104, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-18, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000000014, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-19, point);
+
+  CHECK(FastFixedDtoa(0.10000000006, 10, buffer, &length, &point));
+  CHECK_EQ("1000000001", buffer.start());
+  CHECK_EQ(0, point);
+
+  CHECK(FastFixedDtoa(0.01000000006, 10, buffer, &length, &point));
+  CHECK_EQ("100000001", buffer.start());
+  CHECK_EQ(-1, point);
+
+  CHECK(FastFixedDtoa(0.00100000006, 10, buffer, &length, &point));
+  CHECK_EQ("10000001", buffer.start());
+  CHECK_EQ(-2, point);
+
+  CHECK(FastFixedDtoa(0.00010000006, 10, buffer, &length, &point));
+  CHECK_EQ("1000001", buffer.start());
+  CHECK_EQ(-3, point);
+
+  CHECK(FastFixedDtoa(0.00001000006, 10, buffer, &length, &point));
+  CHECK_EQ("100001", buffer.start());
+  CHECK_EQ(-4, point);
+
+  CHECK(FastFixedDtoa(0.00000100006, 10, buffer, &length, &point));
+  CHECK_EQ("10001", buffer.start());
+  CHECK_EQ(-5, point);
+
+  CHECK(FastFixedDtoa(0.00000010006, 10, buffer, &length, &point));
+  CHECK_EQ("1001", buffer.start());
+  CHECK_EQ(-6, point);
+
+  CHECK(FastFixedDtoa(0.00000001006, 10, buffer, &length, &point));
+  CHECK_EQ("101", buffer.start());
+  CHECK_EQ(-7, point);
+
+  CHECK(FastFixedDtoa(0.00000000106, 10, buffer, &length, &point));
+  CHECK_EQ("11", buffer.start());
+  CHECK_EQ(-8, point);
+
+  CHECK(FastFixedDtoa(0.0000000001000006, 15, buffer, &length, &point));
+  CHECK_EQ("100001", buffer.start());
+  CHECK_EQ(-9, point);
+
+  CHECK(FastFixedDtoa(0.0000000000100006, 15, buffer, &length, &point));
+  CHECK_EQ("10001", buffer.start());
+  CHECK_EQ(-10, point);
+
+  CHECK(FastFixedDtoa(0.0000000000010006, 15, buffer, &length, &point));
+  CHECK_EQ("1001", buffer.start());
+  CHECK_EQ(-11, point);
+
+  CHECK(FastFixedDtoa(0.0000000000001006, 15, buffer, &length, &point));
+  CHECK_EQ("101", buffer.start());
+  CHECK_EQ(-12, point);
+
+  CHECK(FastFixedDtoa(0.0000000000000106, 15, buffer, &length, &point));
+  CHECK_EQ("11", buffer.start());
+  CHECK_EQ(-13, point);
+
+  CHECK(FastFixedDtoa(0.000000000000001000006, 20, buffer, &length, &point));
+  CHECK_EQ("100001", buffer.start());
+  CHECK_EQ(-14, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000100006, 20, buffer, &length, &point));
+  CHECK_EQ("10001", buffer.start());
+  CHECK_EQ(-15, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000010006, 20, buffer, &length, &point));
+  CHECK_EQ("1001", buffer.start());
+  CHECK_EQ(-16, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000001006, 20, buffer, &length, &point));
+  CHECK_EQ("101", buffer.start());
+  CHECK_EQ(-17, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000000106, 20, buffer, &length, &point));
+  CHECK_EQ("11", buffer.start());
+  CHECK_EQ(-18, point);
+
+  CHECK(FastFixedDtoa(0.000000000000000000016, 20, buffer, &length, &point));
+  CHECK_EQ("2", buffer.start());
+  CHECK_EQ(-19, point);
+
+  CHECK(FastFixedDtoa(0.6, 0, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.96, 1, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.996, 2, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.9996, 3, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.99996, 4, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.999996, 5, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.9999996, 6, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.99999996, 7, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.999999996, 8, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.9999999996, 9, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.99999999996, 10, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.999999999996, 11, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.9999999999996, 12, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.99999999999996, 13, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.999999999999996, 14, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.9999999999999996, 15, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(0.00999999999999996, 16, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-1, point);
+
+  CHECK(FastFixedDtoa(0.000999999999999996, 17, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-2, point);
+
+  CHECK(FastFixedDtoa(0.0000999999999999996, 18, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-3, point);
+
+  CHECK(FastFixedDtoa(0.00000999999999999996, 19, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-4, point);
+
+  CHECK(FastFixedDtoa(0.000000999999999999996, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-5, point);
+
+  CHECK(FastFixedDtoa(323423.234234, 10, buffer, &length, &point));
+  CHECK_EQ("323423234234", buffer.start());
+  CHECK_EQ(6, point);
+
+  CHECK(FastFixedDtoa(12345678.901234, 4, buffer, &length, &point));
+  CHECK_EQ("123456789012", buffer.start());
+  CHECK_EQ(8, point);
+
+  CHECK(FastFixedDtoa(98765.432109, 5, buffer, &length, &point));
+  CHECK_EQ("9876543211", buffer.start());
+  CHECK_EQ(5, point);
+
+  CHECK(FastFixedDtoa(42, 20, buffer, &length, &point));
+  CHECK_EQ("42", buffer.start());
+  CHECK_EQ(2, point);
+
+  CHECK(FastFixedDtoa(0.5, 0, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(1, point);
+
+  CHECK(FastFixedDtoa(1e-23, 10, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-10, point);
+
+  CHECK(FastFixedDtoa(1e-123, 2, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-2, point);
+
+  CHECK(FastFixedDtoa(1e-123, 0, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(0, point);
+
+  CHECK(FastFixedDtoa(1e-23, 20, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-20, point);
+
+  CHECK(FastFixedDtoa(1e-21, 20, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-20, point);
+
+  CHECK(FastFixedDtoa(1e-22, 20, buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-20, point);
+
+  CHECK(FastFixedDtoa(6e-21, 20, buffer, &length, &point));
+  CHECK_EQ("1", buffer.start());
+  CHECK_EQ(-19, point);
+
+  CHECK(FastFixedDtoa(9.1193616301674545152000000e+19, 0,
+                      buffer, &length, &point));
+  CHECK_EQ("91193616301674545152", buffer.start());
+  CHECK_EQ(20, point);
+
+  CHECK(FastFixedDtoa(4.8184662102767651659096515e-04, 19,
+                      buffer, &length, &point));
+  CHECK_EQ("4818466210276765", buffer.start());
+  CHECK_EQ(-3, point);
+
+  CHECK(FastFixedDtoa(1.9023164229540652612705182e-23, 8,
+                      buffer, &length, &point));
+  CHECK_EQ("", buffer.start());
+  CHECK_EQ(-8, point);
+
+  CHECK(FastFixedDtoa(1000000000000000128.0, 0,
+                      buffer, &length, &point));
+  CHECK_EQ("1000000000000000128", buffer.start());
+  CHECK_EQ(19, point);
+}
+
+
+TEST(FastFixedDtoaGayFixed) {
+  char buffer_container[kBufferSize];
+  Vector<char> buffer(buffer_container, kBufferSize);
+  bool status;
+  int length;
+  int point;
+
+  Vector<const PrecomputedFixed> precomputed =
+      PrecomputedFixedRepresentations();
+  for (int i = 0; i < precomputed.length(); ++i) {
+    const PrecomputedFixed current_test = precomputed[i];
+    double v = current_test.v;
+    int number_digits = current_test.number_digits;
+    status = FastFixedDtoa(v, number_digits,
+                           buffer, &length, &point);
+    CHECK(status);
+    CHECK_EQ(current_test.decimal_point, point);
+    CHECK_GE(number_digits, length - point);
+    CHECK_EQ(current_test.representation, buffer.start());
+  }
+}

tools/gyp/v8.gyp

@@ -276,6 +276,8 @@
         '../../src/disasm.h',
         '../../src/disassembler.cc',
         '../../src/disassembler.h',
+        '../../src/dtoa.cc',
+        '../../src/dtoa.h',
         '../../src/dtoa-config.c',
         '../../src/diy-fp.cc',
         '../../src/diy-fp.h',
@@ -288,6 +290,8 @@
         '../../src/fast-dtoa.cc',
         '../../src/fast-dtoa.h',
         '../../src/flag-definitions.h',
+        '../../src/fixed-dtoa.cc',
+        '../../src/fixed-dtoa.h',
         '../../src/flags.cc',
         '../../src/flags.h',
         '../../src/flow-graph.cc',