Changeset 38857 in webkit for trunk/JavaScriptCore


Ignore:
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:
Location:
trunk/JavaScriptCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r38856 r38857  
     12008-11-29  Gavin Barraclough  <[email protected]>
     2
     3        Reviewed by Camron Zwarich.
     4
     5        Enable WREC on PLATFORM(X86_64).  This change predominantly requires changes to the
     6        WREC::Generator::generateEnter method to support the x86-64 ABI, and addition of
     7        support for a limited number of quadword operations in the X86Assembler.
     8
     9        This patch will cause the JS heap to be allocated with RWX permissions on 64-bit Mac
     10        platforms.  This is a regression with respect to previous 64-bit behaviour, but is no
     11        more permissive than on 32-bit builds.  This issue should be addressed at some point.
     12        (This is tracked by bug #21783.)
     13
     14        https://bugs.webkit.org/show_bug.cgi?id=22554
     15        Greater than 4x speedup on regexp-dna, on x86-64.
     16
     17        * assembler/MacroAssembler.h:
     18        (JSC::MacroAssembler::addPtr):
     19        (JSC::MacroAssembler::loadPtr):
     20        (JSC::MacroAssembler::storePtr):
     21        (JSC::MacroAssembler::pop):
     22        (JSC::MacroAssembler::push):
     23        (JSC::MacroAssembler::move):
     24        * assembler/X86Assembler.h:
     25        (JSC::X86Assembler::):
     26        (JSC::X86Assembler::movq_rr):
     27        (JSC::X86Assembler::addl_i8m):
     28        (JSC::X86Assembler::addl_i32r):
     29        (JSC::X86Assembler::addq_i8r):
     30        (JSC::X86Assembler::addq_i32r):
     31        (JSC::X86Assembler::movq_mr):
     32        (JSC::X86Assembler::movq_rm):
     33        * wrec/WREC.h:
     34        * wrec/WRECGenerator.cpp:
     35        (JSC::WREC::Generator::generateEnter):
     36        (JSC::WREC::Generator::generateReturnSuccess):
     37        (JSC::WREC::Generator::generateReturnFailure):
     38        * wtf/Platform.h:
     39        * wtf/TCSystemAlloc.cpp:
     40
    1412008-12-01  Cameron Zwarich  <[email protected]>
    242

  • trunk/JavaScriptCore/assembler/MacroAssembler.h

    r38854 r38857  
    255255    // object).
    256256
     257    void addPtr(Imm32 imm, RegisterID dest)
     258    {
     259#if PLATFORM(X86_64)
     260        if (CAN_SIGN_EXTEND_8_32(imm.m_value))
     261            m_assembler.addq_i8r(imm.m_value, dest);
     262        else
     263            m_assembler.addq_i32r(imm.m_value, dest);
     264#else
     265        if (CAN_SIGN_EXTEND_8_32(imm.m_value))
     266            m_assembler.addl_i8r(imm.m_value, dest);
     267        else
     268            m_assembler.addl_i32r(imm.m_value, dest);
     269#endif
     270    }
     271
    257272    void add32(Imm32 imm, RegisterID dest)
    258273    {
    … …  
    296311    void loadPtr(ImplicitAddress address, RegisterID dest)
    297312    {
     313#if PLATFORM(X86_64)
     314        if (address.offset)
     315            m_assembler.movq_mr(address.offset, address.base, dest);
     316        else
     317            m_assembler.movq_mr(address.base, dest);
     318#else
    298319        if (address.offset)
    299320            m_assembler.movl_mr(address.offset, address.base, dest);
    300321        else
    301322            m_assembler.movl_mr(address.base, dest);
     323#endif
    302324    }
    303325
    … …  
    320342    void storePtr(RegisterID src, ImplicitAddress address)
    321343    {
     344#if PLATFORM(X86_64)
     345        if (address.offset)
     346            m_assembler.movq_rm(src, address.offset, address.base);
     347        else
     348            m_assembler.movq_rm(src, address.base);
     349#else
    322350        if (address.offset)
    323351            m_assembler.movl_rm(src, address.offset, address.base);
    324352        else
    325353            m_assembler.movl_rm(src, address.base);
     354#endif
    326355    }
    327356   
    … …  
    351380    void pop(RegisterID dest)
    352381    {
     382#if PLATFORM(X86_64)
     383        m_assembler.popq_r(dest);
     384#else
    353385        m_assembler.popl_r(dest);
     386#endif
    354387    }
    355388
    356389    void push(RegisterID src)
    357390    {
     391#if PLATFORM(X86_64)
     392        m_assembler.pushq_r(src);
     393#else
    358394        m_assembler.pushl_r(src);
     395#endif
    359396    }
    360397
    361398    void pop()
    362399    {
    363         m_assembler.addl_i8r(sizeof(void*), X86::esp);
     400        addPtr(Imm32(sizeof(void*)), X86::esp);
    364401    }
    365402   
    … …  
    381418    void move(Imm32 imm, RegisterID dest)
    382419    {
     420        // Note: on 64-bit the Imm32 value is zero extended into the register, it
     421        // may be useful to have a separate version that sign extends the value?
    383422        if (!imm.m_value)
    384423            m_assembler.xorl_rr(dest, dest);
    385424        else
    386425            m_assembler.movl_i32r(imm.m_value, dest);
     426    }
     427
     428    void move(RegisterID src, RegisterID dest)
     429    {
     430        // Note: on 64-bit this is is a full register move; perhaps it would be
     431        // useful to have separate move32 & movePtr, with move32 zero extending?
     432#if PLATFORM(X86_64)
     433        m_assembler.movq_rr(src, dest);
     434#else
     435        m_assembler.movl_rr(src, dest);
     436#endif
    387437    }
    388438

  • trunk/JavaScriptCore/assembler/X86Assembler.h

    r38839 r38857  
    2929#include <wtf/Platform.h>
    3030
    31 #if ENABLE(ASSEMBLER) && PLATFORM(X86)
     31#if ENABLE(ASSEMBLER) && (PLATFORM(X86) || PLATFORM(X86_64))
    3232
    3333#include "AssemblerBuffer.h"
    … …  
    8888        OP_CMP_EvGv                     = 0x39,
    8989        OP_CMP_GvEv                     = 0x3B,
     90        REX_W                           = 0x48,
    9091        OP_PUSH_EAX                     = 0x50,
    9192        OP_POP_EAX                      = 0x58,
    … …  
    218219    }
    219220   
     221#if PLATFORM(X86_64)
     222    void pushq_r(RegisterID reg)
     223    {
     224        m_buffer->putByte(OP_PUSH_EAX + reg);
     225    }
     226
     227    void popq_r(RegisterID reg)
     228    {
     229        m_buffer->putByte(OP_POP_EAX + reg);
     230    }
     231#else
    220232    void pushl_r(RegisterID reg)
    221233    {
    … …  
    245257        modRm_opm(GROUP1A_OP_POP, base, offset);
    246258    }
     259#endif
    247260   
    248261    void movl_rr(RegisterID src, RegisterID dst)
    … …  
    252265    }
    253266   
     267#if PLATFORM(X86_64)
     268    void movq_rr(RegisterID src, RegisterID dst)
     269    {
     270        m_buffer->putByte(REX_W);
     271        m_buffer->putByte(OP_MOV_EvGv);
     272        modRm_rr(src, dst);
     273    }
     274#endif
     275
    254276    void addl_rr(RegisterID src, RegisterID dst)
    255277    {
    … …  
    257279        modRm_rr(src, dst);
    258280    }
     281
     282#if !PLATFORM(X86_64)
     283    void addl_i8m(int imm, void* addr)
     284    {
     285        m_buffer->putByte(OP_GROUP1_EvIb);
     286        modRm_opm(GROUP1_OP_ADD, addr);
     287        m_buffer->putByte(imm);
     288    }
     289#endif
    259290
    260291    void addl_i8r(int imm, RegisterID dst)
    … …  
    265296    }
    266297
    267     void addl_i8m(int imm, void* addr)
    268     {
    269         m_buffer->putByte(OP_GROUP1_EvIb);
    270         modRm_opm(GROUP1_OP_ADD, addr);
    271         m_buffer->putByte(imm);
    272     }
    273 
    274298    void addl_i32r(int imm, RegisterID dst)
    275299    {
    … …  
    279303    }
    280304
     305#if PLATFORM(X86_64)
     306    void addq_i8r(int imm, RegisterID dst)
     307    {
     308        m_buffer->putByte(REX_W);
     309        m_buffer->putByte(OP_GROUP1_EvIb);
     310        modRm_opr(GROUP1_OP_ADD, dst);
     311        m_buffer->putByte(imm);
     312    }
     313
     314    void addq_i32r(int imm, RegisterID dst)
     315    {
     316        m_buffer->putByte(REX_W);
     317        m_buffer->putByte(OP_GROUP1_EvIz);
     318        modRm_opr(GROUP1_OP_ADD, dst);
     319        m_buffer->putInt(imm);
     320    }
     321#endif
     322
    281323    void addl_mr(int offset, RegisterID base, RegisterID dst)
    282324    {
    … …  
    344386    }
    345387
     388#if !PLATFORM(X86_64)
    346389    void cmpl_i32m(int imm, void* addr)
    347390    {
    … …  
    350393        m_buffer->putInt(imm);
    351394    }
     395#endif
    352396
    353397    void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
    … …  
    428472    }
    429473   
     474#if !PLATFORM(X86_64)
    430475    void subl_i8m(int imm, void* addr)
    431476    {
    … …  
    434479        m_buffer->putByte(imm);
    435480    }
     481#endif
    436482
    437483    void subl_i32r(int imm, RegisterID dst)
    … …  
    569615    }
    570616
     617#if PLATFORM(X86_64)
     618    void movq_mr(RegisterID base, RegisterID dst)
     619    {
     620        m_buffer->putByte(REX_W);
     621        m_buffer->putByte(OP_MOV_GvEv);
     622        modRm_rm(dst, base);
     623    }
     624
     625    void movq_mr(int offset, RegisterID base, RegisterID dst)
     626    {
     627        m_buffer->ensureSpace(maxInstructionSize);
     628        m_buffer->putByteUnchecked(REX_W);
     629        m_buffer->putByteUnchecked(OP_MOV_GvEv);
     630        modRm_rm_Unchecked(dst, base, offset);
     631    }
     632#endif
     633
     634#if !PLATFORM(X86_64)
    571635    void movl_mr(void* addr, RegisterID dst)
    572636    {
    … …  
    574638        modRm_rm(dst, addr);
    575639    }
     640#endif
    576641
    577642    void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
    … …  
    621686        modRm_rm_Unchecked(src, base, offset);
    622687    }
    623    
     688
     689#if PLATFORM(X86_64)
     690    void movq_rm(RegisterID src, RegisterID base)
     691    {
     692        m_buffer->putByte(REX_W);
     693        m_buffer->putByte(OP_MOV_EvGv);
     694        modRm_rm(src, base);
     695    }
     696
     697    void movq_rm(RegisterID src, int offset, RegisterID base)
     698    {
     699        m_buffer->ensureSpace(maxInstructionSize);
     700        m_buffer->putByteUnchecked(REX_W);
     701        m_buffer->putByteUnchecked(OP_MOV_EvGv);
     702        modRm_rm_Unchecked(src, base, offset);
     703    }
     704#endif
     705
    624706    void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
    625707    {
    … …  
    643725    }
    644726
     727#if !PLATFORM(X86_64)
    645728    void movl_i32m(int imm, void* addr)
    646729    {
    … …  
    649732        m_buffer->putInt(imm);
    650733    }
     734#endif
    651735
    652736    void leal_mr(int offset, RegisterID base, RegisterID dst)
    … …  
    687771    }
    688772
     773#if !PLATFORM(X86_64)
    689774    void xorpd_mr(void* addr, XMMRegisterID dst)
    690775    {
    … …  
    694779        modRm_rm((RegisterID)dst, addr);
    695780    }
     781#endif
    696782
    697783    void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
    … …  
    10451131    }
    10461132
     1133#if !PLATFORM(X86_64)
    10471134    void modRm_rm(RegisterID reg, void* addr)
    10481135    {
    … …  
    10501137        m_buffer->putInt((int)addr);
    10511138    }
     1139#endif
    10521140
    10531141    void modRm_rm(RegisterID reg, RegisterID base)
    … …  
    11421230    }
    11431231
     1232#if !PLATFORM(X86_64)
    11441233    void modRm_opm(OpcodeID opcodeID, void* addr)
    11451234    {
    11461235        modRm_rm(static_cast<RegisterID>(opcodeID), addr);
    11471236    }
     1237#endif
    11481238
    11491239    void modRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)

  • trunk/JavaScriptCore/wrec/WREC.h

    r38839 r38857  
    3333#include <wtf/unicode/Unicode.h>
    3434
    35 #if COMPILER(GCC)
     35#if COMPILER(GCC) && PLATFORM(X86)
    3636#define WREC_CALL __attribute__ ((regparm (3)))
    3737#else
    … …  
    4747
    4848    typedef int (*CompiledRegExp)(const UChar* input, unsigned start, unsigned length, int* output) WREC_CALL;
    49 //    CompiledRegExp compileRegExp(Interpreter*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
    5049
    5150} } // namespace JSC::WREC

  • trunk/JavaScriptCore/wrec/WRECGenerator.cpp

    r38839 r38857  
    4141void Generator::generateEnter()
    4242{
    43     // Save callee save registers.
    44     push(output);
    45     push(character);
     43#if PLATFORM(X86_64)
     44    // On x86-64 edi and esi are caller preserved, so nothing to do here.
     45    // The four arguments have been passed in the registers %rdi, %rsi,
     46    // %rdx, %rcx - shuffle these into the expected locations.
     47    move(X86::edi, input); // (arg 1) edi -> eax
     48    move(X86::ecx, output); // (arg 4) ecx -> edi
     49    move(X86::edx, length); // (arg 3) edx -> ecx
     50    move(X86::esi, index); // (arg 2) esi -> edx
     51
     52#else
     53    // On x86 edi & esi are callee preserved registers.
     54    push(X86::edi);
     55    push(X86::esi);
    4656   
    4757#if COMPILER(MSVC)
    … …  
    5262    peek(output, 6);
    5363#else
    54     // Initialize the output register.
     64    // On gcc the function is regparm(3), so the input, index, and length registers
     65    // (eax, edx, and ecx respectively) already contain the appropriate values.
     66    // Just load the fourth argument (output) into edi
    5567    peek(output, 3);
     68#endif
    5669#endif
    5770
    … …  
    7285   
    7386    // Restore callee save registers.
    74     pop(character);
    75     pop(output);
     87#if !PLATFORM(X86_64)
     88    pop(X86::esi);
     89    pop(X86::edi);
     90#endif
    7691    ret();
    7792}
    … …  
    113128    pop();
    114129    move(Imm32(-1), X86::eax);
    115     pop(character);
    116     pop(output);
     130#if !PLATFORM(X86_64)
     131    pop(X86::esi);
     132    pop(X86::edi);
     133#endif
    117134    ret();
    118135}

  • trunk/JavaScriptCore/wtf/Platform.h

    r38839 r38857  
    428428
    429429/* WREC only supports x86 at the moment, and has only been tested on Mac and Windows. */
    430 #if !defined(ENABLE_WREC) && PLATFORM(X86) && (PLATFORM(MAC) || PLATFORM(WIN))
     430#if !defined(ENABLE_WREC) \
     431    && ( (PLATFORM(X86) && PLATFORM(MAC)) \
     432        || (PLATFORM(X86_64) && PLATFORM(MAC)) \
     433        || (PLATFORM(X86) && PLATFORM(WIN)) )
    431434#define ENABLE_WREC 1
    432435#endif

  • trunk/JavaScriptCore/wtf/TCSystemAlloc.cpp

    r38477 r38857  
    5454#if HAVE(MMAP)
    5555static const int cProtFlags = PROT_READ | PROT_WRITE
    56 #if ENABLE(JIT) && PLATFORM(GTK)
     56#if ENABLE(ASSEMBLER) && (PLATFORM(GTK) || (PLATFORM(MAC) && PLATFORM(X86_64)))
    5757                              | PROT_EXEC
    5858#endif
Note: See TracChangeset for help on using the changeset viewer.