Changeset 39738 in webkit for trunk/JavaScriptCore/jit/JITPropertyAccess.cpp

Timestamp:

Jan 9, 2009, 12:11:00 AM (16 years ago)

Author:

[email protected]

Message:

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

Reviewed by Oliver Hunt.

Encode immediates in the low word of JSValuePtrs, on x86-64.

On 32-bit platforms a JSValuePtr may represent a 31-bit signed integer.
On 64-bit platforms, if USE(ALTERNATE_JSIMMEDIATE) is defined, a full
32-bit integer may be stored in an immediate.

Presently USE(ALTERNATE_JSIMMEDIATE) uses the same encoding as the default
immediate format - the value is left shifted by one, so a one bit tag can
be added to indicate the value is an immediate. However this means that
values must be commonly be detagged (by right shifting by one) before
arithmetic operations can be performed on immediates. This patch modifies
the formattting so the the high bits of the immediate mark values as being
integer.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::not32): (JSC::MacroAssembler::orPtr): (JSC::MacroAssembler::zeroExtend32ToPtr): (JSC::MacroAssembler::jaePtr): (JSC::MacroAssembler::jbPtr): (JSC::MacroAssembler::jnzPtr): (JSC::MacroAssembler::jzPtr):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::notl_r): (JSC::X86Assembler::testq_i32r):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompileCTIMachineTrampolines):
• jit/JIT.h:
• jit/JITArithmetic.cpp: (JSC::JIT::compileFastArith_op_lshift): (JSC::JIT::compileFastArith_op_rshift): (JSC::JIT::compileFastArith_op_bitand): (JSC::JIT::compileFastArithSlow_op_bitand): (JSC::JIT::compileFastArith_op_mod): (JSC::JIT::compileFastArithSlow_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/JITCall.cpp: (JSC::JIT::compileOpCallSlowCase):
• jit/JITInlineMethods.h: (JSC::JIT::emitJumpIfJSCell): (JSC::JIT::emitJumpIfNotJSCell): (JSC::JIT::emitJumpIfImmNum): (JSC::JIT::emitJumpSlowCaseIfNotImmNum): (JSC::JIT::emitJumpSlowCaseIfNotImmNums): (JSC::JIT::emitFastArithDeTagImmediate): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithReTagImmediate): (JSC::JIT::emitFastArithImmToInt): (JSC::JIT::emitFastArithIntToImmNoCheck): (JSC::JIT::emitTagAsBoolImmediate):
• jit/JITPropertyAccess.cpp: (JSC::resizePropertyStorage): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace):
• runtime/JSImmediate.h: (JSC::JSImmediate::isNumber): (JSC::JSImmediate::isPositiveNumber): (JSC::JSImmediate::areBothImmediateNumbers): (JSC::JSImmediate::xorImmediateNumbers): (JSC::JSImmediate::rightShiftImmediateNumbers): (JSC::JSImmediate::canDoFastAdditiveOperations): (JSC::JSImmediate::addImmediateNumbers): (JSC::JSImmediate::subImmediateNumbers): (JSC::JSImmediate::makeInt): (JSC::JSImmediate::toBoolean):
• wtf/Platform.h:

File:

• trunk/JavaScriptCore/jit/JITPropertyAccess.cpp (modified) (7 diffs)

trunk/JavaScriptCore/jit/JITPropertyAccess.cpp

@@ -183 +183 @@
 }
 
-static JSValueEncodedAsPointer* resizePropertyStorage(JSObject* baseObject, int32_t oldSize, int32_t newSize)
+static JSObject* resizePropertyStorage(JSObject* baseObject, int32_t oldSize, int32_t newSize)
 {
     baseObject->allocatePropertyStorage(oldSize, newSize);
-    return JSValuePtr::encode(baseObject);
+    return baseObject;
 }
 
@@ -198 +198 @@
     JumpList failureCases;
     // Check eax is an object of the right Structure.
-    failureCases.append(jnz32(X86::eax, Imm32(JSImmediate::TagMask)));
+    failureCases.append(emitJumpIfNotJSCell(X86::eax));
     failureCases.append(jnePtr(Address(X86::eax, FIELD_OFFSET(JSCell, m_structure)), ImmPtr(oldStructure)));
     JumpList successCases;
@@ -318 +318 @@
     // Checks out okay! - get the length from the storage
     loadPtr(Address(X86::eax, FIELD_OFFSET(JSArray, m_storage)), X86::ecx);
-    loadPtr(Address(X86::ecx, FIELD_OFFSET(ArrayStorage, m_length)), X86::ecx);
+    load32(Address(X86::ecx, FIELD_OFFSET(ArrayStorage, m_length)), X86::ecx);
 
     Jump failureCases2 = ja32(X86::ecx, Imm32(JSImmediate::maxImmediateInt));
 
-    add32(X86::ecx, X86::ecx);
-    add32(Imm32(1), X86::ecx);
-    signExtend32ToPtr(X86::ecx, X86::eax);
+    emitFastArithIntToImmNoCheck(X86::ecx, X86::eax);
     Jump success = jump();
 
@@ -350 +348 @@
 {
     // Check eax is an object of the right Structure.
-    Jump failureCases1 = jnz32(X86::eax, Imm32(JSImmediate::TagMask));
+    Jump failureCases1 = emitJumpIfNotJSCell(X86::eax);
     Jump failureCases2 = checkStructure(X86::eax, structure);
 
@@ -424 +422 @@
 
     // Check eax is an object of the right Structure.
-    Jump failureCases1 = jne32(X86::eax, Imm32(JSImmediate::TagMask));
+    Jump failureCases1 = emitJumpIfNotJSCell(X86::eax);
     Jump failureCases2 = checkStructure(X86::eax, structure);
 
@@ -642 +640 @@
 
     // Check eax is an object of the right Structure.
-    bucketsOfFail.append(jne32(X86::eax, Imm32(JSImmediate::TagMask)));
+    bucketsOfFail.append(emitJumpIfNotJSCell(X86::eax));
     bucketsOfFail.append(checkStructure(X86::eax, structure));
 
@@ -681 +679 @@
 {
     // Check eax is an object of the right Structure.
-    Jump failureCases1 = jne32(X86::eax, Imm32(JSImmediate::TagMask));
+    Jump failureCases1 = emitJumpIfNotJSCell(X86::eax);
     Jump failureCases2 = checkStructure(X86::eax, structure);