Changeset 38857 in webkit for trunk/JavaScriptCore/assembler/MacroAssembler.h

Timestamp:

Dec 1, 2008, 1:18:36 AM (16 years ago)

Author:

[email protected]

Message:

2008-11-29 Gavin Barraclough <​[email protected]>

Reviewed by Camron Zwarich.

Enable WREC on PLATFORM(X86_64). This change predominantly requires changes to the
WREC::Generator::generateEnter method to support the x86-64 ABI, and addition of
support for a limited number of quadword operations in the X86Assembler.

This patch will cause the JS heap to be allocated with RWX permissions on 64-bit Mac
platforms. This is a regression with respect to previous 64-bit behaviour, but is no
more permissive than on 32-bit builds. This issue should be addressed at some point.
(This is tracked by bug #21783.)

​https://bugs.webkit.org/show_bug.cgi?id=22554
Greater than 4x speedup on regexp-dna, on x86-64.

• assembler/MacroAssembler.h: (JSC::MacroAssembler::addPtr): (JSC::MacroAssembler::loadPtr): (JSC::MacroAssembler::storePtr): (JSC::MacroAssembler::pop): (JSC::MacroAssembler::push): (JSC::MacroAssembler::move):
• assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::movq_rr): (JSC::X86Assembler::addl_i8m): (JSC::X86Assembler::addl_i32r): (JSC::X86Assembler::addq_i8r): (JSC::X86Assembler::addq_i32r): (JSC::X86Assembler::movq_mr): (JSC::X86Assembler::movq_rm):
• wrec/WREC.h:
• wrec/WRECGenerator.cpp: (JSC::WREC::Generator::generateEnter): (JSC::WREC::Generator::generateReturnSuccess): (JSC::WREC::Generator::generateReturnFailure):
• wtf/Platform.h:
• wtf/TCSystemAlloc.cpp:

File:

• trunk/JavaScriptCore/assembler/MacroAssembler.h (modified) (5 diffs)

trunk/JavaScriptCore/assembler/MacroAssembler.h

@@ -255 +255 @@
     // object).
 
+    void addPtr(Imm32 imm, RegisterID dest)
+    {
+#if PLATFORM(X86_64)
+        if (CAN_SIGN_EXTEND_8_32(imm.m_value))
+            m_assembler.addq_i8r(imm.m_value, dest);
+        else
+            m_assembler.addq_i32r(imm.m_value, dest);
+#else
+        if (CAN_SIGN_EXTEND_8_32(imm.m_value))
+            m_assembler.addl_i8r(imm.m_value, dest);
+        else
+            m_assembler.addl_i32r(imm.m_value, dest);
+#endif
+    }
+
     void add32(Imm32 imm, RegisterID dest)
     {
@@ -296 +311 @@
     void loadPtr(ImplicitAddress address, RegisterID dest)
     {
+#if PLATFORM(X86_64)
+        if (address.offset)
+            m_assembler.movq_mr(address.offset, address.base, dest);
+        else
+            m_assembler.movq_mr(address.base, dest);
+#else
         if (address.offset)
             m_assembler.movl_mr(address.offset, address.base, dest);
         else
             m_assembler.movl_mr(address.base, dest);
+#endif
     }
 
@@ -320 +342 @@
     void storePtr(RegisterID src, ImplicitAddress address)
     {
+#if PLATFORM(X86_64)
+        if (address.offset)
+            m_assembler.movq_rm(src, address.offset, address.base);
+        else
+            m_assembler.movq_rm(src, address.base);
+#else
         if (address.offset)
             m_assembler.movl_rm(src, address.offset, address.base);
         else
             m_assembler.movl_rm(src, address.base);
+#endif
     }
     
@@ -351 +380 @@
     void pop(RegisterID dest)
     {
+#if PLATFORM(X86_64)
+        m_assembler.popq_r(dest);
+#else
         m_assembler.popl_r(dest);
+#endif
     }
 
     void push(RegisterID src)
     {
+#if PLATFORM(X86_64)
+        m_assembler.pushq_r(src);
+#else
         m_assembler.pushl_r(src);
+#endif
     }
 
     void pop()
     {
-        m_assembler.addl_i8r(sizeof(void*), X86::esp);
+        addPtr(Imm32(sizeof(void*)), X86::esp);
     }
     
@@ -381 +418 @@
     void move(Imm32 imm, RegisterID dest)
     {
+        // Note: on 64-bit the Imm32 value is zero extended into the register, it
+        // may be useful to have a separate version that sign extends the value?
         if (!imm.m_value)
             m_assembler.xorl_rr(dest, dest);
         else
             m_assembler.movl_i32r(imm.m_value, dest);
+    }
+
+    void move(RegisterID src, RegisterID dest)
+    {
+        // Note: on 64-bit this is is a full register move; perhaps it would be
+        // useful to have separate move32 & movePtr, with move32 zero extending?
+#if PLATFORM(X86_64)
+        m_assembler.movq_rr(src, dest);
+#else
+        m_assembler.movl_rr(src, dest);
+#endif
     }