mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
87 changed files with 3768 additions and 104742 deletions
@ -1,119 +0,0 @@ |
|||
// 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_
|
@ -1,136 +0,0 @@ |
|||
// 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_
|
@ -1,169 +0,0 @@ |
|||
// 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 BitCast<uint64_t>(d); } |
|||
static double uint64_to_double(uint64_t d64) { return BitCast<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_
|
@ -1,494 +0,0 @@ |
|||
// 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()), |
|||
÷r, ÷r_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
|
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,88 @@ |
|||
// 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_PROFILE_GENERATOR_INL_H_ |
|||
#define V8_PROFILE_GENERATOR_INL_H_ |
|||
|
|||
#include "profile-generator.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
|
|||
bool CodeEntry::is_js_function() { |
|||
return tag_ == Logger::FUNCTION_TAG |
|||
|| tag_ == Logger::LAZY_COMPILE_TAG |
|||
|| tag_ == Logger::SCRIPT_TAG; |
|||
} |
|||
|
|||
|
|||
StaticNameCodeEntry::StaticNameCodeEntry(Logger::LogEventsAndTags tag, |
|||
const char* name) |
|||
: CodeEntry(tag), |
|||
name_(name) { |
|||
} |
|||
|
|||
|
|||
ManagedNameCodeEntry::ManagedNameCodeEntry(Logger::LogEventsAndTags tag, |
|||
String* name, |
|||
const char* resource_name, |
|||
int line_number) |
|||
: CodeEntry(tag), |
|||
name_(name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).Detach()), |
|||
resource_name_(resource_name), |
|||
line_number_(line_number) { |
|||
} |
|||
|
|||
|
|||
ProfileNode::ProfileNode(CodeEntry* entry) |
|||
: entry_(entry), |
|||
total_ticks_(0), |
|||
self_ticks_(0), |
|||
children_(CodeEntriesMatch) { |
|||
} |
|||
|
|||
|
|||
void CodeMap::AddCode(Address addr, CodeEntry* entry, unsigned size) { |
|||
CodeTree::Locator locator; |
|||
tree_.Insert(addr, &locator); |
|||
locator.set_value(CodeEntryInfo(entry, size)); |
|||
} |
|||
|
|||
|
|||
void CodeMap::MoveCode(Address from, Address to) { |
|||
tree_.Move(from, to); |
|||
} |
|||
|
|||
void CodeMap::DeleteCode(Address addr) { |
|||
tree_.Remove(addr); |
|||
} |
|||
|
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_PROFILE_GENERATOR_INL_H_
|
@ -0,0 +1,295 @@ |
|||
// 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 "profile-generator-inl.h" |
|||
|
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
|
|||
ProfileNode* ProfileNode::FindChild(CodeEntry* entry) { |
|||
HashMap::Entry* map_entry = |
|||
children_.Lookup(entry, CodeEntryHash(entry), false); |
|||
return map_entry != NULL ? |
|||
reinterpret_cast<ProfileNode*>(map_entry->value) : NULL; |
|||
} |
|||
|
|||
|
|||
ProfileNode* ProfileNode::FindOrAddChild(CodeEntry* entry) { |
|||
HashMap::Entry* map_entry = |
|||
children_.Lookup(entry, CodeEntryHash(entry), true); |
|||
if (map_entry->value == NULL) { |
|||
// New node added.
|
|||
map_entry->value = new ProfileNode(entry); |
|||
} |
|||
return reinterpret_cast<ProfileNode*>(map_entry->value); |
|||
} |
|||
|
|||
|
|||
void ProfileNode::Print(int indent) { |
|||
OS::Print("%4u %4u %*c %s\n", |
|||
total_ticks_, self_ticks_, |
|||
indent, ' ', |
|||
entry_ != NULL ? entry_->name() : ""); |
|||
for (HashMap::Entry* p = children_.Start(); |
|||
p != NULL; |
|||
p = children_.Next(p)) { |
|||
reinterpret_cast<ProfileNode*>(p->value)->Print(indent + 2); |
|||
} |
|||
} |
|||
|
|||
|
|||
namespace { |
|||
|
|||
class DeleteNodesCallback { |
|||
public: |
|||
void AfterAllChildrenTraversed(ProfileNode* node) { |
|||
delete node; |
|||
} |
|||
|
|||
void AfterChildTraversed(ProfileNode*, ProfileNode*) { } |
|||
}; |
|||
|
|||
} // namespace
|
|||
|
|||
|
|||
ProfileTree::~ProfileTree() { |
|||
DeleteNodesCallback cb; |
|||
TraverseBreadthFirstPostOrder(&cb); |
|||
} |
|||
|
|||
|
|||
void ProfileTree::AddPathFromEnd(const Vector<CodeEntry*>& path) { |
|||
ProfileNode* node = root_; |
|||
for (CodeEntry** entry = path.start() + path.length() - 1; |
|||
entry != path.start() - 1; |
|||
--entry) { |
|||
if (*entry != NULL) { |
|||
node = node->FindOrAddChild(*entry); |
|||
} |
|||
} |
|||
node->IncrementSelfTicks(); |
|||
} |
|||
|
|||
|
|||
void ProfileTree::AddPathFromStart(const Vector<CodeEntry*>& path) { |
|||
ProfileNode* node = root_; |
|||
for (CodeEntry** entry = path.start(); |
|||
entry != path.start() + path.length(); |
|||
++entry) { |
|||
if (*entry != NULL) { |
|||
node = node->FindOrAddChild(*entry); |
|||
} |
|||
} |
|||
node->IncrementSelfTicks(); |
|||
} |
|||
|
|||
|
|||
namespace { |
|||
|
|||
struct Position { |
|||
Position(ProfileNode* a_node, HashMap::Entry* a_p) |
|||
: node(a_node), p(a_p) { } |
|||
INLINE(ProfileNode* current_child()) { |
|||
return reinterpret_cast<ProfileNode*>(p->value); |
|||
} |
|||
ProfileNode* node; |
|||
HashMap::Entry* p; |
|||
}; |
|||
|
|||
} // namespace
|
|||
|
|||
|
|||
template <typename Callback> |
|||
void ProfileTree::TraverseBreadthFirstPostOrder(Callback* callback) { |
|||
List<Position> stack(10); |
|||
stack.Add(Position(root_, root_->children_.Start())); |
|||
do { |
|||
Position& current = stack.last(); |
|||
if (current.p != NULL) { |
|||
stack.Add(Position(current.current_child(), |
|||
current.current_child()->children_.Start())); |
|||
} else { |
|||
callback->AfterAllChildrenTraversed(current.node); |
|||
if (stack.length() > 1) { |
|||
Position& parent = stack[stack.length() - 2]; |
|||
callback->AfterChildTraversed(parent.node, current.node); |
|||
parent.p = parent.node->children_.Next(parent.p); |
|||
// Remove child from the stack.
|
|||
stack.RemoveLast(); |
|||
} |
|||
} |
|||
} while (stack.length() > 1 || stack.last().p != NULL); |
|||
} |
|||
|
|||
|
|||
namespace { |
|||
|
|||
class CalculateTotalTicksCallback { |
|||
public: |
|||
void AfterAllChildrenTraversed(ProfileNode* node) { |
|||
node->IncreaseTotalTicks(node->self_ticks()); |
|||
} |
|||
|
|||
void AfterChildTraversed(ProfileNode* parent, ProfileNode* child) { |
|||
parent->IncreaseTotalTicks(child->total_ticks()); |
|||
} |
|||
}; |
|||
|
|||
} // namespace
|
|||
|
|||
|
|||
// Non-recursive implementation of breadth-first tree traversal.
|
|||
void ProfileTree::CalculateTotalTicks() { |
|||
CalculateTotalTicksCallback cb; |
|||
TraverseBreadthFirstPostOrder(&cb); |
|||
} |
|||
|
|||
|
|||
void ProfileTree::ShortPrint() { |
|||
OS::Print("root: %u %u\n", root_->total_ticks(), root_->self_ticks()); |
|||
} |
|||
|
|||
|
|||
void CpuProfile::AddPath(const Vector<CodeEntry*>& path) { |
|||
top_down_.AddPathFromEnd(path); |
|||
bottom_up_.AddPathFromStart(path); |
|||
} |
|||
|
|||
|
|||
void CpuProfile::CalculateTotalTicks() { |
|||
top_down_.CalculateTotalTicks(); |
|||
bottom_up_.CalculateTotalTicks(); |
|||
} |
|||
|
|||
|
|||
void CpuProfile::ShortPrint() { |
|||
OS::Print("top down "); |
|||
top_down_.ShortPrint(); |
|||
OS::Print("bottom up "); |
|||
bottom_up_.ShortPrint(); |
|||
} |
|||
|
|||
|
|||
void CpuProfile::Print() { |
|||
OS::Print("[Top down]:\n"); |
|||
top_down_.Print(); |
|||
OS::Print("[Bottom up]:\n"); |
|||
bottom_up_.Print(); |
|||
} |
|||
|
|||
|
|||
const CodeMap::CodeTreeConfig::Key CodeMap::CodeTreeConfig::kNoKey = NULL; |
|||
const CodeMap::CodeTreeConfig::Value CodeMap::CodeTreeConfig::kNoValue = |
|||
CodeMap::CodeEntryInfo(NULL, 0); |
|||
|
|||
|
|||
void CodeMap::AddAlias(Address alias, Address addr) { |
|||
CodeTree::Locator locator; |
|||
if (tree_.Find(addr, &locator)) { |
|||
const CodeEntryInfo& entry_info = locator.value(); |
|||
tree_.Insert(alias, &locator); |
|||
locator.set_value(entry_info); |
|||
} |
|||
} |
|||
|
|||
|
|||
CodeEntry* CodeMap::FindEntry(Address addr) { |
|||
CodeTree::Locator locator; |
|||
if (tree_.FindGreatestLessThan(addr, &locator)) { |
|||
// locator.key() <= addr. Need to check that addr is within entry.
|
|||
const CodeEntryInfo& entry = locator.value(); |
|||
if (addr < (locator.key() + entry.size)) |
|||
return entry.entry; |
|||
} |
|||
return NULL; |
|||
} |
|||
|
|||
|
|||
ProfileGenerator::ProfileGenerator() |
|||
: resource_names_(StringsMatch) { |
|||
} |
|||
|
|||
|
|||
static void CodeEntriesDeleter(CodeEntry** entry_ptr) { |
|||
delete *entry_ptr; |
|||
} |
|||
|
|||
|
|||
ProfileGenerator::~ProfileGenerator() { |
|||
for (HashMap::Entry* p = resource_names_.Start(); |
|||
p != NULL; |
|||
p = resource_names_.Next(p)) { |
|||
DeleteArray(reinterpret_cast<const char*>(p->value)); |
|||
} |
|||
|
|||
code_entries_.Iterate(CodeEntriesDeleter); |
|||
} |
|||
|
|||
|
|||
CodeEntry* ProfileGenerator::NewCodeEntry( |
|||
Logger::LogEventsAndTags tag, |
|||
String* name, |
|||
String* resource_name, int line_number) { |
|||
const char* cached_resource_name = NULL; |
|||
if (resource_name->IsString()) { |
|||
// As we copy contents of resource names, and usually they are repeated,
|
|||
// we cache names by string hashcode.
|
|||
HashMap::Entry* cache_entry = |
|||
resource_names_.Lookup(resource_name, |
|||
StringEntryHash(resource_name), |
|||
true); |
|||
if (cache_entry->value == NULL) { |
|||
// New entry added.
|
|||
cache_entry->value = |
|||
resource_name->ToCString(DISALLOW_NULLS, |
|||
ROBUST_STRING_TRAVERSAL).Detach(); |
|||
} |
|||
cached_resource_name = reinterpret_cast<const char*>(cache_entry->value); |
|||
} |
|||
|
|||
CodeEntry* entry = new ManagedNameCodeEntry(tag, |
|||
name, |
|||
cached_resource_name, |
|||
line_number); |
|||
code_entries_.Add(entry); |
|||
return entry; |
|||
} |
|||
|
|||
|
|||
CodeEntry* ProfileGenerator::NewCodeEntry( |
|||
Logger::LogEventsAndTags tag, |
|||
const char* name) { |
|||
CodeEntry* entry = new StaticNameCodeEntry(tag, name); |
|||
code_entries_.Add(entry); |
|||
return entry; |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
@ -0,0 +1,233 @@ |
|||
// 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_PROFILE_GENERATOR_H_ |
|||
#define V8_PROFILE_GENERATOR_H_ |
|||
|
|||
#include "hashmap.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
|
|||
class CodeEntry { |
|||
public: |
|||
virtual ~CodeEntry() { } |
|||
|
|||
virtual const char* name() = 0; |
|||
INLINE(bool is_js_function()); |
|||
|
|||
protected: |
|||
INLINE(explicit CodeEntry(Logger::LogEventsAndTags tag)) |
|||
: tag_(tag) { } |
|||
|
|||
private: |
|||
Logger::LogEventsAndTags tag_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(CodeEntry); |
|||
}; |
|||
|
|||
|
|||
class StaticNameCodeEntry : public CodeEntry { |
|||
public: |
|||
INLINE(StaticNameCodeEntry(Logger::LogEventsAndTags tag, |
|||
const char* name)); |
|||
|
|||
INLINE(virtual const char* name()) { return name_ != NULL ? name_ : ""; } |
|||
|
|||
private: |
|||
const char* name_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(StaticNameCodeEntry); |
|||
}; |
|||
|
|||
|
|||
class ManagedNameCodeEntry : public CodeEntry { |
|||
public: |
|||
INLINE(ManagedNameCodeEntry(Logger::LogEventsAndTags tag, |
|||
String* name, |
|||
const char* resource_name, int line_number)); |
|||
|
|||
INLINE(virtual const char* name()) { return !name_.is_empty() ? *name_ : ""; } |
|||
|
|||
private: |
|||
SmartPointer<char> name_; |
|||
const char* resource_name_; |
|||
int line_number_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(ManagedNameCodeEntry); |
|||
}; |
|||
|
|||
|
|||
class ProfileNode { |
|||
public: |
|||
INLINE(explicit ProfileNode(CodeEntry* entry)); |
|||
|
|||
ProfileNode* FindChild(CodeEntry* entry); |
|||
ProfileNode* FindOrAddChild(CodeEntry* entry); |
|||
INLINE(void IncrementSelfTicks()) { ++self_ticks_; } |
|||
INLINE(void IncreaseTotalTicks(unsigned amount)) { total_ticks_ += amount; } |
|||
|
|||
INLINE(unsigned total_ticks()) { return total_ticks_; } |
|||
INLINE(unsigned self_ticks()) { return self_ticks_; } |
|||
|
|||
void Print(int indent); |
|||
|
|||
private: |
|||
INLINE(static bool CodeEntriesMatch(void* key1, void* key2)) { |
|||
return key1 == key2; |
|||
} |
|||
|
|||
INLINE(static bool CodeEntryHash(CodeEntry* entry)) { |
|||
return static_cast<int32_t>(reinterpret_cast<intptr_t>(entry)); |
|||
} |
|||
|
|||
CodeEntry* entry_; |
|||
unsigned total_ticks_; |
|||
unsigned self_ticks_; |
|||
// CodeEntry* -> ProfileNode*
|
|||
HashMap children_; |
|||
|
|||
friend class ProfileTree; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(ProfileNode); |
|||
}; |
|||
|
|||
|
|||
class ProfileTree BASE_EMBEDDED { |
|||
public: |
|||
ProfileTree() : root_(new ProfileNode(NULL)) { } |
|||
~ProfileTree(); |
|||
|
|||
void AddPathFromEnd(const Vector<CodeEntry*>& path); |
|||
void AddPathFromStart(const Vector<CodeEntry*>& path); |
|||
void CalculateTotalTicks(); |
|||
|
|||
ProfileNode* root() { return root_; } |
|||
|
|||
void ShortPrint(); |
|||
void Print() { |
|||
root_->Print(0); |
|||
} |
|||
|
|||
private: |
|||
template <typename Callback> |
|||
void TraverseBreadthFirstPostOrder(Callback* callback); |
|||
|
|||
ProfileNode* root_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(ProfileTree); |
|||
}; |
|||
|
|||
|
|||
class CpuProfile BASE_EMBEDDED { |
|||
public: |
|||
CpuProfile() { } |
|||
// Add pc -> ... -> main() call path to the profile.
|
|||
void AddPath(const Vector<CodeEntry*>& path); |
|||
void CalculateTotalTicks(); |
|||
|
|||
void ShortPrint(); |
|||
void Print(); |
|||
|
|||
private: |
|||
ProfileTree top_down_; |
|||
ProfileTree bottom_up_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(CpuProfile); |
|||
}; |
|||
|
|||
|
|||
class CodeMap BASE_EMBEDDED { |
|||
public: |
|||
CodeMap() { } |
|||
INLINE(void AddCode(Address addr, CodeEntry* entry, unsigned size)); |
|||
INLINE(void MoveCode(Address from, Address to)); |
|||
INLINE(void DeleteCode(Address addr)); |
|||
void AddAlias(Address alias, Address addr); |
|||
CodeEntry* FindEntry(Address addr); |
|||
|
|||
private: |
|||
struct CodeEntryInfo { |
|||
CodeEntryInfo(CodeEntry* an_entry, unsigned a_size) |
|||
: entry(an_entry), size(a_size) { } |
|||
CodeEntry* entry; |
|||
unsigned size; |
|||
}; |
|||
|
|||
struct CodeTreeConfig { |
|||
typedef Address Key; |
|||
typedef CodeEntryInfo Value; |
|||
static const Key kNoKey; |
|||
static const Value kNoValue; |
|||
static int Compare(const Key& a, const Key& b) { |
|||
return a < b ? -1 : (a > b ? 1 : 0); |
|||
} |
|||
}; |
|||
typedef SplayTree<CodeTreeConfig> CodeTree; |
|||
|
|||
CodeTree tree_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(CodeMap); |
|||
}; |
|||
|
|||
|
|||
class ProfileGenerator { |
|||
public: |
|||
ProfileGenerator(); |
|||
~ProfileGenerator(); |
|||
|
|||
CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, |
|||
String* name, String* resource_name, int line_number); |
|||
CodeEntry* NewCodeEntry(Logger::LogEventsAndTags tag, const char* name); |
|||
|
|||
INLINE(CpuProfile* profile()) { return &profile_; } |
|||
INLINE(CodeMap* code_map()) { return &code_map_; } |
|||
|
|||
private: |
|||
INLINE(static bool StringsMatch(void* key1, void* key2)) { |
|||
return key1 == key2; |
|||
} |
|||
|
|||
INLINE(static bool StringEntryHash(String* entry)) { |
|||
return entry->Hash(); |
|||
} |
|||
|
|||
CpuProfile profile_; |
|||
CodeMap code_map_; |
|||
typedef List<CodeEntry*> CodeEntryList; |
|||
CodeEntryList code_entries_; |
|||
// String::Hash -> const char*
|
|||
HashMap resource_names_; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(ProfileGenerator); |
|||
}; |
|||
|
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_PROFILE_GENERATOR_H_
|
File diff suppressed because it is too large
@ -1,67 +0,0 @@ |
|||
// 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()); |
|||
} |
@ -1,204 +0,0 @@ |
|||
// 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
|
|||
} |
@ -1,116 +0,0 @@ |
|||
// 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); |
|||
} |
@ -0,0 +1,362 @@ |
|||
// Copyright 2010 the V8 project authors. All rights reserved.
|
|||
//
|
|||
// Tests of profiles generator and utilities.
|
|||
|
|||
#include "v8.h" |
|||
#include "profile-generator-inl.h" |
|||
#include "cctest.h" |
|||
|
|||
namespace i = v8::internal; |
|||
|
|||
using i::CodeEntry; |
|||
using i::CodeMap; |
|||
using i::ProfileNode; |
|||
using i::ProfileTree; |
|||
using i::StaticNameCodeEntry; |
|||
using i::Vector; |
|||
|
|||
|
|||
TEST(ProfileNodeFindOrAddChild) { |
|||
ProfileNode node(NULL); |
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
ProfileNode* childNode1 = node.FindOrAddChild(&entry1); |
|||
CHECK_NE(NULL, childNode1); |
|||
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
ProfileNode* childNode2 = node.FindOrAddChild(&entry2); |
|||
CHECK_NE(NULL, childNode2); |
|||
CHECK_NE(childNode1, childNode2); |
|||
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
|||
CHECK_EQ(childNode2, node.FindOrAddChild(&entry2)); |
|||
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
|||
ProfileNode* childNode3 = node.FindOrAddChild(&entry3); |
|||
CHECK_NE(NULL, childNode3); |
|||
CHECK_NE(childNode1, childNode3); |
|||
CHECK_NE(childNode2, childNode3); |
|||
CHECK_EQ(childNode1, node.FindOrAddChild(&entry1)); |
|||
CHECK_EQ(childNode2, node.FindOrAddChild(&entry2)); |
|||
CHECK_EQ(childNode3, node.FindOrAddChild(&entry3)); |
|||
} |
|||
|
|||
|
|||
namespace { |
|||
|
|||
class ProfileTreeTestHelper { |
|||
public: |
|||
explicit ProfileTreeTestHelper(ProfileTree* tree) |
|||
: tree_(tree) { } |
|||
|
|||
ProfileNode* Walk(CodeEntry* entry1, |
|||
CodeEntry* entry2 = NULL, |
|||
CodeEntry* entry3 = NULL) { |
|||
ProfileNode* node = tree_->root(); |
|||
node = node->FindChild(entry1); |
|||
if (node == NULL) return NULL; |
|||
if (entry2 != NULL) { |
|||
node = node->FindChild(entry2); |
|||
if (node == NULL) return NULL; |
|||
} |
|||
if (entry3 != NULL) { |
|||
node = node->FindChild(entry3); |
|||
} |
|||
return node; |
|||
} |
|||
|
|||
private: |
|||
ProfileTree* tree_; |
|||
}; |
|||
|
|||
} // namespace
|
|||
|
|||
TEST(ProfileTreeAddPathFromStart) { |
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
|||
ProfileTree tree; |
|||
ProfileTreeTestHelper helper(&tree); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
|
|||
CodeEntry* path[] = {NULL, &entry1, NULL, &entry2, NULL, NULL, &entry3, NULL}; |
|||
Vector<CodeEntry*> path_vec(path, sizeof(path) / sizeof(path[0])); |
|||
tree.AddPathFromStart(path_vec); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
ProfileNode* node1 = helper.Walk(&entry1); |
|||
CHECK_NE(NULL, node1); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(0, node1->self_ticks()); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
|||
ProfileNode* node2 = helper.Walk(&entry1, &entry2); |
|||
CHECK_NE(NULL, node2); |
|||
CHECK_NE(node1, node2); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(0, node2->self_ticks()); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry2)); |
|||
ProfileNode* node3 = helper.Walk(&entry1, &entry2, &entry3); |
|||
CHECK_NE(NULL, node3); |
|||
CHECK_NE(node1, node3); |
|||
CHECK_NE(node2, node3); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(1, node3->self_ticks()); |
|||
|
|||
tree.AddPathFromStart(path_vec); |
|||
CHECK_EQ(node1, helper.Walk(&entry1)); |
|||
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
|||
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(0, node1->self_ticks()); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(0, node2->self_ticks()); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(2, node3->self_ticks()); |
|||
|
|||
CodeEntry* path2[] = {&entry1, &entry2, &entry2}; |
|||
Vector<CodeEntry*> path2_vec(path2, sizeof(path2) / sizeof(path2[0])); |
|||
tree.AddPathFromStart(path2_vec); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
CHECK_EQ(node1, helper.Walk(&entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
|||
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
|||
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(2, node3->self_ticks()); |
|||
ProfileNode* node4 = helper.Walk(&entry1, &entry2, &entry2); |
|||
CHECK_NE(NULL, node4); |
|||
CHECK_NE(node3, node4); |
|||
CHECK_EQ(0, node4->total_ticks()); |
|||
CHECK_EQ(1, node4->self_ticks()); |
|||
} |
|||
|
|||
|
|||
TEST(ProfileTreeAddPathFromEnd) { |
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
|||
ProfileTree tree; |
|||
ProfileTreeTestHelper helper(&tree); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
|
|||
CodeEntry* path[] = {NULL, &entry3, NULL, &entry2, NULL, NULL, &entry1, NULL}; |
|||
Vector<CodeEntry*> path_vec(path, sizeof(path) / sizeof(path[0])); |
|||
tree.AddPathFromEnd(path_vec); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
ProfileNode* node1 = helper.Walk(&entry1); |
|||
CHECK_NE(NULL, node1); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(0, node1->self_ticks()); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
|||
ProfileNode* node2 = helper.Walk(&entry1, &entry2); |
|||
CHECK_NE(NULL, node2); |
|||
CHECK_NE(node1, node2); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(0, node2->self_ticks()); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry2)); |
|||
ProfileNode* node3 = helper.Walk(&entry1, &entry2, &entry3); |
|||
CHECK_NE(NULL, node3); |
|||
CHECK_NE(node1, node3); |
|||
CHECK_NE(node2, node3); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(1, node3->self_ticks()); |
|||
|
|||
tree.AddPathFromEnd(path_vec); |
|||
CHECK_EQ(node1, helper.Walk(&entry1)); |
|||
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
|||
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(0, node1->self_ticks()); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(0, node2->self_ticks()); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(2, node3->self_ticks()); |
|||
|
|||
CodeEntry* path2[] = {&entry2, &entry2, &entry1}; |
|||
Vector<CodeEntry*> path2_vec(path2, sizeof(path2) / sizeof(path2[0])); |
|||
tree.AddPathFromEnd(path2_vec); |
|||
CHECK_EQ(NULL, helper.Walk(&entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry3)); |
|||
CHECK_EQ(node1, helper.Walk(&entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry1)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry3)); |
|||
CHECK_EQ(node2, helper.Walk(&entry1, &entry2)); |
|||
CHECK_EQ(NULL, helper.Walk(&entry1, &entry2, &entry1)); |
|||
CHECK_EQ(node3, helper.Walk(&entry1, &entry2, &entry3)); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(2, node3->self_ticks()); |
|||
ProfileNode* node4 = helper.Walk(&entry1, &entry2, &entry2); |
|||
CHECK_NE(NULL, node4); |
|||
CHECK_NE(node3, node4); |
|||
CHECK_EQ(0, node4->total_ticks()); |
|||
CHECK_EQ(1, node4->self_ticks()); |
|||
} |
|||
|
|||
|
|||
TEST(ProfileTreeCalculateTotalTicks) { |
|||
ProfileTree empty_tree; |
|||
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, empty_tree.root()->self_ticks()); |
|||
empty_tree.CalculateTotalTicks(); |
|||
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, empty_tree.root()->self_ticks()); |
|||
empty_tree.root()->IncrementSelfTicks(); |
|||
CHECK_EQ(0, empty_tree.root()->total_ticks()); |
|||
CHECK_EQ(1, empty_tree.root()->self_ticks()); |
|||
empty_tree.CalculateTotalTicks(); |
|||
CHECK_EQ(1, empty_tree.root()->total_ticks()); |
|||
CHECK_EQ(1, empty_tree.root()->self_ticks()); |
|||
|
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
CodeEntry* e1_path[] = {&entry1}; |
|||
Vector<CodeEntry*> e1_path_vec( |
|||
e1_path, sizeof(e1_path) / sizeof(e1_path[0])); |
|||
CodeEntry* e1_e2_path[] = {&entry1, &entry2}; |
|||
Vector<CodeEntry*> e1_e2_path_vec( |
|||
e1_e2_path, sizeof(e1_e2_path) / sizeof(e1_e2_path[0])); |
|||
|
|||
ProfileTree flat_tree; |
|||
ProfileTreeTestHelper flat_helper(&flat_tree); |
|||
flat_tree.AddPathFromStart(e1_path_vec); |
|||
flat_tree.AddPathFromStart(e1_path_vec); |
|||
flat_tree.AddPathFromStart(e1_e2_path_vec); |
|||
flat_tree.AddPathFromStart(e1_e2_path_vec); |
|||
flat_tree.AddPathFromStart(e1_e2_path_vec); |
|||
// Results in {root,0,0} -> {entry1,0,2} -> {entry2,0,3}
|
|||
CHECK_EQ(0, flat_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, flat_tree.root()->self_ticks()); |
|||
ProfileNode* node1 = flat_helper.Walk(&entry1); |
|||
CHECK_NE(NULL, node1); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(2, node1->self_ticks()); |
|||
ProfileNode* node2 = flat_helper.Walk(&entry1, &entry2); |
|||
CHECK_NE(NULL, node2); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(3, node2->self_ticks()); |
|||
flat_tree.CalculateTotalTicks(); |
|||
// Must calculate {root,5,0} -> {entry1,5,2} -> {entry2,3,3}
|
|||
CHECK_EQ(5, flat_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, flat_tree.root()->self_ticks()); |
|||
CHECK_EQ(5, node1->total_ticks()); |
|||
CHECK_EQ(2, node1->self_ticks()); |
|||
CHECK_EQ(3, node2->total_ticks()); |
|||
CHECK_EQ(3, node2->self_ticks()); |
|||
|
|||
CodeEntry* e2_path[] = {&entry2}; |
|||
Vector<CodeEntry*> e2_path_vec( |
|||
e2_path, sizeof(e2_path) / sizeof(e2_path[0])); |
|||
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
|||
CodeEntry* e3_path[] = {&entry3}; |
|||
Vector<CodeEntry*> e3_path_vec( |
|||
e3_path, sizeof(e3_path) / sizeof(e3_path[0])); |
|||
|
|||
ProfileTree wide_tree; |
|||
ProfileTreeTestHelper wide_helper(&wide_tree); |
|||
wide_tree.AddPathFromStart(e1_path_vec); |
|||
wide_tree.AddPathFromStart(e1_path_vec); |
|||
wide_tree.AddPathFromStart(e1_e2_path_vec); |
|||
wide_tree.AddPathFromStart(e2_path_vec); |
|||
wide_tree.AddPathFromStart(e2_path_vec); |
|||
wide_tree.AddPathFromStart(e2_path_vec); |
|||
wide_tree.AddPathFromStart(e3_path_vec); |
|||
wide_tree.AddPathFromStart(e3_path_vec); |
|||
wide_tree.AddPathFromStart(e3_path_vec); |
|||
wide_tree.AddPathFromStart(e3_path_vec); |
|||
// Results in -> {entry1,0,2} -> {entry2,0,1}
|
|||
// {root,0,0} -> {entry2,0,3}
|
|||
// -> {entry3,0,4}
|
|||
CHECK_EQ(0, wide_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, wide_tree.root()->self_ticks()); |
|||
node1 = wide_helper.Walk(&entry1); |
|||
CHECK_NE(NULL, node1); |
|||
CHECK_EQ(0, node1->total_ticks()); |
|||
CHECK_EQ(2, node1->self_ticks()); |
|||
ProfileNode* node1_2 = wide_helper.Walk(&entry1, &entry2); |
|||
CHECK_NE(NULL, node1_2); |
|||
CHECK_EQ(0, node1_2->total_ticks()); |
|||
CHECK_EQ(1, node1_2->self_ticks()); |
|||
node2 = wide_helper.Walk(&entry2); |
|||
CHECK_NE(NULL, node2); |
|||
CHECK_EQ(0, node2->total_ticks()); |
|||
CHECK_EQ(3, node2->self_ticks()); |
|||
ProfileNode* node3 = wide_helper.Walk(&entry3); |
|||
CHECK_NE(NULL, node3); |
|||
CHECK_EQ(0, node3->total_ticks()); |
|||
CHECK_EQ(4, node3->self_ticks()); |
|||
wide_tree.CalculateTotalTicks(); |
|||
// Calculates -> {entry1,3,2} -> {entry2,1,1}
|
|||
// {root,10,0} -> {entry2,3,3}
|
|||
// -> {entry3,4,4}
|
|||
CHECK_EQ(10, wide_tree.root()->total_ticks()); |
|||
CHECK_EQ(0, wide_tree.root()->self_ticks()); |
|||
CHECK_EQ(3, node1->total_ticks()); |
|||
CHECK_EQ(2, node1->self_ticks()); |
|||
CHECK_EQ(1, node1_2->total_ticks()); |
|||
CHECK_EQ(1, node1_2->self_ticks()); |
|||
CHECK_EQ(3, node2->total_ticks()); |
|||
CHECK_EQ(3, node2->self_ticks()); |
|||
CHECK_EQ(4, node3->total_ticks()); |
|||
CHECK_EQ(4, node3->self_ticks()); |
|||
} |
|||
|
|||
|
|||
static inline i::Address ToAddress(int n) { |
|||
return reinterpret_cast<i::Address>(n); |
|||
} |
|||
|
|||
TEST(CodeMapAddCode) { |
|||
CodeMap code_map; |
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
StaticNameCodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc"); |
|||
StaticNameCodeEntry entry4(i::Logger::FUNCTION_TAG, "ddd"); |
|||
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200); |
|||
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100); |
|||
code_map.AddCode(ToAddress(0x1900), &entry3, 0x50); |
|||
code_map.AddCode(ToAddress(0x1950), &entry4, 0x10); |
|||
CHECK_EQ(NULL, code_map.FindEntry(0)); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1500 - 1))); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500))); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500 + 0x100))); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500 + 0x200 - 1))); |
|||
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
|||
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700 + 0x50))); |
|||
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700 + 0x100 - 1))); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1700 + 0x100))); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1900 - 1))); |
|||
CHECK_EQ(&entry3, code_map.FindEntry(ToAddress(0x1900))); |
|||
CHECK_EQ(&entry3, code_map.FindEntry(ToAddress(0x1900 + 0x28))); |
|||
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950))); |
|||
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950 + 0x7))); |
|||
CHECK_EQ(&entry4, code_map.FindEntry(ToAddress(0x1950 + 0x10 - 1))); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1950 + 0x10))); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0xFFFFFFFF))); |
|||
} |
|||
|
|||
|
|||
TEST(CodeMapMoveAndDeleteCode) { |
|||
CodeMap code_map; |
|||
StaticNameCodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa"); |
|||
StaticNameCodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb"); |
|||
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200); |
|||
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500))); |
|||
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
|||
code_map.MoveCode(ToAddress(0x1500), ToAddress(0x1800)); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1500))); |
|||
CHECK_EQ(&entry2, code_map.FindEntry(ToAddress(0x1700))); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1800))); |
|||
code_map.DeleteCode(ToAddress(0x1700)); |
|||
CHECK_EQ(NULL, code_map.FindEntry(ToAddress(0x1700))); |
|||
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1800))); |
|||
} |
@ -0,0 +1,83 @@ |
|||
// 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.
|
|||
|
|||
// Flags: --expose-debug-as debug
|
|||
// Get the Debug object exposed from the debug context global object.
|
|||
|
|||
// Scenario: a function is being changed, which causes enclosing function to
|
|||
// have its positions patched; position changing requires new instance of Code
|
|||
// object to be introduced; the function happens to be on stack at this moment;
|
|||
// later it will resume over new instance of Code.
|
|||
// Before the change 2 rinfo are 22 characters away from each other. After the
|
|||
// change they are 114 characters away from each other. New instance of Code is
|
|||
// required when those numbers cross the border value of 64 (in any direction).
|
|||
|
|||
Debug = debug.Debug |
|||
|
|||
eval( |
|||
"function BeingReplaced(changer, opt_x, opt_y) {\n" + |
|||
" changer();\n" + |
|||
" var res = new Object();\n" + |
|||
" if (opt_x) { res.y = opt_y; }\n" + |
|||
" res.a = (function() {})();\n" + |
|||
" return res.a;\n" + |
|||
"}" |
|||
); |
|||
|
|||
var script = Debug.findScript(BeingReplaced); |
|||
|
|||
var orig_body = "{}"; |
|||
var patch_pos = script.source.indexOf(orig_body); |
|||
// Line long enough to change rinfo encoding.
|
|||
var new_body_patch = "{return 'Capybara';" + |
|||
" " + |
|||
"}"; |
|||
|
|||
var change_log = new Array(); |
|||
function Changer() { |
|||
Debug.LiveEditChangeScript(script, patch_pos, orig_body.length, new_body_patch, change_log); |
|||
print("Change log: " + JSON.stringify(change_log) + "\n"); |
|||
} |
|||
|
|||
function NoOp() { |
|||
} |
|||
|
|||
function CallM(changer) { |
|||
// We expect call IC here after several function runs.
|
|||
return BeingReplaced(changer); |
|||
} |
|||
|
|||
// This several iterations should cause call IC for BeingReplaced call. This IC
|
|||
// will keep reference to code object of BeingRepalced function. This reference
|
|||
// should also be patched. Unfortunately, this is a manually checked fact (from
|
|||
// debugger or debug print) and doesn't work as an automatic test.
|
|||
CallM(NoOp); |
|||
CallM(NoOp); |
|||
CallM(NoOp); |
|||
|
|||
var res = CallM(Changer); |
|||
assertEquals("Capybara", res); |
@ -0,0 +1,93 @@ |
|||
// 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.
|
|||
|
|||
// Flags: --expose-debug-as debug
|
|||
// Get the Debug object exposed from the debug context global object.
|
|||
|
|||
// Scenario: some function is being edited; the outer function has to have its
|
|||
// positions patched. Accoring to a special markup of function text
|
|||
// corresponding byte-code PCs should conicide before change and after it.
|
|||
|
|||
Debug = debug.Debug |
|||
|
|||
eval( |
|||
"function F1() { return 5; }\n" + |
|||
"function ChooseAnimal(/*$*/ ) {\n" + |
|||
"/*$*/ var x = F1(/*$*/ );\n" + |
|||
"/*$*/ var res/*$*/ =/*$*/ (function() { return 'Cat'; } )();\n" + |
|||
"/*$*/ var y/*$*/ = F2(/*$*/ F1()/*$*/ , F1(/*$*/ )/*$*/ );\n" + |
|||
"/*$*/ if (/*$*/ x.toString(/*$*/ )) { /*$*/ y = 3;/*$*/ } else {/*$*/ y = 8;/*$*/ }\n" + |
|||
"/*$*/ var z = /*$*/ x * y;\n" + |
|||
"/*$*/ return/*$*/ res/*$*/ + z;/*$*/ }\n" + |
|||
"function F2(x, y) { return x + y; }" |
|||
); |
|||
|
|||
// Find all *$* markers in text of the function and read corresponding statement
|
|||
// PCs.
|
|||
function ReadMarkerPositions(func) { |
|||
var text = func.toString(); |
|||
var positions = new Array(); |
|||
var match; |
|||
var pattern = /\/\*\$\*\//g; |
|||
while ((match = pattern.exec(text)) != null) { |
|||
positions.push(match.index); |
|||
} |
|||
return positions; |
|||
} |
|||
|
|||
function ReadPCMap(func, positions) { |
|||
var res = new Array(); |
|||
for (var i = 0; i < positions.length; i++) { |
|||
res.push(Debug.LiveEditChangeScript.GetPcFromSourcePos(func, positions[i])); |
|||
} |
|||
return res; |
|||
} |
|||
|
|||
var res = ChooseAnimal(); |
|||
assertEquals("Cat15", res); |
|||
|
|||
var markerPositionsBefore = ReadMarkerPositions(ChooseAnimal); |
|||
var pcArrayBefore = ReadPCMap(ChooseAnimal, markerPositionsBefore); |
|||
|
|||
var script = Debug.findScript(ChooseAnimal); |
|||
|
|||
var orig_animal = "'Cat'"; |
|||
var patch_pos = script.source.indexOf(orig_animal); |
|||
var new_animal_patch = "'Capybara'"; |
|||
|
|||
var change_log = new Array(); |
|||
Debug.LiveEditChangeScript(script, patch_pos, orig_animal.length, new_animal_patch, change_log); |
|||
print("Change log: " + JSON.stringify(change_log) + "\n"); |
|||
|
|||
var res = ChooseAnimal(); |
|||
assertEquals("Capybara15", res); |
|||
|
|||
var markerPositionsAfter = ReadMarkerPositions(ChooseAnimal); |
|||
var pcArrayAfter = ReadPCMap(ChooseAnimal, markerPositionsAfter); |
|||
|
|||
assertArrayEquals(pcArrayBefore, pcArrayAfter); |
|||
|
@ -1,286 +0,0 @@ |
|||
;; 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))))) |
Loading…
Reference in new issue