Changeset 39958 in webkit for trunk/JavaScriptCore/runtime/Operations.h

Timestamp:

Jan 15, 2009, 7:20:35 PM (16 years ago)

Author:

[email protected]

Message:

2009-01-15 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

On x86-64 allow JSImmediate to encode 64-bit double precision values.
This patch only affects builds that set USE(ALTERNATE_JSIMMEDIATE).

Updates the implementation of JSValuePtr

and JSImmediate:: methods that operate on neumeric values to be be aware of the new representation. When this representation is in use, the class JSNumberCell is redundant and is compiled out.

The format of the new immediate representation is documented in JSImmediate.h.

• JavaScriptCore.exp:
• assembler/MacroAssembler.h: (JSC::MacroAssembler::subPtr):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::subq_rr): (JSC::X86Assembler::movq_rr): (JSC::X86Assembler::ucomisd_rr): (JSC::X86Assembler::X86InstructionFormatter::twoByteOp64):
• interpreter/Interpreter.cpp: (JSC::Interpreter::cti_op_stricteq): (JSC::Interpreter::cti_op_nstricteq):
• jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases):
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_lshift): (JSC::JIT::compileFastArith_op_rshift): (JSC::JIT::compileFastArith_op_bitand): (JSC::JIT::compileFastArith_op_mod): (JSC::JIT::compileFastArith_op_add): (JSC::JIT::compileFastArith_op_mul): (JSC::JIT::compileFastArith_op_post_inc): (JSC::JIT::compileFastArith_op_post_dec): (JSC::JIT::compileFastArith_op_pre_inc): (JSC::JIT::compileFastArith_op_pre_dec): (JSC::JIT::putDoubleResultToJSNumberCellOrJSImmediate): (JSC::JIT::compileBinaryArithOp):
• jit/JITInlineMethods.h: (JSC::JIT::emitJumpIfBothJSCells): (JSC::JIT::emitJumpIfEitherNumber): (JSC::JIT::emitJumpIfNotEitherNumber): (JSC::JIT::emitJumpIfImmediateIntegerNumber): (JSC::JIT::emitJumpIfNotImmediateIntegerNumber): (JSC::JIT::emitJumpIfNotImmediateIntegerNumbers): (JSC::JIT::emitJumpSlowCaseIfNotImmediateIntegerNumber): (JSC::JIT::emitJumpSlowCaseIfNotImmediateIntegerNumbers): (JSC::JIT::emitFastArithDeTagImmediate): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithReTagImmediate): (JSC::JIT::emitFastArithIntToImmNoCheck):
• runtime/JSCell.h:
• runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData):
• runtime/JSImmediate.cpp: (JSC::JSImmediate::toThisObject): (JSC::JSImmediate::toObject): (JSC::JSImmediate::toString):
• runtime/JSImmediate.h: (JSC::wtf_reinterpret_cast): (JSC::JSImmediate::isNumber): (JSC::JSImmediate::isIntegerNumber): (JSC::JSImmediate::isDoubleNumber): (JSC::JSImmediate::isPositiveIntegerNumber): (JSC::JSImmediate::areBothImmediateIntegerNumbers): (JSC::JSImmediate::makeInt): (JSC::JSImmediate::makeDouble): (JSC::JSImmediate::doubleValue): (JSC::doubleToBoolean): (JSC::JSImmediate::toBoolean): (JSC::JSImmediate::getTruncatedUInt32): (JSC::JSImmediate::makeOutOfIntegerRange): (JSC::JSImmediate::from): (JSC::JSImmediate::getTruncatedInt32): (JSC::JSImmediate::toDouble): (JSC::JSImmediate::getUInt32): (JSC::JSValuePtr::isInt32Fast): (JSC::JSValuePtr::isUInt32Fast): (JSC::JSValuePtr::areBothInt32Fast): (JSC::JSFastMath::canDoFastBitwiseOperations): (JSC::JSFastMath::xorImmediateNumbers): (JSC::JSFastMath::canDoFastRshift): (JSC::JSFastMath::canDoFastUrshift): (JSC::JSFastMath::rightShiftImmediateNumbers): (JSC::JSFastMath::canDoFastAdditiveOperations): (JSC::JSFastMath::addImmediateNumbers): (JSC::JSFastMath::subImmediateNumbers):
• runtime/JSNumberCell.cpp: (JSC::jsNumberCell):
• runtime/JSNumberCell.h: (JSC::createNumberStructure): (JSC::isNumberCell): (JSC::asNumberCell): (JSC::jsNumber): (JSC::JSValuePtr::isDoubleNumber): (JSC::JSValuePtr::getDoubleNumber): (JSC::JSValuePtr::isNumber): (JSC::JSValuePtr::uncheckedGetNumber): (JSC::jsNaN): (JSC::JSValuePtr::getNumber): (JSC::JSValuePtr::numberToInt32): (JSC::JSValuePtr::numberToUInt32):
• runtime/JSValue.h:
• runtime/NumberConstructor.cpp: (JSC::numberConstructorNegInfinity): (JSC::numberConstructorPosInfinity): (JSC::numberConstructorMaxValue): (JSC::numberConstructorMinValue):
• runtime/NumberObject.cpp: (JSC::constructNumber):
• runtime/NumberObject.h:
• runtime/Operations.h: (JSC::JSValuePtr::equal): (JSC::JSValuePtr::equalSlowCaseInline): (JSC::JSValuePtr::strictEqual): (JSC::JSValuePtr::strictEqualSlowCaseInline):
• wtf/Platform.h:

File:

• trunk/JavaScriptCore/runtime/Operations.h (modified) (6 diffs)

trunk/JavaScriptCore/runtime/Operations.h

@@ -32 +32 @@
     inline bool JSValuePtr::equal(ExecState* exec, JSValuePtr v1, JSValuePtr v2)
     {
-        if (JSImmediate::areBothImmediateNumbers(v1, v2))
+        if (JSImmediate::areBothImmediateIntegerNumbers(v1, v2))
             return v1 == v2;
 
@@ -40 +40 @@
     ALWAYS_INLINE bool JSValuePtr::equalSlowCaseInline(ExecState* exec, JSValuePtr v1, JSValuePtr v2)
     {
-        ASSERT(!JSImmediate::areBothImmediateNumbers(v1, v2));
+        ASSERT(!JSImmediate::areBothImmediateIntegerNumbers(v1, v2));
 
         do {
@@ -72 +72 @@
                     return false;
                 v1 = p1;
-                if (JSImmediate::areBothImmediateNumbers(v1, v2))
+                if (JSImmediate::areBothImmediateIntegerNumbers(v1, v2))
                     return v1 == v2;
                 continue;
@@ -82 +82 @@
                     return false;
                 v2 = p2;
-                if (JSImmediate::areBothImmediateNumbers(v1, v2))
+                if (JSImmediate::areBothImmediateIntegerNumbers(v1, v2))
                     return v1 == v2;
                 continue;
@@ -108 +108 @@
     inline bool JSValuePtr::strictEqual(JSValuePtr v1, JSValuePtr v2)
     {
-        if (JSImmediate::areBothImmediate(v1, v2))
+        if (JSImmediate::areBothImmediateIntegerNumbers(v1, v2))
             return v1 == v2;
 
-        if (JSImmediate::isEitherImmediate(v1, v2) & (v1 != js0()) & (v2 != js0()))
-            return false;
+        if (v1->isNumber() && v2->isNumber())
+            return v1->uncheckedGetNumber() == v2->uncheckedGetNumber();
+
+        if (JSImmediate::isEitherImmediate(v1, v2))
+            return v1 == v2;
 
         return strictEqualSlowCase(v1, v2);
@@ -119 +122 @@
     ALWAYS_INLINE bool JSValuePtr::strictEqualSlowCaseInline(JSValuePtr v1, JSValuePtr v2)
     {
-        ASSERT(!JSImmediate::areBothImmediate(v1, v2));
+        ASSERT(!JSImmediate::isEitherImmediate(v1, v2));
 
-        if (JSImmediate::isEitherImmediate(v1, v2)) {
-            ASSERT(v1 == js0() || v2 == js0());
-            ASSERT(v1 != v2);
-
-            // The reason we can't just return false here is that 0 === -0,
-            // and while the former is an immediate number, the latter is not.
-            if (v1 == js0())
-                return v2->asCell()->isNumber() && v2->asNumberCell()->value() == 0;
-            return v1->asCell()->isNumber() && v1->asNumberCell()->value() == 0;
-        }
-
-        if (v1->asCell()->isNumber()) {
-            return v2->asCell()->isNumber()
-                && v1->asNumberCell()->value() == v2->asNumberCell()->value();
-        }
-
-        if (v1->asCell()->isString()) {
-            return v2->asCell()->isString()
-                && asString(v1)->value() == asString(v2)->value();
-        }
+        if (v1->asCell()->isString() && v2->asCell()->isString())
+            return asString(v1)->value() == asString(v2)->value();
 
         return v1 == v2;