Changeset 43432 in webkit for trunk/JavaScriptCore/assembler

Timestamp:

May 9, 2009, 1:35:57 AM (16 years ago)

Author:

[email protected]

Message:

2009-05-09 Maciej Stachowiak <​[email protected]>

Reviewed by Gavin Barraclough.

Original patch by John McCall. Updated by Cameron Zwarich. Further refined by me.

• Assorted speedups to property access

~.3%-1% speedup on SunSpider

1) When we know from the structure ID that an object is using inline storage, plant direct
loads and stores against it; no need to indirect through storage pointer.

2) Also because of the above, union the property storage pointer with the first inline property
slot and add an extra inline property slot.

• assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::CodeLocationInstruction::CodeLocationInstruction): (JSC::AbstractMacroAssembler::CodeLocationInstruction::patchLoadToLEA): (JSC::::CodeLocationCommon::instructionAtOffset):
• assembler/MacroAssembler.h: (JSC::MacroAssembler::storePtr):
• assembler/MacroAssemblerX86.h: (JSC::MacroAssemblerX86::store32):
• assembler/MacroAssemblerX86_64.h: (JSC::MacroAssemblerX86_64::storePtr):
• assembler/X86Assembler.h: (JSC::X86Assembler::movq_EAXm): (JSC::X86Assembler::movl_rm): (JSC::X86Assembler::patchLoadToLEA):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass):
• jit/JIT.h:
• jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::compilePutDirectOffset): (JSC::JIT::compileGetDirectOffset): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::patchPutByIdReplace): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace):
• runtime/JSObject.cpp: (JSC::JSObject::mark): (JSC::JSObject::removeDirect):
• runtime/JSObject.h: (JSC::JSObject::propertyStorage): (JSC::JSObject::getDirect): (JSC::JSObject::getOffset): (JSC::JSObject::offsetForLocation): (JSC::JSObject::locationForOffset): (JSC::JSObject::getDirectOffset): (JSC::JSObject::putDirectOffset): (JSC::JSObject::isUsingInlineStorage): (JSC::JSObject::): (JSC::JSObject::JSObject): (JSC::JSObject::~JSObject): (JSC::Structure::isUsingInlineStorage): (JSC::JSObject::putDirect): (JSC::JSObject::putDirectWithoutTransition): (JSC::JSObject::allocatePropertyStorageInline):
• runtime/Structure.h:

Location:

trunk/JavaScriptCore/assembler

Files:

• AbstractMacroAssembler.h (modified) (4 diffs)
• MacroAssembler.h (modified) (1 diff)
• MacroAssemblerX86.h (modified) (1 diff)
• MacroAssemblerX86_64.h (modified) (1 diff)
• X86Assembler.h (modified) (3 diffs)

trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h

@@ -38 +38 @@
     class Jump;
     class PatchBuffer;
+    class CodeLocationInstruction;
     class CodeLocationLabel;
     class CodeLocationJump;
@@ -407 +408 @@
         // methods may be used to recover a handle that has nopw been
         // retained, based on a known fixed relative offset from one that has.
+        CodeLocationInstruction instructionAtOffset(int offset);
         CodeLocationLabel labelAtOffset(int offset);
         CodeLocationJump jumpAtOffset(int offset);
@@ -423 +425 @@
 
         void* m_location;
+    };
+
+    // CodeLocationInstruction:
+    //
+    // An arbitrary instruction in the JIT code.
+    class CodeLocationInstruction : public CodeLocationCommon {
+        friend class CodeLocationCommon;
+    public:
+        CodeLocationInstruction()
+        {
+        }
+
+        void patchLoadToLEA() {
+            AssemblerType::patchLoadToLEA(reinterpret_cast<intptr_t>(this->m_location));
+        }
+
+    private:
+        explicit CodeLocationInstruction(void* location)
+            : CodeLocationCommon(location)
+        {
+        }
     };
 
@@ -805 +828 @@
 
 template <class AssemblerType>
+typename AbstractMacroAssembler<AssemblerType>::CodeLocationInstruction AbstractMacroAssembler<AssemblerType>::CodeLocationCommon::instructionAtOffset(int offset)
+{
+    return typename AbstractMacroAssembler::CodeLocationInstruction(reinterpret_cast<char*>(m_location) + offset);
+}
+
+template <class AssemblerType>
 typename AbstractMacroAssembler<AssemblerType>::CodeLocationLabel AbstractMacroAssembler<AssemblerType>::CodeLocationCommon::labelAtOffset(int offset)
 {

trunk/JavaScriptCore/assembler/MacroAssembler.h

@@ -243 +243 @@
     }
 
+    void storePtr(RegisterID src, void* address)
+    {
+        store32(src, address);
+    }
+
     void storePtr(ImmPtr imm, ImplicitAddress address)
     {

trunk/JavaScriptCore/assembler/MacroAssemblerX86.h

@@ -71 +71 @@
     }
 
+    void store32(RegisterID src, void* address)
+    {
+        m_assembler.movl_rm(src, address);
+    }
+
     Jump branch32(Condition cond, AbsoluteAddress left, RegisterID right)
     {

trunk/JavaScriptCore/assembler/MacroAssemblerX86_64.h

@@ -242 +242 @@
         m_assembler.movq_rm(src, address.offset, address.base, address.index, address.scale);
     }
+    
+    void storePtr(RegisterID src, void* address)
+    {
+        if (src == X86::eax)
+            m_assembler.movq_EAXm(address);
+        else {
+            swap(X86::eax, src);
+            m_assembler.movq_EAXm(address);
+            swap(X86::eax, src);
+        }
+    }
 
     void storePtr(ImmPtr imm, ImplicitAddress address)

trunk/JavaScriptCore/assembler/X86Assembler.h

@@ -938 +938 @@
     }
 
+    void movq_EAXm(void* addr)
+    {
+        m_formatter.oneByteOp64(OP_MOV_OvEAX);
+        m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
+    }
+
     void movq_mr(int offset, RegisterID base, RegisterID dst)
     {
@@ -972 +978 @@
     
 #else
+    void movl_rm(RegisterID src, void* addr)
+    {
+        if (src == X86::eax)
+            movl_EAXm(addr);
+        else 
+            m_formatter.oneByteOp(OP_MOV_EvGv, src, addr);
+    }
+    
     void movl_mr(void* addr, RegisterID dst)
     {
@@ -1287 +1301 @@
         ASSERT(linkOffset == static_cast<int>(linkOffset));
         reinterpret_cast<int*>(reinterpret_cast<ptrdiff_t>(code) + from.m_offset)[-1] = linkOffset;
+    }
+
+    static void patchLoadToLEA(intptr_t where)
+    {
+        char* ptr = reinterpret_cast<char*>(where);
+        ptr[0] = OP_LEA;
     }