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