Skip to content
Browse files

Fast double-to-ascii conversion.

  • Loading branch information...
1 parent 61e9ff6 commit dfa19a5d9d6074aec6b40fb500df684eaa8704df floitschV8@gmail.com committed Mar 11, 2010
View
1 src/SConscript
@@ -63,6 +63,7 @@ SOURCES = {
full-codegen.cc
func-name-inferrer.cc
global-handles.cc
+ grisu3.cc
handles.cc
hashmap.cc
heap-profiler.cc
View
119 src/cached_powers.h
@@ -0,0 +1,119 @@
+// 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_CACHED_POWERS_H_
+#define V8_CACHED_POWERS_H_
+
+#include "diy_fp.h"
+
+namespace v8 {
+namespace internal {
+
+struct CachedPower {
+ uint64_t significand;
+ int16_t binary_exponent;
+ int16_t decimal_exponent;
+};
+
+// The following defines implement the interface between this file and the
+// generated 'powers_ten.h'.
+// GRISU_CACHE_NAME(1) contains all possible cached powers.
+// GRISU_CACHE_NAME(i) contains GRISU_CACHE_NAME(1) where only every 'i'th
+// element is kept. More formally GRISU_CACHE_NAME(i) contains the elements j*i
+// with 0 <= j < k with k such that j*k < the size of GRISU_CACHE_NAME(1).
+// The higher 'i' is the fewer elements we use.
+// Given that there are less elements, the exponent-distance between two
+// elements in the cache grows. The variable GRISU_CACHE_MAX_DISTANCE(i) stores
+// the maximum distance between two elements.
+#define GRISU_CACHE_STRUCT CachedPower
+#define GRISU_CACHE_NAME(i) kCachedPowers##i
+#define GRISU_CACHE_MAX_DISTANCE(i) kCachedPowersMaxDistance##i
+#define GRISU_CACHE_OFFSET kCachedPowerOffset
+#define GRISU_UINT64_C V8_2PART_UINT64_C
+// The following include imports the precompiled cached powers.
+#include "powers_ten.h" // NOLINT
+
+static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
+
+// We can't use a function since we reference variables depending on the 'i'.
+// This way the compiler is able to see at compile time that only one
+// cache-array variable is used and thus can remove all the others.
+#define COMPUTE_FOR_CACHE(i) \
+ if (!found && (gamma - alpha + 1 >= GRISU_CACHE_MAX_DISTANCE(i))) { \
+ int kQ = DiyFp::kSignificandSize; \
+ double k = ceiling((alpha - e + kQ - 1) * kD_1_LOG2_10); \
+ int index = (GRISU_CACHE_OFFSET + static_cast<int>(k) - 1) / i + 1; \
+ cached_power = GRISU_CACHE_NAME(i)[index]; \
+ found = true; \
+ } \
+
+static void GetCachedPower(int e, int alpha, int gamma, int* mk, DiyFp* c_mk) {
+ // The following if statement should be optimized by the compiler so that only
+ // one array is referenced and the others are not included in the object file.
+ bool found = false;
+ CachedPower cached_power;
+ COMPUTE_FOR_CACHE(20);
+ COMPUTE_FOR_CACHE(19);
+ COMPUTE_FOR_CACHE(18);
+ COMPUTE_FOR_CACHE(17);
+ COMPUTE_FOR_CACHE(16);
+ COMPUTE_FOR_CACHE(15);
+ COMPUTE_FOR_CACHE(14);
+ COMPUTE_FOR_CACHE(13);
+ COMPUTE_FOR_CACHE(12);
+ COMPUTE_FOR_CACHE(11);
+ COMPUTE_FOR_CACHE(10);
+ COMPUTE_FOR_CACHE(9);
+ COMPUTE_FOR_CACHE(8);
+ COMPUTE_FOR_CACHE(7);
+ COMPUTE_FOR_CACHE(6);
+ COMPUTE_FOR_CACHE(5);
+ COMPUTE_FOR_CACHE(4);
+ COMPUTE_FOR_CACHE(3);
+ COMPUTE_FOR_CACHE(2);
+ COMPUTE_FOR_CACHE(1);
+ if (!found) {
+ UNIMPLEMENTED();
+ // Silence compiler warnings.
+ cached_power.significand = 0;
+ cached_power.binary_exponent = 0;
+ cached_power.decimal_exponent = 0;
+ }
+ *c_mk = DiyFp(cached_power.significand, cached_power.binary_exponent);
+ *mk = cached_power.decimal_exponent;
+ ASSERT((alpha <= c_mk->e() + e) && (c_mk->e() + e <= gamma));
+}
+#undef GRISU_REDUCTION
+#undef GRISU_CACHE_STRUCT
+#undef GRISU_CACHE_NAME
+#undef GRISU_CACHE_MAX_DISTANCE
+#undef GRISU_CACHE_OFFSET
+#undef GRISU_UINT64_C
+
+} } // namespace v8::internal
+
+#endif // V8_CACHED_POWERS_H_
View
22 src/checks.h
@@ -80,6 +80,7 @@ static inline void CheckEqualsHelper(const char* file, int line,
}
}
+
// Helper function used by the CHECK_EQ function when given int64_t
// arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, int line,
@@ -202,6 +203,27 @@ static inline void CheckEqualsHelper(const char* file,
}
+static inline void CheckNonEqualsHelper(const char* file,
+ int line,
+ const char* expected_source,
+ double expected,
+ const char* value_source,
+ double value) {
+ // Force values to 64 bit memory to truncate 80 bit precision on IA32.
+ volatile double* exp = new double[1];
+ *exp = expected;
+ volatile double* val = new double[1];
+ *val = value;
+ if (*exp == *val) {
+ V8_Fatal(file, line,
+ "CHECK_NE(%s, %s) failed\n# Value: %f",
+ expected_source, value_source, *val);
+ }
+ delete[] exp;
+ delete[] val;
+}
+
+
namespace v8 {
class Value;
template <class T> class Handle;
View
16 src/conversions.cc
@@ -31,6 +31,7 @@
#include "conversions-inl.h"
#include "factory.h"
+#include "grisu3.h"
#include "scanner.h"
namespace v8 {
@@ -382,8 +383,17 @@ const char* DoubleToCString(double v, Vector<char> buffer) {
int decimal_point;
int sign;
- char* decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
- int length = StrLength(decimal_rep);
+ char* decimal_rep;
+ bool used_dtoa = false;
+ char grisu_buffer[kGrisu3MaximalLength + 1];
+ int length;
+ if (grisu3(v, grisu_buffer, &sign, &length, &decimal_point)) {
+ decimal_rep = grisu_buffer;
+ } else {
+ decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
+ used_dtoa = true;
+ length = StrLength(decimal_rep);
+ }
if (sign) builder.AddCharacter('-');
@@ -418,7 +428,7 @@ const char* DoubleToCString(double v, Vector<char> buffer) {
builder.AddFormatted("%d", exponent);
}
- freedtoa(decimal_rep);
+ if (used_dtoa) freedtoa(decimal_rep);
}
}
return builder.Finalize();
View
136 src/diy_fp.h
@@ -0,0 +1,136 @@
+// 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_DIY_FP_H_
+#define V8_DIY_FP_H_
+
+namespace v8 {
+namespace internal {
+
+// This "Do It Yourself Floating Point" class implements a floating-point number
+// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
+// have the most significant bit of the significand set.
+// Multiplication and Subtraction do not normalize their results.
+// DiyFp are not designed to contain special doubles (NaN and Infinity).
+class DiyFp {
+ public:
+ static const int kSignificandSize = 64;
+
+ DiyFp() : f_(0), e_(0) {}
+ DiyFp(uint64_t f, int e) : f_(f), e_(e) {}
+
+ // this = this - other.
+ // The exponents of both numbers must be the same and the significand of this
+ // must be bigger than the significand of other.
+ // The result will not be normalized.
+ void Subtract(const DiyFp& other) {
+ ASSERT(e_ == other.e_);
+ ASSERT(f_ >= other.f_);
+ f_ -= other.f_;
+ }
+
+ // Returns a - b.
+ // The exponents of both numbers must be the same and this must be bigger
+ // than other. The result will not be normalized.
+ static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
+ DiyFp result = a;
+ result.Subtract(b);
+ return result;
+ }
+
+
+ // this = this * other.
+ void Multiply(const DiyFp& other) {
+ // Simply "emulates" a 128 bit multiplication.
+ // However: the resulting number only contains 64 bits. The least
+ // significant 64 bits are only used for rounding the most significant 64
+ // bits.
+ const uint64_t kM32 = 0xFFFFFFFFu;
+ uint64_t a = f_ >> 32;
+ uint64_t b = f_ & kM32;
+ uint64_t c = other.f_ >> 32;
+ uint64_t d = other.f_ & kM32;
+ uint64_t ac = a * c;
+ uint64_t bc = b * c;
+ uint64_t ad = a * d;
+ uint64_t bd = b * d;
+ uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32);
+ tmp += 1U << 31; // round
+ uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ e_ += other.e_ + 64;
+ f_ = result_f;
+ }
+
+ // returns a * b;
+ static DiyFp Times(const DiyFp& a, const DiyFp& b) {
+ DiyFp result = a;
+ result.Multiply(b);
+ return result;
+ }
+
+ void Normalize() {
+ ASSERT(f_ != 0);
+ uint64_t f = f_;
+ int e = e_;
+
+ // This method is mainly called for normalizing boundaries. In general
+ // boundaries need to be shifted by 10 bits. We thus optimize for this case.
+ const uint64_t k10MSBits = V8_2PART_UINT64_C(0xFFC00000, 00000000);
+ while ((f & k10MSBits) == 0) {
+ f <<= 10;
+ e -= 10;
+ }
+ while ((f & kUint64MSB) == 0) {
+ f <<= 1;
+ e--;
+ }
+ f_ = f;
+ e_ = e;
+ }
+
+ static DiyFp Normalize(const DiyFp& a) {
+ DiyFp result = a;
+ result.Normalize();
+ return result;
+ }
+
+ uint64_t f() const { return f_; }
+ int e() const { return e_; }
+
+ void set_f(uint64_t new_value) { f_ = new_value; }
+ void set_e(int new_value) { e_ = new_value; }
+
+ private:
+ static const uint64_t kUint64MSB = V8_2PART_UINT64_C(0x80000000, 00000000);
+
+ uint64_t f_;
+ int e_;
+};
+
+} } // namespace v8::internal
+
+#endif // V8_DIY_FP_H_
View
169 src/double.h
@@ -0,0 +1,169 @@
+// 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_DOUBLE_H_
+#define V8_DOUBLE_H_
+
+#include "diy_fp.h"
+
+namespace v8 {
+namespace internal {
+
+// We assume that doubles and uint64_t have the same endianness.
+static uint64_t double_to_uint64(double d) { return bit_cast<uint64_t>(d); }
+static double uint64_to_double(uint64_t d64) { return bit_cast<double>(d64); }
+
+// Helper functions for doubles.
+class Double {
+ public:
+ static const uint64_t kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000);
+ static const uint64_t kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000);
+ static const uint64_t kSignificandMask =
+ V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
+ static const uint64_t kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000);
+
+ Double() : d64_(0) {}
+ explicit Double(double d) : d64_(double_to_uint64(d)) {}
+ explicit Double(uint64_t d64) : d64_(d64) {}
+
+ DiyFp AsDiyFp() const {
+ ASSERT(!IsSpecial());
+ return DiyFp(Significand(), Exponent());
+ }
+
+ // this->Significand() must not be 0.
+ DiyFp AsNormalizedDiyFp() const {
+ uint64_t f = Significand();
+ int e = Exponent();
+
+ ASSERT(f != 0);
+
+ // The current double could be a denormal.
+ while ((f & kHiddenBit) == 0) {
+ f <<= 1;
+ e--;
+ }
+ // Do the final shifts in one go. Don't forget the hidden bit (the '-1').
+ f <<= DiyFp::kSignificandSize - kSignificandSize - 1;
+ e -= DiyFp::kSignificandSize - kSignificandSize - 1;
+ return DiyFp(f, e);
+ }
+
+ // Returns the double's bit as uint64.
+ uint64_t AsUint64() const {
+ return d64_;
+ }
+
+ int Exponent() const {
+ if (IsDenormal()) return kDenormalExponent;
+
+ uint64_t d64 = AsUint64();
+ int biased_e = static_cast<int>((d64 & kExponentMask) >> kSignificandSize);
+ return biased_e - kExponentBias;
+ }
+
+ uint64_t Significand() const {
+ uint64_t d64 = AsUint64();
+ uint64_t significand = d64 & kSignificandMask;
+ if (!IsDenormal()) {
+ return significand + kHiddenBit;
+ } else {
+ return significand;
+ }
+ }
+
+ // Returns true if the double is a denormal.
+ bool IsDenormal() const {
+ uint64_t d64 = AsUint64();
+ return (d64 & kExponentMask) == 0;
+ }
+
+ // We consider denormals not to be special.
+ // Hence only Infinity and NaN are special.
+ bool IsSpecial() const {
+ uint64_t d64 = AsUint64();
+ return (d64 & kExponentMask) == kExponentMask;
+ }
+
+ bool IsNan() const {
+ uint64_t d64 = AsUint64();
+ return ((d64 & kExponentMask) == kExponentMask) &&
+ ((d64 & kSignificandMask) != 0);
+ }
+
+
+ bool IsInfinite() const {
+ uint64_t d64 = AsUint64();
+ return ((d64 & kExponentMask) == kExponentMask) &&
+ ((d64 & kSignificandMask) == 0);
+ }
+
+
+ int Sign() const {
+ uint64_t d64 = AsUint64();
+ return (d64 & kSignMask) == 0? 1: -1;
+ }
+
+
+ // Returns the two boundaries of this.
+ // The bigger boundary (m_plus) is normalized. The lower boundary has the same
+ // exponent as m_plus.
+ void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
+ DiyFp v = this->AsDiyFp();
+ bool significand_is_zero = (v.f() == kHiddenBit);
+ DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
+ DiyFp m_minus;
+ if (significand_is_zero && v.e() != kDenormalExponent) {
+ // The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
+ // Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
+ // at a distance of 1e8.
+ // The only exception is for the smallest normal: the largest denormal is
+ // at the same distance as its successor.
+ // Note: denormals have the same exponent as the smallest normals.
+ m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2);
+ } else {
+ m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1);
+ }
+ m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e()));
+ m_minus.set_e(m_plus.e());
+ *out_m_plus = m_plus;
+ *out_m_minus = m_minus;
+ }
+
+ double value() const { return uint64_to_double(d64_); }
+
+ private:
+ static const int kSignificandSize = 52; // Excludes the hidden bit.
+ static const int kExponentBias = 0x3FF + kSignificandSize;
+ static const int kDenormalExponent = -kExponentBias + 1;
+
+ uint64_t d64_;
+};
+
+} } // namespace v8::internal
+
+#endif // V8_DOUBLE_H_
View
5 src/globals.h
@@ -98,6 +98,11 @@ typedef byte* Address;
#define V8_PTR_PREFIX ""
#endif // V8_HOST_ARCH_64_BIT
+// The following macro works on both 32 and 64-bit platforms.
+// Usage: instead of writing 0x1234567890123456
+// write V8_2PART_UINT64_C(0x12345678,90123456);
+#define V8_2PART_UINT64_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
+
#define V8PRIxPTR V8_PTR_PREFIX "x"
#define V8PRIdPTR V8_PTR_PREFIX "d"
View
494 src/grisu3.cc
@@ -0,0 +1,494 @@
+// 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 "v8.h"
+
+#include "grisu3.h"
+
+#include "cached_powers.h"
+#include "diy_fp.h"
+#include "double.h"
+
+namespace v8 {
+namespace internal {
+
+template <int alpha = -60, int gamma = -32>
+class Grisu3 {
+ public:
+ // Provides a decimal representation of v.
+ // Returns true if it succeeds, otherwise the result can not be trusted.
+ // There will be *length digits inside the buffer (not null-terminated).
+ // If the function returns true then
+ // v == (double) (buffer * 10^decimal_exponent).
+ // The digits in the buffer are the shortest representation possible: no
+ // 0.099999999999 instead of 0.1.
+ // The last digit will be closest to the actual v. That is, even if several
+ // digits might correctly yield 'v' when read again, the closest will be
+ // computed.
+ static bool grisu3(double v,
+ char* buffer, int* length, int* decimal_exponent);
+
+ private:
+ // Rounds the buffer according to the rest.
+ // If there is too much imprecision to round then false is returned.
+ // Similarily false is returned when the buffer is not within Delta.
+ static bool RoundWeed(char* buffer, int len, uint64_t wp_W, uint64_t Delta,
+ uint64_t rest, uint64_t ten_kappa, uint64_t ulp);
+ // Dispatches to the a specialized digit-generation routine. The chosen
+ // routine depends on w.e (which in turn depends on alpha and gamma).
+ // Currently there is only one digit-generation routine, but it would be easy
+ // to add others.
+ static bool DigitGen(DiyFp low, DiyFp w, DiyFp high,
+ char* buffer, int* len, int* kappa);
+ // Generates w's digits. The result is the shortest in the interval low-high.
+ // All DiyFp are assumed to be imprecise and this function takes this
+ // imprecision into account. If the function cannot compute the best
+ // representation (due to the imprecision) then false is returned.
+ static bool DigitGen_m60_m32(DiyFp low, DiyFp w, DiyFp high,
+ char* buffer, int* length, int* kappa);
+};
+
+
+template<int alpha, int gamma>
+bool Grisu3<alpha, gamma>::grisu3(double v,
+ char* buffer,
+ int* length,
+ int* decimal_exponent) {
+ DiyFp w = Double(v).AsNormalizedDiyFp();
+ // boundary_minus and boundary_plus are the boundaries between v and its
+ // neighbors. Any number strictly between boundary_minus and boundary_plus
+ // will round to v when read as double.
+ // Grisu3 will never output representations that lie exactly on a boundary.
+ DiyFp boundary_minus, boundary_plus;
+ Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+ ASSERT(boundary_plus.e() == w.e());
+ DiyFp ten_mk; // Cached power of ten: 10^-k
+ int mk; // -k
+ GetCachedPower(w.e() + DiyFp::kSignificandSize, alpha, gamma, &mk, &ten_mk);
+ ASSERT(alpha <= w.e() + ten_mk.e() + DiyFp::kSignificandSize &&
+ gamma >= w.e() + ten_mk.e() + DiyFp::kSignificandSize);
+ // Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
+ // 64 bit significand and ten_mk is thus only precise up to 64 bits.
+
+ // The DiyFp::Times procedure rounds its result, and ten_mk is approximated
+ // too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
+ // off by a small amount.
+ // In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
+ // In other words: let f = scaled_w.f() and e = scaled_w.e(), then
+ // (f-1) * 2^e < w*10^k < (f+1) * 2^e
+ DiyFp scaled_w = DiyFp::Times(w, ten_mk);
+ ASSERT(scaled_w.e() ==
+ boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize);
+ // In theory it would be possible to avoid some recomputations by computing
+ // the difference between w and boundary_minus/plus (a power of 2) and to
+ // compute scaled_boundary_minus/plus by subtracting/adding from
+ // scaled_w. However the code becomes much less readable and the speed
+ // enhancements are not terriffic.
+ DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk);
+ DiyFp scaled_boundary_plus = DiyFp::Times(boundary_plus, ten_mk);
+
+ // DigitGen will generate the digits of scaled_w. Therefore we have
+ // v == (double) (scaled_w * 10^-mk).
+ // Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
+ // integer than it will be updated. For instance if scaled_w == 1.23 then
+ // the buffer will be filled with "123" und the decimal_exponent will be
+ // decreased by 2.
+ int kappa;
+ bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus,
+ buffer, length, &kappa);
+ *decimal_exponent = -mk + kappa;
+ return result;
+}
+
+// Generates the digits of input number w.
+// w is a floating-point number (DiyFp), consisting of a significand and an
+// exponent. Its exponent is bounded by alpha and gamma. Typically alpha >= -63
+// and gamma <= 3.
+// Returns false if it fails, in which case the generated digits in the buffer
+// should not be used.
+// Preconditions:
+// * low, w and high are correct up to 1 ulp (unit in the last place). That
+// is, their error must be less that a unit of their last digits.
+// * low.e() == w.e() == high.e()
+// * low < w < high, and taking into account their error: low~ <= high~
+// * alpha <= w.e() <= gamma
+// Postconditions: returns false if procedure fails.
+// otherwise:
+// * buffer is not null-terminated, but len contains the number of digits.
+// * buffer contains the shortest possible decimal digit-sequence
+// such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
+// correct values of low and high (without their error).
+// * if more than one decimal representation gives the minimal number of
+// decimal digits then the one closest to W (where W is the correct value
+// of w) is chosen.
+// Remark: this procedure takes into account the imprecision of its input
+// numbers. If the precision is not enough to guarantee all the postconditions
+// then false is returned. This usually happens rarely (~0.5%).
+template<int alpha, int gamma>
+bool Grisu3<alpha, gamma>::DigitGen(DiyFp low,
+ DiyFp w,
+ DiyFp high,
+ char* buffer,
+ int* len,
+ int* kappa) {
+ ASSERT(low.e() == w.e() && w.e() == high.e());
+ ASSERT(low.f() + 1 <= high.f() - 1);
+ ASSERT(alpha <= w.e() && w.e() <= gamma);
+ // The following tests use alpha and gamma to avoid unnecessary dynamic tests.
+ if ((alpha >= -60 && gamma <= -32) || // -60 <= w.e() <= -32
+ (alpha <= -32 && gamma >= -60 && // Alpha/gamma overlaps -60/-32 region.
+ -60 <= w.e() && w.e() <= -32)) {
+ return DigitGen_m60_m32(low, w, high, buffer, len, kappa);
+ } else {
+ // A simple adaption of the special case -60/-32 would allow greater ranges
+ // of alpha/gamma and thus reduce the number of precomputed cached powers of
+ // ten.
+ UNIMPLEMENTED();
+ return false;
+ }
+}
+
+static const uint32_t kTen4 = 10000;
+static const uint32_t kTen5 = 100000;
+static const uint32_t kTen6 = 1000000;
+static const uint32_t kTen7 = 10000000;
+static const uint32_t kTen8 = 100000000;
+static const uint32_t kTen9 = 1000000000;
+
+// Returns the biggest power of ten that is <= than the given number. We
+// furthermore receive the maximum number of bits 'number' has.
+// If number_bits == 0 then 0^-1 is returned
+// The number of bits must be <= 32.
+static void BiggestPowerTen(uint32_t number,
+ int number_bits,
+ uint32_t* power,
+ int* exponent) {
+ switch (number_bits) {
+ case 32:
+ case 31:
+ case 30:
+ if (kTen9 <= number) {
+ *power = kTen9;
+ *exponent = 9;
+ break;
+ } // else fallthrough
+ case 29:
+ case 28:
+ case 27:
+ if (kTen8 <= number) {
+ *power = kTen8;
+ *exponent = 8;
+ break;
+ } // else fallthrough
+ case 26:
+ case 25:
+ case 24:
+ if (kTen7 <= number) {
+ *power = kTen7;
+ *exponent = 7;
+ break;
+ } // else fallthrough
+ case 23:
+ case 22:
+ case 21:
+ case 20:
+ if (kTen6 <= number) {
+ *power = kTen6;
+ *exponent = 6;
+ break;
+ } // else fallthrough
+ case 19:
+ case 18:
+ case 17:
+ if (kTen5 <= number) {
+ *power = kTen5;
+ *exponent = 5;
+ break;
+ } // else fallthrough
+ case 16:
+ case 15:
+ case 14:
+ if (kTen4 <= number) {
+ *power = kTen4;
+ *exponent = 4;
+ break;
+ } // else fallthrough
+ case 13:
+ case 12:
+ case 11:
+ case 10:
+ if (1000 <= number) {
+ *power = 1000;
+ *exponent = 3;
+ break;
+ } // else fallthrough
+ case 9:
+ case 8:
+ case 7:
+ if (100 <= number) {
+ *power = 100;
+ *exponent = 2;
+ break;
+ } // else fallthrough
+ case 6:
+ case 5:
+ case 4:
+ if (10 <= number) {
+ *power = 10;
+ *exponent = 1;
+ break;
+ } // else fallthrough
+ case 3:
+ case 2:
+ case 1:
+ if (1 <= number) {
+ *power = 1;
+ *exponent = 0;
+ break;
+ } // else fallthrough
+ case 0:
+ *power = 0;
+ *exponent = -1;
+ break;
+ default:
+ // Following assignments are here to silence compiler warnings.
+ *power = 0;
+ *exponent = 0;
+ UNREACHABLE();
+ }
+}
+
+
+// Same comments as for DigitGen but with additional precondition:
+// -60 <= w.e() <= -32
+//
+// Say, for the sake of example, that
+// w.e() == -48, and w.f() == 0x1234567890abcdef
+// w's value can be computed by w.f() * 2^w.e()
+// We can obtain w's integral digits by simply shifting w.f() by -w.e().
+// -> w's integral part is 0x1234
+// 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
+// (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
+// represent 'w' we can stop. Everything inside the interval low - high
+// represents w. However we have to pay attention to low, high and w's
+// imprecision.
+template<int alpha, int gamma>
+bool Grisu3<alpha, gamma>::DigitGen_m60_m32(DiyFp low,
+ DiyFp w,
+ DiyFp high,
+ char* buffer,
+ int* length,
+ int* kappa) {
+ // low, w and high are imprecise, but by less than one ulp (unit in the last
+ // place).
+ // If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
+ // the new numbers are outside of the interval we want the final
+ // representation to lie in.
+ // Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
+ // numbers that are certain to lie in the interval. We will use this fact
+ // later on.
+ // We will now start by generating the digits within the uncertain
+ // interval. Later we will weed out representations that lie outside the safe
+ // interval and thus _might_ lie outside the correct interval.
+ uint64_t unit = 1;
+ DiyFp too_low = DiyFp(low.f() - unit, low.e());
+ DiyFp too_high = DiyFp(high.f() + unit, high.e());
+ // too_low and too_high are guaranteed to lie outside the interval we want the
+ // generated number in.
+ DiyFp unsafe_interval = DiyFp::Minus(too_high, too_low);
+ // We now cut the input number into two parts: the integral digits and the
+ // fractionals. We will not write any decimal separator though, but adapt
+ // kappa instead.
+ // Reminder: we are currently computing the digits (stored inside the buffer)
+ // such that: too_low < buffer * 10^kappa < too_high
+ // We use too_high for the digit_generation and stop as soon as possible.
+ // If we stop early we effectively round down.
+ DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e());
+ // Division by one is a shift.
+ uint32_t integrals = static_cast<uint32_t>(too_high.f() >> -one.e());
+ // Modulo by one is an and.
+ uint64_t fractionals = too_high.f() & (one.f() - 1);
+ uint32_t divider;
+ int divider_exponent;
+ BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()),
+ &divider, &divider_exponent);
+ *kappa = divider_exponent + 1;
+ *length = 0;
+ // Loop invariant: buffer = too_high / 10^kappa (integer division)
+ // The invariant holds for the first iteration: kappa has been initialized
+ // with the divider exponent + 1. And the divider is the biggest power of ten
+ // that is smaller than integrals.
+ while (*kappa > 0) {
+ int digit = integrals / divider;
+ buffer[*length] = '0' + digit;
+ (*length)++;
+ integrals %= divider;
+ (*kappa)--;
+ // Note that kappa now equals the exponent of the divider and that the
+ // invariant thus holds again.
+ uint64_t rest =
+ (static_cast<uint64_t>(integrals) << -one.e()) + fractionals;
+ // Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
+ // Reminder: unsafe_interval.e() == one.e()
+ if (rest < unsafe_interval.f()) {
+ // Rounding down (by not emitting the remaining digits) yields a number
+ // that lies within the unsafe interval.
+ return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(),
+ unsafe_interval.f(), rest,
+ static_cast<uint64_t>(divider) << -one.e(), unit);
+ }
+ divider /= 10;
+ }
+
+ // The integrals have been generated. We are at the point of the decimal
+ // separator. In the following loop we simply multiply the remaining digits by
+ // 10 and divide by one. We just need to pay attention to multiply associated
+ // data (like the interval or 'unit'), too.
+ // Instead of multiplying by 10 we multiply by 5 (cheaper operation) and
+ // increase its (imaginary) exponent. At the same time we decrease the
+ // divider's (one's) exponent and shift its significand.
+ // Basically, if fractionals was a DiyFp (with fractionals.e == one.e):
+ // fractionals.f *= 10;
+ // fractionals.f >>= 1; fractionals.e++; // value remains unchanged.
+ // one.f >>= 1; one.e++; // value remains unchanged.
+ // and we have again fractionals.e == one.e which allows us to divide
+ // fractionals.f() by one.f()
+ // We simply combine the *= 10 and the >>= 1.
+ while (true) {
+ fractionals *= 5;
+ unit *= 5;
+ unsafe_interval.set_f(unsafe_interval.f() * 5);
+ unsafe_interval.set_e(unsafe_interval.e() + 1); // Will be optimized out.
+ one.set_f(one.f() >> 1);
+ one.set_e(one.e() + 1);
+ // Integer division by one.
+ int digit = static_cast<int>(fractionals >> -one.e());
+ buffer[*length] = '0' + digit;
+ (*length)++;
+ fractionals &= one.f() - 1; // Modulo by one.
+ (*kappa)--;
+ if (fractionals < unsafe_interval.f()) {
+ return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit,
+ unsafe_interval.f(), fractionals, one.f(), unit);
+ }
+ }
+}
+
+
+// Rounds the given generated digits in the buffer and weeds out generated
+// digits that are not in the safe interval, or where we cannot find a rounded
+// representation.
+// Input: * buffer containing the digits of too_high / 10^kappa
+// * the buffer's length
+// * distance_too_high_w == (too_high - w).f() * unit
+// * unsafe_interval == (too_high - too_low).f() * unit
+// * rest = (too_high - buffer * 10^kappa).f() * unit
+// * ten_kappa = 10^kappa * unit
+// * unit = the common multiplier
+// Output: returns true on success.
+// Modifies the generated digits in the buffer to approach (round towards) w.
+template<int alpha, int gamma>
+bool Grisu3<alpha, gamma>::RoundWeed(char* buffer,
+ int length,
+ uint64_t distance_too_high_w,
+ uint64_t unsafe_interval,
+ uint64_t rest,
+ uint64_t ten_kappa,
+ uint64_t unit) {
+ uint64_t small_distance = distance_too_high_w - unit;
+ uint64_t big_distance = distance_too_high_w + unit;
+ // Let w- = too_high - big_distance, and
+ // w+ = too_high - small_distance.
+ // Note: w- < w < w+
+ //
+ // The real w (* unit) must lie somewhere inside the interval
+ // ]w-; w+[ (often written as "(w-; w+)")
+
+ // Basically the buffer currently contains a number in the unsafe interval
+ // ]too_low; too_high[ with too_low < w < too_high
+ //
+ // By generating the digits of too_high we got the biggest last digit.
+ // In the case that w+ < buffer < too_high we try to decrement the buffer.
+ // This way the buffer approaches (rounds towards) w.
+ // There are 3 conditions that stop the decrementation process:
+ // 1) the buffer is already below w+
+ // 2) decrementing the buffer would make it leave the unsafe interval
+ // 3) decrementing the buffer would yield a number below w+ and farther away
+ // than the current number. In other words:
+ // (buffer{-1} < w+) && w+ - buffer{-1} > buffer - w+
+ // Instead of using the buffer directly we use its distance to too_high.
+ // Conceptually rest ~= too_high - buffer
+ while (rest < small_distance && // Negated condition 1
+ unsafe_interval - rest >= ten_kappa && // Negated condition 2
+ (rest + ten_kappa < small_distance || // buffer{-1} > w+
+ small_distance - rest >= rest + ten_kappa - small_distance)) {
+ buffer[length - 1]--;
+ rest += ten_kappa;
+ }
+
+ // We have approached w+ as much as possible. We now test if approaching w-
+ // would require changing the buffer. If yes, then we have two possible
+ // representations close to w, but we cannot decide which one is closer.
+ if (rest < big_distance &&
+ unsafe_interval - rest >= ten_kappa &&
+ (rest + ten_kappa < big_distance ||
+ big_distance - rest > rest + ten_kappa - big_distance)) {
+ return false;
+ }
+
+ // Weeding test.
+ // The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
+ // Since too_low = too_high - unsafe_interval this is equivalent too
+ // [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
+ // Conceptually we have: rest ~= too_high - buffer
+ return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit);
+}
+
+
+bool grisu3(double v, char* buffer, int* sign, int* length, int* point) {
+ ASSERT(v != 0);
+ ASSERT(!Double(v).IsSpecial());
+
+ if (v < 0) {
+ v = -v;
+ *sign = 1;
+ } else {
+ *sign = 0;
+ }
+ int decimal_exponent;
+ bool result = Grisu3<-60, -32>::grisu3(v, buffer, length, &decimal_exponent);
+ *point = *length + decimal_exponent;
+ buffer[*length] = '\0';
+ return result;
+}
+
+} } // namespace v8::internal
View
55 src/grisu3.h
@@ -0,0 +1,55 @@
+// 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_GRISU3_H_
+#define V8_GRISU3_H_
+
+namespace v8 {
+namespace internal {
+
+// Grisu3 will produce at most kGrisu3MaximalLength digits. This does not
+// include the terminating '\0' character.
+static const int kGrisu3MaximalLength = 17;
+
+// Provides a decimal representation of v.
+// v must satisfy v != 0 and it must not be Infinity or NaN.
+// 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
+// v == (double) (buffer * 10^(decimal-point - length)).
+// The digits in the buffer are the shortest representation possible: no
+// 0.099999999999 instead of 0.1.
+// The last digit will be closest to the actual v. That is, even if several
+// digits might correctly yield 'v' when read again, the buffer will contain the
+// one closest to v.
+// The variable 'sign' will be '0' if the given number is positive, and '1'
+// otherwise.
+bool grisu3(double d, char* buffer, int* sign, int* length, int* decimal_point);
+
+} } // namespace v8::internal
+
+#endif // V8_GRISU3_H_
View
2,461 src/powers_ten.h
2,461 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
4 test/cctest/SConscript
@@ -34,6 +34,7 @@ Import('context object_files')
SOURCES = {
'all': [
+ 'gay_shortest.cc',
'test-accessors.cc',
'test-alloc.cc',
'test-api.cc',
@@ -43,8 +44,11 @@ SOURCES = {
'test-dataflow.cc',
'test-debug.cc',
'test-decls.cc',
+ 'test-diy_fp.cc',
+ 'test-double.cc',
'test-flags.cc',
'test-func-name-inference.cc',
+ 'test-grisu3.cc',
'test-hashmap.cc',
'test-heap.cc',
'test-heap-profiler.cc',
View
100,048 test/cctest/gay_shortest.cc
100,048 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
44 test/cctest/gay_shortest.h
@@ -0,0 +1,44 @@
+// 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_SHORTEST_H_
+#define GAY_SHORTEST_H_
+
+namespace v8 {
+namespace internal {
+
+struct GayShortest {
+ double v;
+ const char* representation;
+ int decimal_point;
+};
+
+Vector<const GayShortest> PrecomputedShortestRepresentations();
+
+} } // namespace v8::internal
+
+#endif // GAY_SHORTEST_H_
View
67 test/cctest/test-diy_fp.cc
@@ -0,0 +1,67 @@
+// Copyright 2006-2008 the V8 project authors. All rights reserved.
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "platform.h"
+#include "cctest.h"
+#include "diy_fp.h"
+
+
+using namespace v8::internal;
+
+
+TEST(Subtract) {
+ DiyFp diy_fp1 = DiyFp(3, 0);
+ DiyFp diy_fp2 = DiyFp(1, 0);
+ DiyFp diff = DiyFp::Minus(diy_fp1, diy_fp2);
+
+ CHECK(2 == diff.f()); // NOLINT
+ CHECK_EQ(0, diff.e());
+ diy_fp1.Subtract(diy_fp2);
+ CHECK(2 == diy_fp1.f()); // NOLINT
+ CHECK_EQ(0, diy_fp1.e());
+}
+
+
+TEST(Multiply) {
+ DiyFp diy_fp1 = DiyFp(3, 0);
+ DiyFp diy_fp2 = DiyFp(2, 0);
+ DiyFp product = DiyFp::Times(diy_fp1, diy_fp2);
+
+ CHECK(0 == product.f()); // NOLINT
+ CHECK_EQ(64, product.e());
+ diy_fp1.Multiply(diy_fp2);
+ CHECK(0 == diy_fp1.f()); // NOLINT
+ CHECK_EQ(64, diy_fp1.e());
+
+ diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000000), 11);
+ diy_fp2 = DiyFp(2, 13);
+ product = DiyFp::Times(diy_fp1, diy_fp2);
+ CHECK(1 == product.f()); // NOLINT
+ CHECK_EQ(11 + 13 + 64, product.e());
+
+ // Test rounding.
+ diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000001), 11);
+ diy_fp2 = DiyFp(1, 13);
+ product = DiyFp::Times(diy_fp1, diy_fp2);
+ CHECK(1 == product.f()); // NOLINT
+ CHECK_EQ(11 + 13 + 64, product.e());
+
+ diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x7fffffff, ffffffff), 11);
+ diy_fp2 = DiyFp(1, 13);
+ product = DiyFp::Times(diy_fp1, diy_fp2);
+ CHECK(0 == product.f()); // NOLINT
+ CHECK_EQ(11 + 13 + 64, product.e());
+
+ // Halfway cases are allowed to round either way. So don't check for it.
+
+ // Big numbers.
+ diy_fp1 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 11);
+ diy_fp2 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 13);
+ // 128bit result: 0xfffffffffffffffe0000000000000001
+ product = DiyFp::Times(diy_fp1, diy_fp2);
+ CHECK(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFe) == product.f());
+ CHECK_EQ(11 + 13 + 64, product.e());
+}
View
204 test/cctest/test-double.cc
@@ -0,0 +1,204 @@
+// Copyright 2006-2008 the V8 project authors. All rights reserved.
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "platform.h"
+#include "cctest.h"
+#include "diy_fp.h"
+#include "double.h"
+
+
+using namespace v8::internal;
+
+
+TEST(Uint64Conversions) {
+ // Start by checking the byte-order.
+ uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
+ CHECK_EQ(3512700564088504e-318, Double(ordered).value());
+
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ CHECK_EQ(5e-324, Double(min_double64).value());
+
+ uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
+ CHECK_EQ(1.7976931348623157e308, Double(max_double64).value());
+}
+
+TEST(AsDiyFp) {
+ uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
+ DiyFp diy_fp = Double(ordered).AsDiyFp();
+ CHECK_EQ(0x12 - 0x3FF - 52, diy_fp.e());
+ // The 52 mantissa bits, plus the implicit 1 in bit 52 as a UINT64.
+ CHECK(V8_2PART_UINT64_C(0x00134567, 89ABCDEF) == diy_fp.f()); // NOLINT
+
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ diy_fp = Double(min_double64).AsDiyFp();
+ CHECK_EQ(-0x3FF - 52 + 1, diy_fp.e());
+ // This is a denormal; so no hidden bit.
+ CHECK(1 == diy_fp.f()); // NOLINT
+
+ uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
+ diy_fp = Double(max_double64).AsDiyFp();
+ CHECK_EQ(0x7FE - 0x3FF - 52, diy_fp.e());
+ CHECK(V8_2PART_UINT64_C(0x001fffff, ffffffff) == diy_fp.f()); // NOLINT
+}
+
+
+TEST(AsNormalizedDiyFp) {
+ uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF);
+ DiyFp diy_fp = Double(ordered).AsNormalizedDiyFp();
+ CHECK_EQ(0x12 - 0x3FF - 52 - 11, diy_fp.e());
+ CHECK((V8_2PART_UINT64_C(0x00134567, 89ABCDEF) << 11) ==
+ diy_fp.f()); // NOLINT
+
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ diy_fp = Double(min_double64).AsNormalizedDiyFp();
+ CHECK_EQ(-0x3FF - 52 + 1 - 63, diy_fp.e());
+ // This is a denormal; so no hidden bit.
+ CHECK(V8_2PART_UINT64_C(0x80000000, 00000000) == diy_fp.f()); // NOLINT
+
+ uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
+ diy_fp = Double(max_double64).AsNormalizedDiyFp();
+ CHECK_EQ(0x7FE - 0x3FF - 52 - 11, diy_fp.e());
+ CHECK((V8_2PART_UINT64_C(0x001fffff, ffffffff) << 11) ==
+ diy_fp.f()); // NOLINT
+}
+
+
+TEST(IsDenormal) {
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ CHECK(Double(min_double64).IsDenormal());
+ uint64_t bits = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
+ CHECK(Double(bits).IsDenormal());
+ bits = V8_2PART_UINT64_C(0x00100000, 00000000);
+ CHECK(!Double(bits).IsDenormal());
+}
+
+
+TEST(IsSpecial) {
+ CHECK(Double(V8_INFINITY).IsSpecial());
+ CHECK(Double(-V8_INFINITY).IsSpecial());
+ CHECK(Double(OS::nan_value()).IsSpecial());
+ uint64_t bits = V8_2PART_UINT64_C(0xFFF12345, 00000000);
+ CHECK(Double(bits).IsSpecial());
+ // Denormals are not special:
+ CHECK(!Double(5e-324).IsSpecial());
+ CHECK(!Double(-5e-324).IsSpecial());
+ // And some random numbers:
+ CHECK(!Double(0.0).IsSpecial());
+ CHECK(!Double(-0.0).IsSpecial());
+ CHECK(!Double(1.0).IsSpecial());
+ CHECK(!Double(-1.0).IsSpecial());
+ CHECK(!Double(1000000.0).IsSpecial());
+ CHECK(!Double(-1000000.0).IsSpecial());
+ CHECK(!Double(1e23).IsSpecial());
+ CHECK(!Double(-1e23).IsSpecial());
+ CHECK(!Double(1.7976931348623157e308).IsSpecial());
+ CHECK(!Double(-1.7976931348623157e308).IsSpecial());
+}
+
+
+TEST(IsInfinite) {
+ CHECK(Double(V8_INFINITY).IsInfinite());
+ CHECK(Double(-V8_INFINITY).IsInfinite());
+ CHECK(!Double(OS::nan_value()).IsInfinite());
+ CHECK(!Double(0.0).IsInfinite());
+ CHECK(!Double(-0.0).IsInfinite());
+ CHECK(!Double(1.0).IsInfinite());
+ CHECK(!Double(-1.0).IsInfinite());
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ CHECK(!Double(min_double64).IsInfinite());
+}
+
+
+TEST(IsNan) {
+ CHECK(Double(OS::nan_value()).IsNan());
+ uint64_t other_nan = V8_2PART_UINT64_C(0xFFFFFFFF, 00000001);
+ CHECK(Double(other_nan).IsNan());
+ CHECK(!Double(V8_INFINITY).IsNan());
+ CHECK(!Double(-V8_INFINITY).IsNan());
+ CHECK(!Double(0.0).IsNan());
+ CHECK(!Double(-0.0).IsNan());
+ CHECK(!Double(1.0).IsNan());
+ CHECK(!Double(-1.0).IsNan());
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ CHECK(!Double(min_double64).IsNan());
+}
+
+
+TEST(Sign) {
+ CHECK_EQ(1, Double(1.0).Sign());
+ CHECK_EQ(1, Double(V8_INFINITY).Sign());
+ CHECK_EQ(-1, Double(-V8_INFINITY).Sign());
+ CHECK_EQ(1, Double(0.0).Sign());
+ CHECK_EQ(-1, Double(-0.0).Sign());
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ CHECK_EQ(1, Double(min_double64).Sign());
+}
+
+
+TEST(NormalizedBoundaries) {
+ DiyFp boundary_plus;
+ DiyFp boundary_minus;
+ DiyFp diy_fp = Double(1.5).AsNormalizedDiyFp();
+ Double(1.5).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ // 1.5 does not have a significand of the form 2^p (for some p).
+ // Therefore its boundaries are at the same distance.
+ CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
+ CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
+
+ diy_fp = Double(1.0).AsNormalizedDiyFp();
+ Double(1.0).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ // 1.0 does have a significand of the form 2^p (for some p).
+ // Therefore its lower boundary is twice as close as the upper boundary.
+ CHECK_GT(boundary_plus.f() - diy_fp.f(), diy_fp.f() - boundary_minus.f());
+ CHECK((1 << 9) == diy_fp.f() - boundary_minus.f()); // NOLINT
+ CHECK((1 << 10) == boundary_plus.f() - diy_fp.f()); // NOLINT
+
+ uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001);
+ diy_fp = Double(min_double64).AsNormalizedDiyFp();
+ Double(min_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ // min-value does not have a significand of the form 2^p (for some p).
+ // Therefore its boundaries are at the same distance.
+ CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
+ // Denormals have their boundaries much closer.
+ CHECK((static_cast<uint64_t>(1) << 62) ==
+ diy_fp.f() - boundary_minus.f()); // NOLINT
+
+ uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000);
+ diy_fp = Double(smallest_normal64).AsNormalizedDiyFp();
+ Double(smallest_normal64).NormalizedBoundaries(&boundary_minus,
+ &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ // Even though the significand is of the form 2^p (for some p), its boundaries
+ // are at the same distance. (This is the only exception).
+ CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
+ CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
+
+ uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
+ diy_fp = Double(largest_denormal64).AsNormalizedDiyFp();
+ Double(largest_denormal64).NormalizedBoundaries(&boundary_minus,
+ &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
+ CHECK((1 << 11) == diy_fp.f() - boundary_minus.f()); // NOLINT
+
+ uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff);
+ diy_fp = Double(max_double64).AsNormalizedDiyFp();
+ Double(max_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+ CHECK_EQ(diy_fp.e(), boundary_minus.e());
+ CHECK_EQ(diy_fp.e(), boundary_plus.e());
+ // max-value does not have a significand of the form 2^p (for some p).
+ // Therefore its boundaries are at the same distance.
+ CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f());
+ CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
+}
View
116 test/cctest/test-grisu3.cc
@@ -0,0 +1,116 @@
+// Copyright 2006-2008 the V8 project authors. All rights reserved.
+
+#include <stdlib.h>
+
+#include "v8.h"
+
+#include "platform.h"
+#include "cctest.h"
+#include "diy_fp.h"
+#include "double.h"
+#include "gay_shortest.h"
+#include "grisu3.h"
+
+using namespace v8::internal;
+
+static const int kBufferSize = 100;
+
+TEST(GrisuVariousDoubles) {
+ char buffer[kBufferSize];
+ int sign;
+ int length;
+ int point;
+ int status;
+
+ double min_double = 5e-324;
+ status = grisu3(min_double, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("5", buffer);
+ CHECK_EQ(-323, point);
+
+ double max_double = 1.7976931348623157e308;
+ status = grisu3(max_double, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("17976931348623157", buffer);
+ CHECK_EQ(309, point);
+
+ status = grisu3(4294967272.0, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("4294967272", buffer);
+ CHECK_EQ(10, point);
+
+ status = grisu3(4.1855804968213567e298, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("4185580496821357", buffer);
+ CHECK_EQ(299, point);
+
+ status = grisu3(5.5626846462680035e-309, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("5562684646268003", buffer);
+ CHECK_EQ(-308, point);
+
+ status = grisu3(2147483648.0, buffer, &sign, &length, &point);
+ CHECK(status);
+ CHECK_EQ(0, sign);
+ CHECK_EQ("2147483648", buffer);
+ CHECK_EQ(10, point);
+
+ status = grisu3(3.5844466002796428e+298, buffer, &sign, &length, &point);
+ if (status) { // Not all grisu3 variants manage to compute this number.
+ CHECK_EQ("35844466002796428", buffer);
+ 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 = grisu3(v, buffer, &sign, &length, &point);
+ if (status) {
+ CHECK_EQ(0, sign);
+ CHECK_EQ("22250738585072014", buffer);
+ CHECK_EQ(-307, point);
+ }
+
+ uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
+ v = Double(largest_denormal64).value();
+ status = grisu3(v, buffer, &sign, &length, &point);
+ if (status) {
+ CHECK_EQ(0, sign);
+ CHECK_EQ("2225073858507201", buffer);
+ CHECK_EQ(-307, point);
+ }
+}
+
+
+TEST(GrisuGayShortest) {
+ char buffer[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();
+ for (int i = 0; i < precomputed.length(); ++i) {
+ const GayShortest current_test = precomputed[i];
+ total++;
+ double v = current_test.v;
+ status = grisu3(v, buffer, &sign, &length, &point);
+ CHECK_GE(kGrisu3MaximalLength, length);
+ if (!status) continue;
+ if (length == kGrisu3MaximalLength) 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);
+ }
+ CHECK_GT(succeeded*1.0/total, 0.99);
+ CHECK(needed_max_length);
+}
View
286 tools/generate-ten-powers.scm
@@ -0,0 +1,286 @@
+;; 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.
+
+;; This is a Scheme script for the Bigloo compiler. Bigloo must be compiled with
+;; support for bignums. The compilation of the script can be done as follows:
+;; bigloo -static-bigloo -o generate-ten-powers generate-ten-powers.scm
+;;
+;; Generate approximations of 10^k.
+
+(module gen-ten-powers
+ (static (class Cached-Fast
+ v::bignum
+ e::bint
+ exact?::bool))
+ (main my-main))
+
+
+;;----------------bignum shifts -----------------------------------------------
+(define (bit-lshbx::bignum x::bignum by::bint)
+ (if (<fx by 0)
+ #z0
+ (*bx x (exptbx #z2 (fixnum->bignum by)))))
+
+(define (bit-rshbx::bignum x::bignum by::bint)
+ (if (<fx by 0)
+ #z0
+ (/bx x (exptbx #z2 (fixnum->bignum by)))))
+
+;;----------------the actual power generation -------------------------------
+
+;; e should be an indication. it might be too small.
+(define (round-n-cut n e nb-bits)
+ (define max-container (- (bit-lshbx #z1 nb-bits) 1))
+ (define (round n)
+ (case *round*
+ ((down) n)
+ ((up)
+ (+bx n
+ ;; with the -1 it will only round up if the cut off part is
+ ;; non-zero
+ (-bx (bit-lshbx #z1
+ (-fx (+fx e nb-bits) 1))
+ #z1)))
+ ((round)
+ (+bx n
+ (bit-lshbx #z1
+ (-fx (+fx e nb-bits) 2))))))
+ (let* ((shift (-fx (+fx e nb-bits) 1))
+ (cut (bit-rshbx (round n) shift))
+ (exact? (=bx n (bit-lshbx cut shift))))
+ (if (<=bx cut max-container)
+ (values cut e exact?)
+ (round-n-cut n (+fx e 1) nb-bits))))
+
+(define (rounded-/bx x y)
+ (case *round*
+ ((down) (/bx x y))
+ ((up) (+bx (/bx x y) #z1))
+ ((round) (let ((tmp (/bx (*bx #z2 x) y)))
+ (if (zerobx? (remainderbx tmp #z2))
+ (/bx tmp #z2)
+ (+bx (/bx tmp #z2) #z1))))))
+
+(define (generate-powers from to mantissa-size)
+ (let* ((nb-bits mantissa-size)
+ (offset (- from))
+ (nb-elements (+ (- from) to 1))
+ (vec (make-vector nb-elements))
+ (max-container (- (bit-lshbx #z1 nb-bits) 1)))
+ ;; the negative ones. 10^-1, 10^-2, etc.
+ ;; We already know, that we can't be exact, so exact? will always be #f.
+ ;; Basically we will have a ten^i that we will *10 at each iteration. We
+ ;; want to create the matissa of 1/ten^i. However the mantissa must be
+ ;; normalized (start with a 1). -> we have to shift the number.
+ ;; We shift by multiplying with two^e. -> We encode two^e*(1/ten^i) ==
+ ;; two^e/ten^i.
+ (let loop ((i 1)
+ (ten^i #z10)
+ (two^e #z1)
+ (e 0))
+ (unless (< (- i) from)
+ (if (>bx (/bx (*bx #z2 two^e) ten^i) max-container)
+ ;; another shift would make the number too big. We are
+ ;; hence normalized now.
+ (begin
+ (vector-set! vec (-fx offset i)
+ (instantiate::Cached-Fast
+ (v (rounded-/bx two^e ten^i))
+ (e (negfx e))
+ (exact? #f)))
+ (loop (+fx i 1) (*bx ten^i #z10) two^e e))
+ (loop i ten^i (bit-lshbx two^e 1) (+fx e 1)))))
+ ;; the positive ones 10^0, 10^1, etc.
+ ;; start with 1.0. mantissa: 10...0 (1 followed by nb-bits-1 bits)
+ ;; -> e = -(nb-bits-1)
+ ;; exact? is true when the container can still hold the complete 10^i
+ (let loop ((i 0)
+ (n (bit-lshbx #z1 (-fx nb-bits 1)))
+ (e (-fx 1 nb-bits)))
+ (when (<= i to)
+ (receive (cut e exact?)
+ (round-n-cut n e nb-bits)
+ (vector-set! vec (+fx i offset)
+ (instantiate::Cached-Fast
+ (v cut)
+ (e e)
+ (exact? exact?)))
+ (loop (+fx i 1) (*bx n #z10) e))))
+ vec))
+
+(define (print-c powers from to struct-type
+ cache-name max-distance-name offset-name macro64)
+ (define (display-power power k)
+ (with-access::Cached-Fast power (v e exact?)
+ (let ((tmp-p (open-output-string)))
+ ;; really hackish way of getting the digits
+ (display (format "~x" v) tmp-p)
+ (let ((str (close-output-port tmp-p)))
+ (printf " {~a(0x~a, ~a), ~a, ~a},\n"
+ macro64
+ (substring str 0 8)
+ (substring str 8 16)
+ e
+ k)))))
+ (define (print-powers-reduced n)
+ (print "static const " struct-type " " cache-name
+ "(" n ")"
+ "[] = {")
+ (let loop ((i 0)
+ (nb-elements 0)
+ (last-e 0)
+ (max-distance 0))
+ (cond
+ ((>= i (vector-length powers))
+ (print " };")
+ (print "static const int " max-distance-name "(" n ") = "
+ max-distance ";")
+ (print "// nb elements (" n "): " nb-elements))
+ (else
+ (let* ((power (vector-ref powers i))
+ (e (Cached-Fast-e power)))
+ (display-power power (+ i from))
+ (loop (+ i n)
+ (+ nb-elements 1)
+ e
+ (cond
+ ((=fx i 0) max-distance)
+ ((> (- e last-e) max-distance) (- e last-e))
+ (else max-distance))))))))
+ (print "// Copyright 2010 the V8 project authors. All rights reserved.")
+ (print "// ------------ GENERATED FILE ----------------")
+ (print "// command used:")
+ (print "// "
+ (apply string-append (map (lambda (str)
+ (string-append " " str))
+ *main-args*))
+ " // NOLINT")
+ (print)
+ (print
+ "// This file is intended to be included inside another .h or .cc files\n"
+ "// with the following defines set:\n"
+ "// GRISU_CACHE_STRUCT: should expand to the name of a struct that will\n"
+ "// hold the cached powers of ten. Each entry will hold a 64-bit\n"
+ "// significand, a 16-bit signed binary exponent, and a 16-bit\n"
+ "// signed decimal exponent. Each entry will be constructed as follows:\n"
+ "// { significand, binary_exponent, decimal_exponent }.\n"
+ "// GRISU_CACHE_NAME(i): generates the name for the different caches.\n"
+ "// The parameter i will be a number in the range 1-20. A cache will\n"
+ "// hold every i'th element of a full cache. GRISU_CACHE_NAME(1) will\n"
+ "// thus hold all elements. The higher i the fewer elements it has.\n"
+ "// Ideally the user should only reference one cache and let the\n"
+ "// compiler remove the unused ones.\n"
+ "// GRISU_CACHE_MAX_DISTANCE(i): generates the name for the maximum\n"
+ "// binary exponent distance between all elements of a given cache.\n"
+ "// GRISU_CACHE_OFFSET: is used as variable name for the decimal\n"
+ "// exponent offset. It is equal to -cache[0].decimal_exponent.\n"
+ "// GRISU_UINT64_C: used to construct 64-bit values in a platform\n"
+ "// independent way. In order to encode 0x123456789ABCDEF0 the macro\n"
+ "// will be invoked as follows: GRISU_UINT64_C(0x12345678,9ABCDEF0).\n")
+ (print)
+ (print-powers-reduced 1)
+ (print-powers-reduced 2)
+ (print-powers-reduced 3)
+ (print-powers-reduced 4)
+ (print-powers-reduced 5)
+ (print-powers-reduced 6)
+ (print-powers-reduced 7)
+ (print-powers-reduced 8)
+ (print-powers-reduced 9)
+ (print-powers-reduced 10)
+ (print-powers-reduced 11)
+ (print-powers-reduced 12)
+ (print-powers-reduced 13)
+ (print-powers-reduced 14)
+ (print-powers-reduced 15)
+ (print-powers-reduced 16)
+ (print-powers-reduced 17)
+ (print-powers-reduced 18)
+ (print-powers-reduced 19)
+ (print-powers-reduced 20)
+ (print "static const int GRISU_CACHE_OFFSET = " (- from) ";"))
+
+;;----------------main --------------------------------------------------------
+(define *main-args* #f)
+(define *mantissa-size* #f)
+(define *dest* #f)
+(define *round* #f)
+(define *from* #f)
+(define *to* #f)
+
+(define (my-main args)
+ (set! *main-args* args)
+ (args-parse (cdr args)
+ (section "Help")
+ (("?") (args-parse-usage #f))
+ ((("-h" "--help") (help "?, -h, --help" "This help message"))
+ (args-parse-usage #f))
+ (section "Misc")
+ (("-o" ?file (help "The output file"))
+ (set! *dest* file))
+ (("--mantissa-size" ?size (help "Container-size in bits"))
+ (set! *mantissa-size* (string->number size)))
+ (("--round" ?direction (help "Round bignums (down, round or up)"))
+ (set! *round* (string->symbol direction)))
+ (("--from" ?from (help "start at 10^from"))
+ (set! *from* (string->number from)))
+ (("--to" ?to (help "go up to 10^to"))
+ (set! *to* (string->number to)))
+ (else
+ (print "Illegal argument `" else "'. Usage:")
+ (args-parse-usage #f)))
+ (when (not *from*)
+ (error "generate-ten-powers"
+ "Missing from"
+ #f))
+ (when (not *to*)
+ (error "generate-ten-powers"
+ "Missing to"
+ #f))
+ (when (not *mantissa-size*)
+ (error "generate-ten-powers"
+ "Missing mantissa size"
+ #f))
+ (when (not (memv *round* '(up down round)))
+ (error "generate-ten-powers"
+ "Missing round-method"
+ *round*))
+
+ (let ((dividers (generate-powers *from* *to* *mantissa-size*))
+ (p (if (not *dest*)
+ (current-output-port)
+ (open-output-file *dest*))))
+ (unwind-protect
+ (with-output-to-port p
+ (lambda ()
+ (print-c dividers *from* *to*
+ "GRISU_CACHE_STRUCT" "GRISU_CACHE_NAME"
+ "GRISU_CACHE_MAX_DISTANCE" "GRISU_CACHE_OFFSET"
+ "GRISU_UINT64_C"
+ )))
+ (if *dest*
+ (close-output-port p)))))
View
6 tools/gyp/v8.gyp
@@ -229,6 +229,7 @@
'../../src/builtins.cc',
'../../src/builtins.h',
'../../src/bytecodes-irregexp.h',
+ '../../src/cached_powers.h',
'../../src/char-predicates-inl.h',
'../../src/char-predicates.h',
'../../src/checks.cc',
@@ -264,6 +265,8 @@
'../../src/disassembler.cc',
'../../src/disassembler.h',
'../../src/dtoa-config.c',
+ '../../src/diy_fp.h',
+ '../../src/double.h',
'../../src/execution.cc',
'../../src/execution.h',
'../../src/factory.cc',
@@ -284,6 +287,8 @@
'../../src/global-handles.cc',
'../../src/global-handles.h',
'../../src/globals.h',
+ '../../src/grisu3.h',
+ '../../src/grisu3.cc',
'../../src/handles-inl.h',
'../../src/handles.cc',
'../../src/handles.h',
@@ -330,6 +335,7 @@
'../../src/parser.cc',
'../../src/parser.h',
'../../src/platform.h',
+ '../../src/powers_ten.h',
'../../src/prettyprinter.cc',
'../../src/prettyprinter.h',
'../../src/property.cc',

0 comments on commit dfa19a5

Please sign in to comment.
Something went wrong with that request. Please try again.