LCOV - code coverage report
Current view: top level - src - double.h (source / functions) Hit Total Coverage
Test: app.info Lines: 52 55 94.5 %
Date: 2017-04-26 Functions: 6 6 100.0 %

          Line data    Source code
       1             : // Copyright 2011 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_DOUBLE_H_
       6             : #define V8_DOUBLE_H_
       7             : 
       8             : #include "src/diy-fp.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13             : // We assume that doubles and uint64_t have the same endianness.
      14     2176008 : inline uint64_t double_to_uint64(double d) { return bit_cast<uint64_t>(d); }
      15     2182576 : inline double uint64_to_double(uint64_t d64) { return bit_cast<double>(d64); }
      16             : 
      17             : // Helper functions for doubles.
      18             : class Double {
      19             :  public:
      20             :   static const uint64_t kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000);
      21             :   static const uint64_t kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000);
      22             :   static const uint64_t kSignificandMask =
      23             :       V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF);
      24             :   static const uint64_t kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000);
      25             :   static const int kPhysicalSignificandSize = 52;  // Excludes the hidden bit.
      26             :   static const int kSignificandSize = 53;
      27             : 
      28             :   Double() : d64_(0) {}
      29     9576597 :   explicit Double(double d) : d64_(double_to_uint64(d)) {}
      30             :   explicit Double(uint64_t d64) : d64_(d64) {}
      31             :   explicit Double(DiyFp diy_fp)
      32       67435 :     : d64_(DiyFpToUint64(diy_fp)) {}
      33             : 
      34             :   // The value encoded by this Double must be greater or equal to +0.0.
      35             :   // It must not be special (infinity, or NaN).
      36             :   DiyFp AsDiyFp() const {
      37             :     DCHECK(Sign() > 0);
      38             :     DCHECK(!IsSpecial());
      39             :     return DiyFp(Significand(), Exponent());
      40             :   }
      41             : 
      42             :   // The value encoded by this Double must be strictly greater than 0.
      43     5275791 :   DiyFp AsNormalizedDiyFp() const {
      44             :     DCHECK(value() > 0.0);
      45             :     uint64_t f = Significand();
      46             :     int e = Exponent();
      47             : 
      48             :     // The current double could be a denormal.
      49    10725806 :     while ((f & kHiddenBit) == 0) {
      50      174224 :       f <<= 1;
      51      174224 :       e--;
      52             :     }
      53             :     // Do the final shifts in one go.
      54     5275791 :     f <<= DiyFp::kSignificandSize - kSignificandSize;
      55     5275791 :     e -= DiyFp::kSignificandSize - kSignificandSize;
      56     5275791 :     return DiyFp(f, e);
      57             :   }
      58             : 
      59             :   // Returns the double's bit as uint64.
      60             :   uint64_t AsUint64() const {
      61     9242641 :     return d64_;
      62             :   }
      63             : 
      64             :   // Returns the next greater double. Returns +infinity on input +infinity.
      65      333956 :   double NextDouble() const {
      66      333956 :     if (d64_ == kInfinity) return Double(kInfinity).value();
      67      333956 :     if (Sign() < 0 && Significand() == 0) {
      68             :       // -0.0
      69             :       return 0.0;
      70             :     }
      71      333956 :     if (Sign() < 0) {
      72           0 :       return Double(d64_ - 1).value();
      73             :     } else {
      74      333956 :       return Double(d64_ + 1).value();
      75             :     }
      76             :   }
      77             : 
      78             :   int Exponent() const {
      79    19167876 :     if (IsDenormal()) return kDenormalExponent;
      80             : 
      81             :     uint64_t d64 = AsUint64();
      82             :     int biased_e =
      83    19150553 :         static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
      84    19150553 :     return biased_e - kExponentBias;
      85             :   }
      86             : 
      87             :   uint64_t Significand() const {
      88             :     uint64_t d64 = AsUint64();
      89    14549416 :     uint64_t significand = d64 & kSignificandMask;
      90    14549541 :     if (!IsDenormal()) {
      91    14534272 :       return significand + kHiddenBit;
      92             :     } else {
      93             :       return significand;
      94             :     }
      95             :   }
      96             : 
      97             :   // Returns true if the double is a denormal.
      98             :   bool IsDenormal() const {
      99             :     uint64_t d64 = AsUint64();
     100    18608359 :     return (d64 & kExponentMask) == 0;
     101             :   }
     102             : 
     103             :   // We consider denormals not to be special.
     104             :   // Hence only Infinity and NaN are special.
     105             :   bool IsSpecial() const {
     106             :     uint64_t d64 = AsUint64();
     107             :     return (d64 & kExponentMask) == kExponentMask;
     108             :   }
     109             : 
     110             :   bool IsInfinite() const {
     111             :     uint64_t d64 = AsUint64();
     112       12659 :     return ((d64 & kExponentMask) == kExponentMask) &&
     113             :         ((d64 & kSignificandMask) == 0);
     114             :   }
     115             : 
     116             :   int Sign() const {
     117             :     uint64_t d64 = AsUint64();
     118     5534063 :     return (d64 & kSignMask) == 0? 1: -1;
     119             :   }
     120             : 
     121             :   // Precondition: the value encoded by this Double must be greater or equal
     122             :   // than +0.0.
     123             :   DiyFp UpperBoundary() const {
     124             :     DCHECK(Sign() > 0);
     125         682 :     return DiyFp(Significand() * 2 + 1, Exponent() - 1);
     126             :   }
     127             : 
     128             :   // Returns the two boundaries of this.
     129             :   // The bigger boundary (m_plus) is normalized. The lower boundary has the same
     130             :   // exponent as m_plus.
     131             :   // Precondition: the value encoded by this Double must be greater than 0.
     132     3966850 :   void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
     133             :     DCHECK(value() > 0.0);
     134             :     DiyFp v = this->AsDiyFp();
     135             :     bool significand_is_zero = (v.f() == kHiddenBit);
     136     3966850 :     DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
     137             :     DiyFp m_minus;
     138     3966850 :     if (significand_is_zero && v.e() != kDenormalExponent) {
     139             :       // The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
     140             :       // Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
     141             :       // at a distance of 1e8.
     142             :       // The only exception is for the smallest normal: the largest denormal is
     143             :       // at the same distance as its successor.
     144             :       // Note: denormals have the same exponent as the smallest normals.
     145      260597 :       m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2);
     146             :     } else {
     147     3706253 :       m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1);
     148             :     }
     149     3966850 :     m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e()));
     150             :     m_minus.set_e(m_plus.e());
     151     3966850 :     *out_m_plus = m_plus;
     152     3966850 :     *out_m_minus = m_minus;
     153     3966850 :   }
     154             : 
     155             :   double value() const { return uint64_to_double(d64_); }
     156             : 
     157             :   // Returns the significand size for a given order of magnitude.
     158             :   // If v = f*2^e with 2^p-1 <= f <= 2^p then p+e is v's order of magnitude.
     159             :   // This function returns the number of significant binary digits v will have
     160             :   // once its encoded into a double. In almost all cases this is equal to
     161             :   // kSignificandSize. The only exception are denormals. They start with leading
     162             :   // zeroes and their effective significand-size is hence smaller.
     163             :   static int SignificandSizeForOrderOfMagnitude(int order) {
     164       67435 :     if (order >= (kDenormalExponent + kSignificandSize)) {
     165             :       return kSignificandSize;
     166             :     }
     167         196 :     if (order <= kDenormalExponent) return 0;
     168         110 :     return order - kDenormalExponent;
     169             :   }
     170             : 
     171             :  private:
     172             :   static const int kExponentBias = 0x3FF + kPhysicalSignificandSize;
     173             :   static const int kDenormalExponent = -kExponentBias + 1;
     174             :   static const int kMaxExponent = 0x7FF - kExponentBias;
     175             :   static const uint64_t kInfinity = V8_2PART_UINT64_C(0x7FF00000, 00000000);
     176             : 
     177             :   const uint64_t d64_;
     178             : 
     179       67435 :   static uint64_t DiyFpToUint64(DiyFp diy_fp) {
     180       67435 :     uint64_t significand = diy_fp.f();
     181       67435 :     int exponent = diy_fp.e();
     182       67442 :     while (significand > kHiddenBit + kSignificandMask) {
     183           7 :       significand >>= 1;
     184           7 :       exponent++;
     185             :     }
     186       67435 :     if (exponent >= kMaxExponent) {
     187             :       return kInfinity;
     188             :     }
     189       67400 :     if (exponent < kDenormalExponent) {
     190             :       return 0;
     191             :     }
     192       67357 :     while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
     193           0 :       significand <<= 1;
     194           0 :       exponent--;
     195             :     }
     196             :     uint64_t biased_exponent;
     197       67357 :     if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
     198             :       biased_exponent = 0;
     199             :     } else {
     200       67204 :       biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
     201             :     }
     202       67357 :     return (significand & kSignificandMask) |
     203       67357 :         (biased_exponent << kPhysicalSignificandSize);
     204             :   }
     205             : };
     206             : 
     207             : }  // namespace internal
     208             : }  // namespace v8
     209             : 
     210             : #endif  // V8_DOUBLE_H_

Generated by: LCOV version 1.10