Changeset 67825 in webkit for trunk/JavaScriptCore/runtime/JSValue.cpp

Timestamp:

Sep 19, 2010, 6:23:33 PM (15 years ago)

Author:

[email protected]

Message:

Bug 46065 - Unify implementation of ToInt32 and ToUInt32, don't use fmod.

Reviewed by Oliver Hunt.

These methods implement the same conversion (see discussion in the notes
of sections of 9.5 and 9.6 of the spec), only differing in how the result
is interpretted.

JavaScriptCore:

Date prototype is incorrectly using toInt32, and this is causing us to
provide an output value indicating whether the input to ToInt32 was finite
(the corresponding methods on Date are actually spec'ed to use ToInteger,
not ToInt32). This patch partially fixes this in order to remove this
bogus output value, hoewever more work will be require to bring Date
fully up to spec compliance (the constructor is still performing ToInt32
conversions).

• JavaScriptCore.exp:
• runtime/DatePrototype.cpp:

(JSC::fillStructuresUsingTimeArgs):
(JSC::fillStructuresUsingDateArgs):
(JSC::dateProtoFuncSetYear):

• runtime/JSValue.cpp:

(JSC::toInt32):

• runtime/JSValue.h:

(JSC::toUInt32):
(JSC::JSValue::toInt32):
(JSC::JSValue::toUInt32):

WebCore:

Removing JSValue::toInt32 (since this has weird, non-spec function).
A couple of places in the binding are using this method, so adding
finiteInt32Value to the bindings to maintain current behaviour.

Test: fast/js/toInt32UInt32.html

• bindings/js/JSDOMBinding.h:

(WebCore::finiteInt32Value):

• bindings/js/JSHTMLOptionsCollectionCustom.cpp:

(WebCore::JSHTMLOptionsCollection::add):

• bindings/js/JSSQLResultSetRowListCustom.cpp:

(WebCore::JSSQLResultSetRowList::item):

• bindings/js/JSSVGPODListCustom.h:

(WebCore::JSSVGPODListCustom::getItem):
(WebCore::JSSVGPODListCustom::insertItemBefore):
(WebCore::JSSVGPODListCustom::replaceItem):
(WebCore::JSSVGPODListCustom::removeItem):

• bindings/js/JSSVGPathSegListCustom.cpp:

(WebCore::JSSVGPathSegList::getItem):
(WebCore::JSSVGPathSegList::insertItemBefore):
(WebCore::JSSVGPathSegList::replaceItem):
(WebCore::JSSVGPathSegList::removeItem):

LayoutTests:

Add test cases for ToInt32 / ToUInt32 functionality.

• fast/js/script-tests/toInt32UInt32.js: Added.
• fast/js/toInt32UInt32-expected.txt: Added.
• fast/js/toInt32UInt32.html: Added.

File:

• trunk/JavaScriptCore/runtime/JSValue.cpp (modified) (1 diff)

trunk/JavaScriptCore/runtime/JSValue.cpp

@@ -136 +136 @@
 #endif
 
-int32_t toInt32SlowCase(double d, bool& ok)
+// This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
+// Note that this operation is identical to ToUInt32 other than to interpretation
+// of the resulting bit-pattern (as such this metod is also called to implement
+// ToUInt32).
+//
+// The operation can be descibed as round towards zero, then select the 32 least
+// bits of the resulting value in 2s-complement representation.
+int32_t toInt32(double number)
 {
-    if (isnan(d) || isinf(d)) {
-        ok = false;
+    int64_t bits = WTF::bitwise_cast<int64_t>(number);
+    int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
+
+    // If exponent < 0 there will be no bits to the left of the decimal point
+    // after rounding; if the exponent is > 83 then no bits of precision can be
+    // left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
+    // of fractional precision).
+    // Note this case handles 0, -0, and all infinte, NaN, & denormal value. 
+    if (exp < 0 || exp > 83)
         return 0;
+
+    // Select the appropriate 32-bits from the floating point mantissa.  If the
+    // exponent is 52 then the bits we need to select are already aligned to the
+    // lowest bits of the 64-bit integer representation of tghe number, no need
+    // to shift.  If the exponent is greater than 52 we need to shift the value
+    // left by (exp - 52), if the value is less than 52 we need to shift right
+    // accordingly.
+    int32_t result = (exp > 52)
+        ? static_cast<int32_t>(bits << (exp - 52))
+        : static_cast<int32_t>(bits >> (52 - exp));
+
+    // IEEE-754 double precision values are stored omitting an implicit 1 before
+    // the decimal point; we need to reinsert this now.  We may also the shifted
+    // invalid bits into the result that are not a part of the mantissa (the sign
+    // and exponent bits from the floatingpoint representation); mask these out.
+    if (exp < 32) {
+        int32_t missingOne = 1 << exp;
+        result &= missingOne - 1;
+        result += missingOne;
     }
 
-    ok = true;
-
-    double d32 = fmod(trunc(d), D32);
-    if (d32 >= D32 / 2)
-        d32 -= D32;
-    else if (d32 < -D32 / 2)
-        d32 += D32;
-    return static_cast<int32_t>(d32);
-}
-
-uint32_t toUInt32SlowCase(double d, bool& ok)
-{
-    if (isnan(d) || isinf(d)) {
-        ok = false;
-        return 0;
-    }
-
-    ok = true;
-
-    double d32 = fmod(trunc(d), D32);
-    if (d32 < 0)
-        d32 += D32;
-    return static_cast<uint32_t>(d32);
+    // If the input value was negative (we could test either 'number' or 'bits',
+    // but testing 'bits' is likely faster) invert the result appropriately.
+    return bits < 0 ? -result : result;
 }