Unreviewed, rolling out r202413.
[WebKit.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 int clz32(uint32_t number)
39 {
40 #if COMPILER(GCC_OR_CLANG)
41     int zeroCount = 32;
42     if (number)
43         zeroCount = __builtin_clz(number);
44     return zeroCount;
45 #else
46     int zeroCount = 0;
47     for (int i = 31; i >= 0; i--) {
48         if (!(number >> i))
49             zeroCount++;
50         else
51             break;
52     }
53     return zeroCount;
54 #endif
55 }
56
57 // This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
58 // Note that this operation is identical to ToUInt32 other than to interpretation
59 // of the resulting bit-pattern (as such this method is also called to implement
60 // ToUInt32).
61 //
62 // The operation can be described as round towards zero, then select the 32 least
63 // bits of the resulting value in 2s-complement representation.
64 ALWAYS_INLINE int32_t toInt32(double number)
65 {
66     int64_t bits = WTF::bitwise_cast<int64_t>(number);
67     int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
68
69     // If exponent < 0 there will be no bits to the left of the decimal point
70     // after rounding; if the exponent is > 83 then no bits of precision can be
71     // left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
72     // of fractional precision).
73     // Note this case handles 0, -0, and all infinite, NaN, & denormal value.
74     if (exp < 0 || exp > 83)
75         return 0;
76
77     // Select the appropriate 32-bits from the floating point mantissa. If the
78     // exponent is 52 then the bits we need to select are already aligned to the
79     // lowest bits of the 64-bit integer representation of the number, no need
80     // to shift. If the exponent is greater than 52 we need to shift the value
81     // left by (exp - 52), if the value is less than 52 we need to shift right
82     // accordingly.
83     int32_t result = (exp > 52)
84         ? static_cast<int32_t>(bits << (exp - 52))
85         : static_cast<int32_t>(bits >> (52 - exp));
86
87     // IEEE-754 double precision values are stored omitting an implicit 1 before
88     // the decimal point; we need to reinsert this now. We may also the shifted
89     // invalid bits into the result that are not a part of the mantissa (the sign
90     // and exponent bits from the floatingpoint representation); mask these out.
91     if (exp < 32) {
92         int32_t missingOne = 1 << exp;
93         result &= missingOne - 1;
94         result += missingOne;
95     }
96
97     // If the input value was negative (we could test either 'number' or 'bits',
98     // but testing 'bits' is likely faster) invert the result appropriately.
99     return bits < 0 ? -result : result;
100 }
101
102 inline Optional<double> safeReciprocalForDivByConst(double constant)
103 {
104     // No "weird" numbers (NaN, Denormal, etc).
105     if (!constant || !std::isnormal(constant))
106         return Nullopt;
107
108     int exponent;
109     if (std::frexp(constant, &exponent) != 0.5)
110         return Nullopt;
111
112     // Note that frexp() returns the value divided by two
113     // so we to offset this exponent by one.
114     exponent -= 1;
115
116     // A double exponent is between -1022 and 1023.
117     // Nothing we can do to invert 1023.
118     if (exponent == 1023)
119         return Nullopt;
120
121     double reciprocal = std::ldexp(1, -exponent);
122     ASSERT(std::isnormal(reciprocal));
123     ASSERT(1. / constant == reciprocal);
124     ASSERT(constant == 1. / reciprocal);
125     ASSERT(1. == constant * reciprocal);
126
127     return reciprocal;
128 }
129
130 extern "C" {
131 double JIT_OPERATION jsRound(double value) REFERENCED_FROM_ASM WTF_INTERNAL;
132
133 // On Windows we need to wrap fmod; on other platforms we can call it directly.
134 // On ARMv7 we assert that all function pointers have to low bit set (point to thumb code).
135 #if CALLING_CONVENTION_IS_STDCALL || CPU(ARM_THUMB2)
136 double JIT_OPERATION jsMod(double x, double y) REFERENCED_FROM_ASM WTF_INTERNAL;
137 #else
138 #define jsMod fmod
139 #endif
140 }
141
142 }
143
144 #endif // MathCommon_h