Changeset 64938 in webkit for trunk/JavaScriptCore/assembler

Timestamp:

Aug 7, 2010, 11:04:59 PM (15 years ago)

Author:

[email protected]

Message:

2010-08-07 Nathan Lawrence <​[email protected]>

Reviewed by Geoffrey Garen.

The JIT code contains a number of direct references to GC'd objects.
When we have movable objects, these references will need to be
updated.

• Android.mk:
• CMakeLists.txt:
• GNUmakefile.am:
• JavaScriptCore.gypi:
• JavaScriptCore.pro:
• JavaScriptCore.xcodeproj/project.pbxproj:
• assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::int32AtLocation): (JSC::AbstractMacroAssembler::pointerAtLocation): (JSC::AbstractMacroAssembler::jumpTarget):
• assembler/MacroAssembler.h: (JSC::MacroAssembler::loadPtrWithPatch):

Normally, loadPtr will optimize when the register is eax. Since
the slightly smaller instruction changes the offsets, it messes up
our ability to repatch the code. We added this new instruction
that garuntees a constant size.

• assembler/MacroAssemblerX86.h: (JSC::MacroAssemblerX86::load32WithPatch):

Changed load32 in the same way described above.

(JSC::MacroAssemblerX86::load32):

Moved the logic to optimize laod32 from movl_mr to load32

(JSC::MacroAssemblerX86::store32):

Moved the logic to optimize store32 from movl_rm to store32

• assembler/X86Assembler.h: (JSC::X86Assembler::movl_rm): (JSC::X86Assembler::movl_mr): (JSC::X86Assembler::int32AtLocation): (JSC::X86Assembler::pointerAtLocation): (JSC::X86Assembler::jumpTarget):
• bytecode/CodeBlock.cpp: (JSC::CodeBlock::markAggregate):
• bytecode/Instruction.h:

As described in StructureStubInfo.h, we needed to add additional
fields to both StructureStubInfo and
PolymorphicAccessStructureList so that we can determine the
structure of the JITed code at patch time.

(JSC::PolymorphicAccessStructureList::PolymorphicStubInfo::set):
(JSC::PolymorphicAccessStructureList::PolymorphicAccessStructureList):

• bytecode/StructureStubInfo.cpp: (JSC::StructureStubInfo::markAggregate):

Added this function to mark the JITed code that correosponds to
this structure stub info.

• bytecode/StructureStubInfo.h: (JSC::StructureStubInfo::initGetByIdProto): (JSC::StructureStubInfo::initGetByIdChain): (JSC::StructureStubInfo::):
• jit/JIT.h:
• jit/JITMarkObjects.cpp: Added. (JSC::JIT::patchPrototypeStructureAddress): (JSC::JIT::patchGetDirectOffset): (JSC::JIT::markGetByIdProto): (JSC::JIT::markGetByIdChain): (JSC::JIT::markGetByIdProtoList): (JSC::JIT::markPutByIdTransition): (JSC::JIT::markGlobalObjectReference):
• jit/JITPropertyAccess.cpp:

Added asserts for the patch offsets.

(JSC::JIT::compileGetDirectOffset):
(JSC::JIT::testPrototype):
(JSC::JIT::privateCompilePutByIdTransition):
(JSC::JIT::privateCompileGetByIdProto):
(JSC::JIT::privateCompileGetByIdProtoList):
(JSC::JIT::privateCompileGetByIdChainList):
(JSC::JIT::privateCompileGetByIdChain):

• jit/JITPropertyAccess32_64.cpp: (JSC::JIT::compileGetDirectOffset): (JSC::JIT::testPrototype): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain):
• jit/JITStubs.cpp: (JSC::setupPolymorphicProtoList):
• wtf/Platform.h:

Added ENABLE_MOVABLE_GC_OBJECTS flag

Location:

trunk/JavaScriptCore/assembler

Files:

• AbstractMacroAssembler.h (modified) (1 diff)
• MacroAssembler.h (modified) (1 diff)
• MacroAssemblerX86.h (modified) (2 diffs)
• X86Assembler.h (modified) (2 diffs)

trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@ -522 +522 @@
     }
 
+    static int32_t int32AtLocation(CodeLocationDataLabel32 dataLabel32)
+    {
+        return AssemblerType::int32AtLocation(dataLabel32.dataLocation());
+    }
+
+    static void* pointerAtLocation(CodeLocationDataLabelPtr dataLabelPtr)
+    {
+        return AssemblerType::pointerAtLocation(dataLabelPtr.dataLocation());
+    }
+
+    static void* jumpTarget(CodeLocationJump jump)
+    {
+        return AssemblerType::jumpTarget(jump.dataLocation());
+    }
+
     static void repatchInt32(CodeLocationDataLabel32 dataLabel32, int32_t value)
     {

trunk/JavaScriptCore/assembler/MacroAssembler.h

@@ -210 +210 @@
     }
 
+    void loadPtrWithPatch(void* address, RegisterID dest)
+    {
+        load32WithPatch(address, dest);
+    }
 
     void loadPtr(ImplicitAddress address, RegisterID dest)

trunk/JavaScriptCore/assembler/MacroAssemblerX86.h

@@ -83 +83 @@
     }
 
+    void load32WithPatch(void* address, RegisterID dest)
+    {
+        m_assembler.movl_mr(address, dest);
+    }
+
     void load32(void* address, RegisterID dest)
     {
-        m_assembler.movl_mr(address, dest);
+        if (dest == X86Registers::eax)
+            m_assembler.movl_mEAX(address);
+        else
+            m_assembler.movl_mr(address, dest);
     }
 
@@ -106 +114 @@
     void store32(RegisterID src, void* address)
     {
-        m_assembler.movl_rm(src, address);
+        if (src == X86Registers::eax)
+            m_assembler.movl_EAXm(address);
+        else
+            m_assembler.movl_rm(src, address);
     }
 

trunk/JavaScriptCore/assembler/X86Assembler.h

@@ -1155 +1155 @@
     void movl_rm(RegisterID src, void* addr)
     {
-        if (src == X86Registers::eax)
-            movl_EAXm(addr);
-        else 
-            m_formatter.oneByteOp(OP_MOV_EvGv, src, addr);
+        m_formatter.oneByteOp(OP_MOV_EvGv, src, addr);
     }
     
     void movl_mr(void* addr, RegisterID dst)
     {
-        if (dst == X86Registers::eax)
-            movl_mEAX(addr);
-        else
-            m_formatter.oneByteOp(OP_MOV_GvEv, dst, addr);
+        m_formatter.oneByteOp(OP_MOV_GvEv, dst, addr);
     }
 
@@ -1558 +1552 @@
 
         setPointer(reinterpret_cast<char*>(code) + where.m_offset, value);
+    }
+
+    static int32_t int32AtLocation(void* where)
+    {
+        return static_cast<int32_t*>(where)[-1];
+    }
+
+    static void* pointerAtLocation(void* where)
+    {
+        return static_cast<void**>(where)[-1];
+    }
+
+    static void* jumpTarget(void* jump)
+    {
+        intptr_t src = reinterpret_cast<intptr_t>(jump);
+        int32_t offset = static_cast<int32_t*>(jump)[-1];
+        return reinterpret_cast<void*>(src + offset);
     }