Changeset 148893 in webkit


Ignore:
Timestamp:
Apr 22, 2013 10:37:29 AM (11 years ago)
Author:
mark.lam@apple.com
Message:

Change baseline JIT watchdog timer check to use the proper fast slow path
infrastructure.
https://bugs.webkit.org/show_bug.cgi?id=114963.

Reviewed by Oliver Hunt.

SH4 parts contributed by Julien Brianceau.

  • assembler/ARMAssembler.h:
  • assembler/MacroAssemblerARM.h:
  • assembler/MacroAssemblerARMv7.h:
  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::branchAdd32):

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::branchAdd32):

  • assembler/MacroAssemblerX86Common.h:
  • assembler/SH4Assembler.h:
  • jit/JIT.cpp:

(JSC::JIT::emitEnterOptimizationCheck):
(JSC::JIT::privateCompileSlowCases):

  • jit/JIT.h:

(JSC::JIT::emitEnterOptimizationCheck):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_loop_hint):
(JSC::JIT::emitSlow_op_loop_hint):
(JSC::JIT::emit_op_enter):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_enter):

Location:
trunk/Source/JavaScriptCore
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r148891 r148893  
     12013-04-22  Mark Lam  <mark.lam@apple.com>
     2
     3        Change baseline JIT watchdog timer check to use the proper fast slow path
     4        infrastructure.
     5        https://bugs.webkit.org/show_bug.cgi?id=114963.
     6
     7        Reviewed by Oliver Hunt.
     8
     9        SH4 parts contributed by Julien Brianceau.
     10
     11        * assembler/ARMAssembler.h:
     12        * assembler/MacroAssemblerARM.h:
     13        * assembler/MacroAssemblerARMv7.h:
     14        * assembler/MacroAssemblerMIPS.h:
     15        (JSC::MacroAssemblerMIPS::branchAdd32):
     16        * assembler/MacroAssemblerSH4.h:
     17        (JSC::MacroAssemblerSH4::branchAdd32):
     18        * assembler/MacroAssemblerX86Common.h:
     19        * assembler/SH4Assembler.h:
     20        * jit/JIT.cpp:
     21        (JSC::JIT::emitEnterOptimizationCheck):
     22        (JSC::JIT::privateCompileSlowCases):
     23        * jit/JIT.h:
     24        (JSC::JIT::emitEnterOptimizationCheck):
     25        * jit/JITOpcodes.cpp:
     26        (JSC::JIT::emit_op_loop_hint):
     27        (JSC::JIT::emitSlow_op_loop_hint):
     28        (JSC::JIT::emit_op_enter):
     29        * jit/JITOpcodes32_64.cpp:
     30        (JSC::JIT::emit_op_enter):
     31
    1322013-04-22  Andreas Kling  <akling@apple.com>
    233
  • trunk/Source/JavaScriptCore/assembler/ARMAssembler.h

    r148696 r148893  
    108108        // ARM conditional constants
    109109        typedef enum {
    110             EQ = 0x00000000, // Zero
    111             NE = 0x10000000, // Non-zero
    112             CS = 0x20000000,
    113             CC = 0x30000000,
    114             MI = 0x40000000,
    115             PL = 0x50000000,
    116             VS = 0x60000000,
    117             VC = 0x70000000,
    118             HI = 0x80000000,
    119             LS = 0x90000000,
    120             GE = 0xa0000000,
    121             LT = 0xb0000000,
    122             GT = 0xc0000000,
    123             LE = 0xd0000000,
    124             AL = 0xe0000000
     110            EQ = 0x00000000, // Zero / Equal.
     111            NE = 0x10000000, // Non-zero / Not equal.
     112            CS = 0x20000000, // Unsigned higher or same.
     113            CC = 0x30000000, // Unsigned lower.
     114            MI = 0x40000000, // Negative.
     115            PL = 0x50000000, // Positive or zero.
     116            VS = 0x60000000, // Overflowed.
     117            VC = 0x70000000, // Not overflowed.
     118            HI = 0x80000000, // Unsigned higher.
     119            LS = 0x90000000, // Unsigned lower or same.
     120            GE = 0xa0000000, // Signed greater than or equal.
     121            LT = 0xb0000000, // Signed less than.
     122            GT = 0xc0000000, // Signed greater than.
     123            LE = 0xd0000000, // Signed less than or euqal.
     124            AL = 0xe0000000  // Unconditional / Always execute.
    125125        } Condition;
    126126
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h

    r148134 r148893  
    5959        Overflow = ARMAssembler::VS,
    6060        Signed = ARMAssembler::MI,
     61        PositiveOrZero = ARMAssembler::PL,
    6162        Zero = ARMAssembler::EQ,
    6263        NonZero = ARMAssembler::NE
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r147892 r148893  
    120120        Overflow = ARMv7Assembler::ConditionVS,
    121121        Signed = ARMv7Assembler::ConditionMI,
     122        PositiveOrZero = ARMAssembler::PL,
    122123        Zero = ARMv7Assembler::ConditionEQ,
    123124        NonZero = ARMv7Assembler::ConditionNE
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r146339 r148893  
    8181        Overflow,
    8282        Signed,
     83        PositiveOrZero,
    8384        Zero,
    8485        NonZero
     
    15101511    Jump branchAdd32(ResultCondition cond, RegisterID src, RegisterID dest)
    15111512    {
    1512         ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     1513        ASSERT((cond == Overflow) || (cond == Signed) || (cond == PositiveOrZero) || (cond == Zero) || (cond == NonZero));
    15131514        if (cond == Overflow) {
    15141515            /*
     
    15411542            // Check if dest is negative.
    15421543            m_assembler.slt(cmpTempRegister, dest, MIPSRegisters::zero);
     1544            return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
     1545        }
     1546        if (cond == PositiveOrZero) {
     1547            add32(src, dest);
     1548            // Check if dest is negative.
     1549            m_assembler.slt(cmpTempRegister, MIPSRegisters::zero, dest);
    15431550            return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
    15441551        }
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h

    r140594 r148893  
    6969        Overflow = SH4Assembler::OF,
    7070        Signed = SH4Assembler::SI,
     71        PositiveOrZero = SH4Assembler::NS,
    7172        Zero = SH4Assembler::EQ,
    7273        NonZero = SH4Assembler::NE
     
    19211922        }
    19221923
     1924        if (cond == PositiveOrZero) {
     1925            m_assembler.addlRegReg(src, dest);
     1926            m_assembler.cmppz(dest);
     1927            return branchTrue();
     1928        }
     1929
    19231930        m_assembler.addlRegReg(src, dest);
    19241931        compare32(0, dest, Equal);
     
    19551962            m_assembler.cmppz(dest);
    19561963            return branchFalse();
     1964        }
     1965
     1966        if (cond == PositiveOrZero) {
     1967            m_assembler.cmppz(dest);
     1968            return branchTrue();
    19571969        }
    19581970
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

    r133953 r148893  
    6969        Overflow = X86Assembler::ConditionO,
    7070        Signed = X86Assembler::ConditionS,
     71        PositiveOrZero = X86Assembler::ConditionNS,
    7172        Zero = X86Assembler::ConditionE,
    7273        NonZero = X86Assembler::ConditionNE
  • trunk/Source/JavaScriptCore/assembler/SH4Assembler.h

    r148696 r148893  
    342342        EQ = 0x0, // Equal
    343343        NE = 0x1, // Not Equal
    344         HS = 0x2, // Unsigend Greater Than equal
    345         HI = 0x3, // Unsigend Greater Than
    346         LS = 0x4, // Unsigend Lower or Same
    347         LI = 0x5, // Unsigend Lower
     344        HS = 0x2, // Unsigned Greater Than equal
     345        HI = 0x3, // Unsigned Greater Than
     346        LS = 0x4, // Unsigned Lower or Same
     347        LI = 0x5, // Unsigned Lower
    348348        GE = 0x6, // Greater or Equal
    349349        LT = 0x7, // Less Than
     
    352352        OF = 0xa, // OverFlow
    353353        SI = 0xb, // Signed
    354         EQU= 0xc, // Equal or unordered(NaN)
    355         NEU= 0xd,
    356         GTU= 0xe,
    357         GEU= 0xf,
    358         LTU= 0x10,
    359         LEU= 0x11,
     354        NS = 0xc, // Not Signed
     355        EQU= 0xd, // Equal or unordered(NaN)
     356        NEU= 0xe,
     357        GTU= 0xf,
     358        GEU= 0x10,
     359        LTU= 0x11,
     360        LEU= 0x12,
    360361    } Condition;
    361362
  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r148696 r148893  
    104104
    105105#if ENABLE(DFG_JIT)
    106 void JIT::emitOptimizationCheck(OptimizationCheckKind kind)
     106void JIT::emitEnterOptimizationCheck()
    107107{
    108108    if (!canBeOptimized())
    109109        return;
    110    
    111     Jump skipOptimize = branchAdd32(Signed, TrustedImm32(kind == LoopOptimizationCheck ? Options::executionCounterIncrementForLoop() : Options::executionCounterIncrementForReturn()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter()));
     110
     111    Jump skipOptimize = branchAdd32(Signed, TrustedImm32(Options::executionCounterIncrementForReturn()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter()));
    112112    JITStubCall stubCall(this, cti_optimize);
    113113    stubCall.addArgument(TrustedImm32(m_bytecodeOffset));
    114     if (kind == EnterOptimizationCheck)
    115         ASSERT(!m_bytecodeOffset);
     114    ASSERT(!m_bytecodeOffset);
    116115    stubCall.call();
    117116    skipOptimize.link(this);
    118117}
    119118#endif
    120 
    121 void JIT::emitWatchdogTimerCheck()
    122 {
    123     if (!m_vm->watchdog.isEnabled())
    124         return;
    125 
    126     Jump skipCheck = branchTest8(Zero, AbsoluteAddress(m_vm->watchdog.timerDidFireAddress()));
    127     JITStubCall stubCall(this, cti_handle_watchdog_timer);
    128     stubCall.call();
    129     skipCheck.link(this);
    130 }
    131119
    132120#define NEXT_OPCODE(name) \
     
    474462        DEFINE_SLOWCASE_OP(op_jngreatereq)
    475463        DEFINE_SLOWCASE_OP(op_jtrue)
     464        DEFINE_SLOWCASE_OP(op_loop_hint)
    476465        DEFINE_SLOWCASE_OP(op_lshift)
    477466        DEFINE_SLOWCASE_OP(op_mod)
  • trunk/Source/JavaScriptCore/jit/JIT.h

    r148696 r148893  
    781781        void emitSlow_op_jngreatereq(Instruction*, Vector<SlowCaseEntry>::iterator&);
    782782        void emitSlow_op_jtrue(Instruction*, Vector<SlowCaseEntry>::iterator&);
     783        void emitSlow_op_loop_hint(Instruction*, Vector<SlowCaseEntry>::iterator&);
    783784        void emitSlow_op_lshift(Instruction*, Vector<SlowCaseEntry>::iterator&);
    784785        void emitSlow_op_mod(Instruction*, Vector<SlowCaseEntry>::iterator&);
     
    853854        void emitLoadCharacterString(RegisterID src, RegisterID dst, JumpList& failures);
    854855       
    855         enum OptimizationCheckKind { LoopOptimizationCheck, EnterOptimizationCheck };
    856856#if ENABLE(DFG_JIT)
    857         void emitOptimizationCheck(OptimizationCheckKind);
    858 #else
    859         void emitOptimizationCheck(OptimizationCheckKind) { }
    860 #endif
    861         void emitWatchdogTimerCheck();
     857        void emitEnterOptimizationCheck();
     858#else
     859        void emitEnterOptimizationCheck() { }
     860#endif
    862861
    863862#ifndef NDEBUG
     
    945944    } JIT_CLASS_ALIGNMENT;
    946945
    947     inline void JIT::emit_op_loop_hint(Instruction*)
    948     {
    949         emitWatchdogTimerCheck();
    950         emitOptimizationCheck(LoopOptimizationCheck);
    951     }
    952 
    953946} // namespace JSC
    954947
  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r148711 r148893  
    482482}
    483483
     484void JIT::emit_op_loop_hint(Instruction*)
     485{
     486    // Emit the watchdog timer check:
     487    if (m_vm->watchdog.isEnabled())
     488        addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->watchdog.timerDidFireAddress())));
     489
     490    // Emit the JIT optimization check:
     491    if (canBeOptimized())
     492        addSlowCase(branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForLoop()),
     493            AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
     494}
     495
     496void JIT::emitSlow_op_loop_hint(Instruction*, Vector<SlowCaseEntry>::iterator& iter)
     497{
     498    // Emit the slow path of the watchdog timer check:
     499    if (m_vm->watchdog.isEnabled()) {
     500        linkSlowCase(iter);
     501
     502        JITStubCall stubCall(this, cti_handle_watchdog_timer);
     503        stubCall.call();
     504
     505#if ENABLE(DFG_JIT)
     506        if (canBeOptimized()) {
     507            Jump doOptimize = branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForLoop()),
     508                AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter()));
     509            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_loop_hint));
     510            doOptimize.link(this);
     511        } else
     512#endif
     513            emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_loop_hint));
     514    }
     515
     516#if ENABLE(DFG_JIT)
     517    // Emit the slow path for the JIT optimization check:
     518    if (canBeOptimized()) {
     519        linkSlowCase(iter);
     520
     521        JITStubCall stubCall(this, cti_optimize);
     522        stubCall.addArgument(TrustedImm32(m_bytecodeOffset));
     523        stubCall.call();
     524
     525        emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_loop_hint));
     526    }
     527#endif
     528}
     529
    484530void JIT::emit_op_neq(Instruction* currentInstruction)
    485531{
     
    864910void JIT::emit_op_enter(Instruction*)
    865911{
    866     emitOptimizationCheck(EnterOptimizationCheck);
     912    emitEnterOptimizationCheck();
    867913   
    868914    // Even though CTI doesn't use them, we initialize our constant
  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r148696 r148893  
    11141114void JIT::emit_op_enter(Instruction*)
    11151115{
    1116     emitOptimizationCheck(EnterOptimizationCheck);
     1116    emitEnterOptimizationCheck();
    11171117   
    11181118    // Even though JIT code doesn't use them, we initialize our constant
Note: See TracChangeset for help on using the changeset viewer.