v8::internal::Double Class Reference

#include <double.h>

Collaboration diagram for v8::internal::Double:

Public Member Functions
	Double ()
	Double (double d)
	Double (uint64_t d64)
	Double (DiyFp diy_fp)
DiyFp	AsDiyFp () const
DiyFp	AsNormalizedDiyFp () const
uint64_t	AsUint64 () const
double	NextDouble () const
int	Exponent () const
uint64_t	Significand () const
bool	IsDenormal () const
bool	IsSpecial () const
bool	IsInfinite () const
int	Sign () const
DiyFp	UpperBoundary () const
void	NormalizedBoundaries (DiyFp *out_m_minus, DiyFp *out_m_plus) const
double	value () const

Static Public Member Functions
static int	SignificandSizeForOrderOfMagnitude (int order)

Static Public Attributes
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
static const uint64_t	kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000)
static const int	kPhysicalSignificandSize = 52
static const int	kSignificandSize = 53

Static Private Member Functions
static uint64_t	DiyFpToUint64 (DiyFp diy_fp)

Private Attributes
const uint64_t	d64_

Static Private Attributes
static const int	kExponentBias = 0x3FF + kPhysicalSignificandSize
static const int	kDenormalExponent = -kExponentBias + 1
static const int	kMaxExponent = 0x7FF - kExponentBias
static const uint64_t	kInfinity = V8_2PART_UINT64_C(0x7FF00000, 00000000)

Detailed Description

Definition at line 18 of file double.h.

Constructor & Destructor Documentation

Double() [1/4]

v8::internal::Double::Double ( )

inline

Definition at line 28 of file double.h.

: d64_(0) {}

Referenced by NextDouble().

Here is the caller graph for this function:

Double() [2/4]

v8::internal::Double::Double ( double  d )

inlineexplicit

Definition at line 29 of file double.h.

: d64_(double_to_uint64(d)) {}

Double() [3/4]

v8::internal::Double::Double ( uint64_t  d64 )

inlineexplicit

Definition at line 30 of file double.h.

: d64_(d64) {}

Double() [4/4]

v8::internal::Double::Double ( DiyFp  diy_fp )

inlineexplicit

Definition at line 31 of file double.h.

    : d64_(DiyFpToUint64(diy_fp)) {}

Member Function Documentation

AsDiyFp()

DiyFp v8::internal::Double::AsDiyFp ( ) const

inline

Definition at line 36 of file double.h.

                        {
    DCHECK(Sign() > 0);
    DCHECK(!IsSpecial());
    return DiyFp(Significand(), Exponent());
  }

References DCHECK, Exponent(), IsSpecial(), Sign(), and Significand().

Referenced by NormalizedBoundaries().

Here is the call graph for this function:

Here is the caller graph for this function:

AsNormalizedDiyFp()

DiyFp v8::internal::Double::AsNormalizedDiyFp ( ) const

inline

Definition at line 43 of file double.h.

                                  {
    DCHECK(value() > 0.0);
    uint64_t f = Significand();
    int e = Exponent();
 
    // The current double could be a denormal.
    while ((f & kHiddenBit) == 0) {
      f <<= 1;
      e--;
    }
    // Do the final shifts in one go.
    f <<= DiyFp::kSignificandSize - kSignificandSize;
    e -= DiyFp::kSignificandSize - kSignificandSize;
    return DiyFp(f, e);
  }

References DCHECK, Exponent(), kHiddenBit, v8::internal::DiyFp::kSignificandSize, kSignificandSize, Significand(), and value().

Referenced by v8::internal::Grisu3(), and v8::internal::Grisu3Counted().

Here is the call graph for this function:

Here is the caller graph for this function:

AsUint64()

uint64_t v8::internal::Double::AsUint64 ( ) const

inline

Definition at line 60 of file double.h.

                            {
    return d64_;
  }

References d64_.

Referenced by Exponent(), v8::internal::InitialScaledStartValuesNegativeExponentNegativePower(), v8::internal::InitialScaledStartValuesNegativeExponentPositivePower(), v8::internal::InitialScaledStartValuesPositiveExponent(), IsDenormal(), IsInfinite(), IsSpecial(), Sign(), and Significand().

Here is the caller graph for this function:

DiyFpToUint64()

static uint64_t v8::internal::Double::DiyFpToUint64 ( DiyFp  diy_fp )

inlinestaticprivate

Definition at line 179 of file double.h.

                                              {
    uint64_t significand = diy_fp.f();
    int exponent = diy_fp.e();
    while (significand > kHiddenBit + kSignificandMask) {
      significand >>= 1;
      exponent++;
    }
    if (exponent >= kMaxExponent) {
      return kInfinity;
    }
    if (exponent < kDenormalExponent) {
      return 0;
    }
    while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
      significand <<= 1;
      exponent--;
    }
    uint64_t biased_exponent;
    if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
      biased_exponent = 0;
    } else {
      biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
    }
    return (significand & kSignificandMask) |
        (biased_exponent << kPhysicalSignificandSize);
  }

References v8::internal::DiyFp::e(), v8::internal::DiyFp::f(), kDenormalExponent, kExponentBias, kHiddenBit, kInfinity, kMaxExponent, kPhysicalSignificandSize, and kSignificandMask.

Here is the call graph for this function:

Exponent()

int v8::internal::Double::Exponent ( ) const

inline

Definition at line 78 of file double.h.

                       {
    if (IsDenormal()) return kDenormalExponent;
 
    uint64_t d64 = AsUint64();
    int biased_e =
        static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
    return biased_e - kExponentBias;
  }

References AsUint64(), IsDenormal(), kDenormalExponent, kExponentBias, kExponentMask, and kPhysicalSignificandSize.

Referenced by AsDiyFp(), AsNormalizedDiyFp(), v8::internal::BignumDtoa(), v8::internal::DoubleToInt32(), v8::internal::FastFixedDtoa(), v8::internal::InitialScaledStartValuesNegativeExponentNegativePower(), v8::internal::InitialScaledStartValuesNegativeExponentPositivePower(), and UpperBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDenormal()

bool v8::internal::Double::IsDenormal ( ) const

inline

Definition at line 98 of file double.h.

                          {
    uint64_t d64 = AsUint64();
    return (d64 & kExponentMask) == 0;
  }

References AsUint64(), and kExponentMask.

Referenced by Exponent(), and Significand().

Here is the call graph for this function:

Here is the caller graph for this function:

IsInfinite()

bool v8::internal::Double::IsInfinite ( ) const

inline

Definition at line 110 of file double.h.

                          {
    uint64_t d64 = AsUint64();
    return ((d64 & kExponentMask) == kExponentMask) &&
        ((d64 & kSignificandMask) == 0);
  }

References AsUint64(), kExponentMask, and kSignificandMask.

Here is the call graph for this function:

IsSpecial()

bool v8::internal::Double::IsSpecial ( ) const

inline

Definition at line 105 of file double.h.

                         {
    uint64_t d64 = AsUint64();
    return (d64 & kExponentMask) == kExponentMask;
  }

References AsUint64(), and kExponentMask.

Referenced by AsDiyFp().

Here is the call graph for this function:

Here is the caller graph for this function:

NextDouble()

double v8::internal::Double::NextDouble ( ) const

inline

Definition at line 65 of file double.h.

                            {
    if (d64_ == kInfinity) return Double(kInfinity).value();
    if (Sign() < 0 && Significand() == 0) {
      // -0.0
      return 0.0;
    }
    if (Sign() < 0) {
      return Double(d64_ - 1).value();
    } else {
      return Double(d64_ + 1).value();
    }
  }

References d64_, Double(), kInfinity, Sign(), and Significand().

Referenced by v8::internal::BignumStrtod().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizedBoundaries()

void v8::internal::Double::NormalizedBoundaries ( DiyFp *  out_m_minus, DiyFp *  out_m_plus  ) const

inline

Definition at line 132 of file double.h.

                                                                         {
    DCHECK(value() > 0.0);
    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;
  }

References AsDiyFp(), DCHECK, v8::internal::DiyFp::e(), v8::internal::DiyFp::f(), kDenormalExponent, kHiddenBit, v8::internal::DiyFp::Normalize(), v8::internal::DiyFp::set_e(), v8::internal::DiyFp::set_f(), and value().

Referenced by v8::internal::Grisu3().

Here is the call graph for this function:

Here is the caller graph for this function:

Sign()

int v8::internal::Double::Sign ( ) const

inline

Definition at line 116 of file double.h.

                   {
    uint64_t d64 = AsUint64();
    return (d64 & kSignMask) == 0? 1: -1;
  }

References AsUint64(), and kSignMask.

Referenced by AsDiyFp(), v8::internal::DoubleToInt32(), NextDouble(), and UpperBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

Significand()

uint64_t v8::internal::Double::Significand ( ) const

inline

Definition at line 87 of file double.h.

                               {
    uint64_t d64 = AsUint64();
    uint64_t significand = d64 & kSignificandMask;
    if (!IsDenormal()) {
      return significand + kHiddenBit;
    } else {
      return significand;
    }
  }

References AsUint64(), IsDenormal(), kHiddenBit, and kSignificandMask.

Referenced by AsDiyFp(), AsNormalizedDiyFp(), v8::internal::BignumDtoa(), v8::internal::DoubleToInt32(), v8::internal::FastFixedDtoa(), v8::internal::InitialScaledStartValuesNegativeExponentNegativePower(), v8::internal::InitialScaledStartValuesNegativeExponentPositivePower(), NextDouble(), and UpperBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

SignificandSizeForOrderOfMagnitude()

static int v8::internal::Double::SignificandSizeForOrderOfMagnitude ( int  order )

inlinestatic

Definition at line 163 of file double.h.

                                                           {
    if (order >= (kDenormalExponent + kSignificandSize)) {
      return kSignificandSize;
    }
    if (order <= kDenormalExponent) return 0;
    return order - kDenormalExponent;
  }

References kDenormalExponent, and kSignificandSize.

Referenced by v8::internal::DiyFpStrtod().

Here is the caller graph for this function:

UpperBoundary()

DiyFp v8::internal::Double::UpperBoundary ( ) const

inline

Definition at line 123 of file double.h.

                              {
    DCHECK(Sign() > 0);
    return DiyFp(Significand() * 2 + 1, Exponent() - 1);
  }

References DCHECK, Exponent(), Sign(), and Significand().

Referenced by v8::internal::BignumStrtod().

Here is the call graph for this function:

Here is the caller graph for this function:

value()

double v8::internal::Double::value ( ) const

inline

Definition at line 155 of file double.h.

{ return uint64_to_double(d64_); }

References d64_, and v8::internal::uint64_to_double().

Referenced by AsNormalizedDiyFp(), v8::internal::DiyFpStrtod(), and NormalizedBoundaries().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

d64_

const uint64_t v8::internal::Double::d64_

private

Definition at line 177 of file double.h.

Referenced by AsUint64(), NextDouble(), and value().

kDenormalExponent

const int v8::internal::Double::kDenormalExponent = -kExponentBias + 1

staticprivate

Definition at line 173 of file double.h.

Referenced by DiyFpToUint64(), Exponent(), NormalizedBoundaries(), and SignificandSizeForOrderOfMagnitude().

kExponentBias

const int v8::internal::Double::kExponentBias = 0x3FF + kPhysicalSignificandSize

staticprivate

Definition at line 172 of file double.h.

Referenced by DiyFpToUint64(), and Exponent().

kExponentMask

const uint64_t v8::internal::Double::kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000)

static

Definition at line 21 of file double.h.

Referenced by Exponent(), v8::internal::InitialScaledStartValuesNegativeExponentNegativePower(), IsDenormal(), IsInfinite(), and IsSpecial().

kHiddenBit

const uint64_t v8::internal::Double::kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000)

static

Definition at line 24 of file double.h.

Referenced by AsNormalizedDiyFp(), DiyFpToUint64(), NormalizedBoundaries(), v8::internal::NormalizedExponent(), and Significand().

kInfinity

const uint64_t v8::internal::Double::kInfinity = V8_2PART_UINT64_C(0x7FF00000, 00000000)

staticprivate

Definition at line 175 of file double.h.

Referenced by DiyFpToUint64(), and NextDouble().

kMaxExponent

const int v8::internal::Double::kMaxExponent = 0x7FF - kExponentBias

staticprivate

Definition at line 174 of file double.h.

Referenced by DiyFpToUint64().

kPhysicalSignificandSize

const int v8::internal::Double::kPhysicalSignificandSize = 52

static

Definition at line 25 of file double.h.

Referenced by DiyFpToUint64(), and Exponent().

kSignificandMask

const uint64_t v8::internal::Double::kSignificandMask

static

Initial value:

=
      V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF)

Definition at line 22 of file double.h.

Referenced by DiyFpToUint64(), v8::internal::InitialScaledStartValuesNegativeExponentNegativePower(), v8::internal::InitialScaledStartValuesNegativeExponentPositivePower(), v8::internal::InitialScaledStartValuesPositiveExponent(), IsInfinite(), and Significand().

kSignificandSize

const int v8::internal::Double::kSignificandSize = 53

static

Definition at line 26 of file double.h.

Referenced by AsNormalizedDiyFp(), v8::internal::DoubleToInt32(), and SignificandSizeForOrderOfMagnitude().

kSignMask

const uint64_t v8::internal::Double::kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000)

static

Definition at line 20 of file double.h.

Referenced by Sign(), and v8::internal::SignedZero().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/double.h