Changeset 39958 in webkit for trunk/JavaScriptCore/jit/JITArithmetic.cpp

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/jit/JITArithmetic.cpp (modified) (22 diffs)

trunk/JavaScriptCore/jit/JITArithmetic.cpp

@@ -50 +50 @@
 {
     emitGetVirtualRegisters(op1, X86::eax, op2, X86::ecx);
-    // FIXME: would we be better using 'emitJumpSlowCaseIfNotImmNums'? - we *probably* ought to be consistent.
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
-    emitJumpSlowCaseIfNotImmNum(X86::ecx);
+    // FIXME: would we be better using 'emitJumpSlowCaseIfNotImmediateIntegers'? - we *probably* ought to be consistent.
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::ecx);
     emitFastArithImmToInt(X86::eax);
     emitFastArithImmToInt(X86::ecx);
@@ -94 +94 @@
     if (isOperandConstantImmediateInt(op2)) {
         emitGetVirtualRegister(op1, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
         // Mask with 0x1f as per ecma-262 11.7.2 step 7.
 #if USE(ALTERNATE_JSIMMEDIATE)
@@ -103 +103 @@
     } else {
         emitGetVirtualRegisters(op1, X86::eax, op2, X86::ecx);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::ecx);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::ecx);
         emitFastArithImmToInt(X86::ecx);
 #if !PLATFORM(X86)
@@ -120 +120 @@
     emitFastArithIntToImmNoCheck(X86::eax, X86::eax);
 #else
-    orPtr(Imm32(JSImmediate::TagTypeInteger), X86::eax);
+    orPtr(Imm32(JSImmediate::TagTypeNumber), X86::eax);
 #endif
     emitPutVirtualRegister(result);
@@ -143 +143 @@
     if (isOperandConstantImmediateInt(op1)) {
         emitGetVirtualRegister(op2, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         int32_t imm = getConstantOperandImmediateInt(op1);
@@ -154 +154 @@
     } else if (isOperandConstantImmediateInt(op2)) {
         emitGetVirtualRegister(op1, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         int32_t imm = getConstantOperandImmediateInt(op2);
@@ -166 +166 @@
         emitGetVirtualRegisters(op1, X86::eax, op2, X86::edx);
         andPtr(X86::edx, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
     }
     emitPutVirtualRegister(result);
@@ -190 +190 @@
 {
     emitGetVirtualRegisters(op1, X86::eax, op2, X86::ecx);
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
-    emitJumpSlowCaseIfNotImmNum(X86::ecx);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::ecx);
 #if USE(ALTERNATE_JSIMMEDIATE)
     addSlowCase(jePtr(X86::ecx, ImmPtr(JSValuePtr::encode(js0()))));
@@ -233 +233 @@
     if (isOperandConstantImmediateInt(op1)) {
         emitGetVirtualRegister(op2, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         // FIXME: investigate performing a 31-bit add here (can we preserve upper bit & detect overflow from low word to high?)
@@ -246 +246 @@
     } else if (isOperandConstantImmediateInt(op2)) {
         emitGetVirtualRegister(op1, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         emitFastArithImmToInt(X86::eax);
@@ -323 +323 @@
     if (isOperandConstantImmediateInt(op1) && ((value = getConstantOperandImmediateInt(op1)) > 0)) {
         emitGetVirtualRegister(op2, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         addSlowCase(joMul32(Imm32(value), X86::eax, X86::eax));
@@ -335 +335 @@
     } else if (isOperandConstantImmediateInt(op2) && ((value = getConstantOperandImmediateInt(op2)) > 0)) {
         emitGetVirtualRegister(op1, X86::eax);
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
         addSlowCase(joMul32(Imm32(value), X86::eax, X86::eax));
@@ -371 +371 @@
     emitGetVirtualRegister(srcDst, X86::eax);
     move(X86::eax, X86::edx);
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
     addSlowCase(joAdd32(Imm32(1), X86::edx));
@@ -396 +396 @@
     emitGetVirtualRegister(srcDst, X86::eax);
     move(X86::eax, X86::edx);
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
     addSlowCase(joSub32(Imm32(1), X86::edx));
@@ -420 +420 @@
 {
     emitGetVirtualRegister(srcDst, X86::eax);
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
     // FIXME: Could add ptr & specify int64; no need to re-sign-extend?
@@ -445 +445 @@
 {
     emitGetVirtualRegister(srcDst, X86::eax);
-    emitJumpSlowCaseIfNotImmNum(X86::eax);
+    emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
 #if USE(ALTERNATE_JSIMMEDIATE)
     addSlowCase(joSub32(Imm32(1), X86::eax));
@@ -548 +548 @@
     __ cvtsi2sd_rr(tempReg1, tempXmm);
     // Compare & branch if immediate. 
-    __ ucomis_rr(tempXmm, xmmSource);
+    __ ucomisd_rr(tempXmm, xmmSource);
     JmpSrc resultIsImm = __ je();
     JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
@@ -585 +585 @@
 
         // Check op2 is a number
-        __ testl_i32r(JSImmediate::TagTypeInteger, X86::edx);
+        __ testl_i32r(JSImmediate::TagTypeNumber, X86::edx);
         JmpSrc op2imm = __ jne();
         if (!types.second().definitelyIsNumber()) {
@@ -595 +595 @@
         // (1) In this case src2 is a reusable number cell.
         //     Slow case if src1 is not a number type.
-        __ testl_i32r(JSImmediate::TagTypeInteger, X86::eax);
+        __ testl_i32r(JSImmediate::TagTypeNumber, X86::eax);
         JmpSrc op1imm = __ jne();
         if (!types.first().definitelyIsNumber()) {
@@ -627 +627 @@
         //     Two slow cases - either src1 isn't an immediate, or the subtract overflows.
         __ link(op2imm, __ label());
-        emitJumpSlowCaseIfNotImmNum(X86::eax);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
     } else if (types.first().isReusable() && isSSE2Present()) {
         ASSERT(types.first().mightBeNumber());
 
         // Check op1 is a number
-        __ testl_i32r(JSImmediate::TagTypeInteger, X86::eax);
+        __ testl_i32r(JSImmediate::TagTypeNumber, X86::eax);
         JmpSrc op1imm = __ jne();
         if (!types.first().definitelyIsNumber()) {
@@ -642 +642 @@
         // (1) In this case src1 is a reusable number cell.
         //     Slow case if src2 is not a number type.
-        __ testl_i32r(JSImmediate::TagTypeInteger, X86::edx);
+        __ testl_i32r(JSImmediate::TagTypeNumber, X86::edx);
         JmpSrc op2imm = __ jne();
         if (!types.second().definitelyIsNumber()) {
@@ -677 +677 @@
         //     Two slow cases - either src2 isn't an immediate, or the subtract overflows.
         __ link(op1imm, __ label());
-        emitJumpSlowCaseIfNotImmNum(X86::edx);
+        emitJumpSlowCaseIfNotImmediateInteger(X86::edx);
     } else
-        emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx);
+        emitJumpSlowCaseIfNotImmediateIntegers(X86::eax, X86::edx, X86::ecx);
 
     if (opcodeID == op_add) {