conversions-inl.h 7.6 KB
Newer Older
1
// Copyright 2011 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4 5 6 7

#ifndef V8_CONVERSIONS_INL_H_
#define V8_CONVERSIONS_INL_H_

8 9 10
#include <float.h>         // Required for DBL_MAX and on Win32 for finite()
#include <limits.h>        // Required for INT_MAX etc.
#include <stdarg.h>
11
#include <cmath>
12
#include "src/globals.h"       // Required for V8_INFINITY
13 14 15 16

// ----------------------------------------------------------------------------
// Extra POSIX/ANSI functions for Win32/MSVC.

17
#include "src/base/bits.h"
18
#include "src/base/platform/platform.h"
19 20
#include "src/conversions.h"
#include "src/double.h"
21
#include "src/objects-inl.h"
22

23 24
namespace v8 {
namespace internal {
25

26
// The fast double-to-unsigned-int conversion routine does not guarantee
27 28
// rounding towards zero, or any reasonable value if the argument is larger
// than what fits in an unsigned 32-bit integer.
29
inline unsigned int FastD2UI(double x) {
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
  // There is no unsigned version of lrint, so there is no fast path
  // in this function as there is in FastD2I. Using lrint doesn't work
  // for values of 2^31 and above.

  // Convert "small enough" doubles to uint32_t by fixing the 32
  // least significant non-fractional bits in the low 32 bits of the
  // double, and reading them from there.
  const double k2Pow52 = 4503599627370496.0;
  bool negative = x < 0;
  if (negative) {
    x = -x;
  }
  if (x < k2Pow52) {
    x += k2Pow52;
    uint32_t result;
45
#ifndef V8_TARGET_BIG_ENDIAN
46
    void* mantissa_ptr = reinterpret_cast<void*>(&x);
47
#else
48 49
    void* mantissa_ptr =
        reinterpret_cast<void*>(reinterpret_cast<Address>(&x) + kInt32Size);
50
#endif
51
    // Copy least significant 32 bits of mantissa.
52
    memcpy(&result, mantissa_ptr, sizeof(result));
53 54 55 56 57 58 59
    return negative ? ~result + 1 : result;
  }
  // Large number (outside uint32 range), Infinity or NaN.
  return 0x80000000u;  // Return integer indefinite.
}


60
inline float DoubleToFloat32(double x) {
61
  // TODO(yangguo): This static_cast is implementation-defined behaviour in C++,
62 63 64 65 66 67
  // so we may need to do the conversion manually instead to match the spec.
  volatile float f = static_cast<float>(x);
  return f;
}


68
inline double DoubleToInteger(double x) {
69 70
  if (std::isnan(x)) return 0;
  if (!std::isfinite(x) || x == 0) return x;
71
  return (x >= 0) ? std::floor(x) : std::ceil(x);
72 73 74 75
}


int32_t DoubleToInt32(double x) {
76 77 78 79
  if ((std::isfinite(x)) && (x <= INT_MAX) && (x >= INT_MIN)) {
    int32_t i = static_cast<int32_t>(x);
    if (FastI2D(i) == x) return i;
  }
80 81 82 83 84 85 86 87 88
  Double d(x);
  int exponent = d.Exponent();
  if (exponent < 0) {
    if (exponent <= -Double::kSignificandSize) return 0;
    return d.Sign() * static_cast<int32_t>(d.Significand() >> -exponent);
  } else {
    if (exponent > 31) return 0;
    return d.Sign() * static_cast<int32_t>(d.Significand() << exponent);
  }
89 90
}

91
bool DoubleToSmiInteger(double value, int* smi_int_value) {
92 93 94
  if (!IsSmiDouble(value)) return false;
  *smi_int_value = FastD2I(value);
  DCHECK(Smi::IsValid(*smi_int_value));
95 96
  return true;
}
97

98
bool IsSmiDouble(double value) {
99 100
  return value >= Smi::kMinValue && value <= Smi::kMaxValue &&
         !IsMinusZero(value) && value == FastI2D(FastD2I(value));
101 102 103 104
}


bool IsInt32Double(double value) {
105 106
  return value >= kMinInt && value <= kMaxInt && !IsMinusZero(value) &&
         value == FastI2D(FastD2I(value));
107 108 109 110 111 112 113 114
}


bool IsUint32Double(double value) {
  return !IsMinusZero(value) && value >= 0 && value <= kMaxUInt32 &&
         value == FastUI2D(FastD2UI(value));
}

115
bool DoubleToUint32IfEqualToSelf(double value, uint32_t* uint32_value) {
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
  const double k2Pow52 = 4503599627370496.0;
  const uint32_t kValidTopBits = 0x43300000;
  const uint64_t kBottomBitMask = V8_2PART_UINT64_C(0x00000000, FFFFFFFF);

  // Add 2^52 to the double, to place valid uint32 values in the low-significant
  // bits of the exponent, by effectively setting the (implicit) top bit of the
  // significand. Note that this addition also normalises 0.0 and -0.0.
  double shifted_value = value + k2Pow52;

  // At this point, a valid uint32 valued double will be represented as:
  //
  // sign = 0
  // exponent = 52
  // significand = 1. 00...00 <value>
  //       implicit^          ^^^^^^^ 32 bits
  //                  ^^^^^^^^^^^^^^^ 52 bits
  //
  // Therefore, we can first check the top 32 bits to make sure that the sign,
  // exponent and remaining significand bits are valid, and only then check the
  // value in the bottom 32 bits.

  uint64_t result = bit_cast<uint64_t>(shifted_value);
  if ((result >> 32) == kValidTopBits) {
    *uint32_value = result & kBottomBitMask;
    return FastUI2D(result & kBottomBitMask) == value;
141 142 143
  }
  return false;
}
144 145

int32_t NumberToInt32(Object* number) {
jgruber's avatar
jgruber committed
146
  if (number->IsSmi()) return Smi::ToInt(number);
147 148 149 150
  return DoubleToInt32(number->Number());
}

uint32_t NumberToUint32(Object* number) {
jgruber's avatar
jgruber committed
151
  if (number->IsSmi()) return Smi::ToInt(number);
152 153 154
  return DoubleToUint32(number->Number());
}

155 156
uint32_t PositiveNumberToUint32(Object* number) {
  if (number->IsSmi()) {
jgruber's avatar
jgruber committed
157
    int value = Smi::ToInt(number);
158 159 160 161 162 163 164 165 166 167 168 169
    if (value <= 0) return 0;
    return value;
  }
  DCHECK(number->IsHeapNumber());
  double value = number->Number();
  // Catch all values smaller than 1 and use the double-negation trick for NANs.
  if (!(value >= 1)) return 0;
  uint32_t max = std::numeric_limits<uint32_t>::max();
  if (value < max) return static_cast<uint32_t>(value);
  return max;
}

170
int64_t NumberToInt64(Object* number) {
jgruber's avatar
jgruber committed
171
  if (number->IsSmi()) return Smi::ToInt(number);
172 173 174 175 176 177 178 179 180
  double d = number->Number();
  if (std::isnan(d)) return 0;
  if (d >= static_cast<double>(std::numeric_limits<int64_t>::max())) {
    return std::numeric_limits<int64_t>::max();
  }
  if (d <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
    return std::numeric_limits<int64_t>::min();
  }
  return static_cast<int64_t>(d);
181
}
182

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
uint64_t PositiveNumberToUint64(Object* number) {
  if (number->IsSmi()) {
    int value = Smi::ToInt(number);
    if (value <= 0) return 0;
    return value;
  }
  DCHECK(number->IsHeapNumber());
  double value = number->Number();
  // Catch all values smaller than 1 and use the double-negation trick for NANs.
  if (!(value >= 1)) return 0;
  uint64_t max = std::numeric_limits<uint64_t>::max();
  if (value < max) return static_cast<uint64_t>(value);
  return max;
}

198
bool TryNumberToSize(Object* number, size_t* result) {
199 200
  // Do not create handles in this function! Don't use SealHandleScope because
  // the function can be used concurrently.
201
  if (number->IsSmi()) {
jgruber's avatar
jgruber committed
202
    int value = Smi::ToInt(number);
203 204 205 206 207 208 209 210 211 212
    DCHECK(static_cast<unsigned>(Smi::kMaxValue) <=
           std::numeric_limits<size_t>::max());
    if (value >= 0) {
      *result = static_cast<size_t>(value);
      return true;
    }
    return false;
  } else {
    DCHECK(number->IsHeapNumber());
    double value = HeapNumber::cast(number)->value();
213 214 215 216 217 218
    // If value is compared directly to the limit, the limit will be
    // casted to a double and could end up as limit + 1,
    // because a double might not have enough mantissa bits for it.
    // So we might as well cast the limit first, and use < instead of <=.
    double maxSize = static_cast<double>(std::numeric_limits<size_t>::max());
    if (value >= 0 && value < maxSize) {
219 220 221 222 223 224 225 226
      *result = static_cast<size_t>(value);
      return true;
    } else {
      return false;
    }
  }
}

227
size_t NumberToSize(Object* number) {
228
  size_t result = 0;
229
  bool is_valid = TryNumberToSize(number, &result);
230 231 232 233 234
  CHECK(is_valid);
  return result;
}


235 236 237 238
uint32_t DoubleToUint32(double x) {
  return static_cast<uint32_t>(DoubleToInt32(x));
}

239 240
}  // namespace internal
}  // namespace v8
241 242

#endif  // V8_CONVERSIONS_INL_H_