[JSC] Implement isFinite / isNaN in JS and make DFG ToNumber accept non number values
[WebKit-https.git] / Source / JavaScriptCore / runtime / MathCommon.h
1 /*
2  * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef MathCommon_h
27 #define MathCommon_h
28
29 #include <cmath>
30 #include <wtf/Optional.h>
31
32 namespace JSC {
33
34 const int32_t maxExponentForIntegerMathPow = 1000;
35 double JIT_OPERATION operationMathPow(double x, double y) WTF_INTERNAL;
36 int32_t JIT_OPERATION operationToInt32(double) WTF_INTERNAL;
37
38 inline constexpr double maxSafeInteger()
39 {
40     // 2 ^ 53 - 1
41     return 9007199254740991.0;
42 }
43
44 inline constexpr double minSafeInteger()
45 {
46     // -(2 ^ 53 - 1)
47     return -9007199254740991.0;
48 }
49
50 inline int clz32(uint32_t number)
51 {
52 #if COMPILER(GCC_OR_CLANG)
53     int zeroCount = 32;
54     if (number)
55         zeroCount = __builtin_clz(number);
56     return zeroCount;
57 #else
58     int zeroCount = 0;
59     for (int i = 31; i >= 0; i--) {
60         if (!(number >> i))
61             zeroCount++;
62         else
63             break;
64     }
65     return zeroCount;
66 #endif
67 }
68
69 // This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
70 // Note that this operation is identical to ToUInt32 other than to interpretation
71 // of the resulting bit-pattern (as such this method is also called to implement
72 // ToUInt32).
73 //
74 // The operation can be described as round towards zero, then select the 32 least
75 // bits of the resulting value in 2s-complement representation.
76 ALWAYS_INLINE int32_t toInt32(double number)
77 {
78     int64_t bits = WTF::bitwise_cast<int64_t>(number);
79     int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
80
81     // If exponent < 0 there will be no bits to the left of the decimal point
82     // after rounding; if the exponent is > 83 then no bits of precision can be
83     // left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
84     // of fractional precision).
85     // Note this case handles 0, -0, and all infinite, NaN, & denormal value.
86     if (exp < 0 || exp > 83)
87         return 0;
88
89     // Select the appropriate 32-bits from the floating point mantissa. If the
90     // exponent is 52 then the bits we need to select are already aligned to the
91     // lowest bits of the 64-bit integer representation of the number, no need
92     // to shift. If the exponent is greater than 52 we need to shift the value
93     // left by (exp - 52), if the value is less than 52 we need to shift right
94     // accordingly.
95     int32_t result = (exp > 52)
96         ? static_cast<int32_t>(bits << (exp - 52))
97         : static_cast<int32_t>(bits >> (52 - exp));
98
99     // IEEE-754 double precision values are stored omitting an implicit 1 before
100     // the decimal point; we need to reinsert this now. We may also the shifted
101     // invalid bits into the result that are not a part of the mantissa (the sign
102     // and exponent bits from the floatingpoint representation); mask these out.
103     if (exp < 32) {
104         int32_t missingOne = 1 << exp;
105         result &= missingOne - 1;
106         result += missingOne;
107     }
108
109     // If the input value was negative (we could test either 'number' or 'bits',
110     // but testing 'bits' is likely faster) invert the result appropriately.
111     return bits < 0 ? -result : result;
112 }
113
114 inline Optional<double> safeReciprocalForDivByConst(double constant)
115 {
116     // No "weird" numbers (NaN, Denormal, etc).
117     if (!constant || !std::isnormal(constant))
118         return Nullopt;
119
120     int exponent;
121     if (std::frexp(constant, &exponent) != 0.5)
122         return Nullopt;
123
124     // Note that frexp() returns the value divided by two
125     // so we to offset this exponent by one.
126     exponent -= 1;
127
128     // A double exponent is between -1022 and 1023.
129     // Nothing we can do to invert 1023.
130     if (exponent == 1023)
131         return Nullopt;
132
133     double reciprocal = std::ldexp(1, -exponent);
134     ASSERT(std::isnormal(reciprocal));
135     ASSERT(1. / constant == reciprocal);
136     ASSERT(constant == 1. / reciprocal);
137     ASSERT(1. == constant * reciprocal);
138
139     return reciprocal;
140 }
141
142 extern "C" {
143 double JIT_OPERATION jsRound(double value) REFERENCED_FROM_ASM WTF_INTERNAL;
144
145 // On Windows we need to wrap fmod; on other platforms we can call it directly.
146 // On ARMv7 we assert that all function pointers have to low bit set (point to thumb code).
147 #if CALLING_CONVENTION_IS_STDCALL || CPU(ARM_THUMB2)
148 double JIT_OPERATION jsMod(double x, double y) REFERENCED_FROM_ASM WTF_INTERNAL;
149 #else
150 #define jsMod fmod
151 #endif
152 }
153
154 }
155
156 #endif // MathCommon_h