Changeset 249372 in webkit


Ignore:
Timestamp:
Sep 1, 2019 8:44:32 PM (5 years ago)
Author:
ysuzuki@apple.com
Message:

[JSC] Merge op_check_traps into op_enter and op_loop_hint
https://bugs.webkit.org/show_bug.cgi?id=201373

Reviewed by Mark Lam.

This patch removes op_check_traps. Previously we were conditionally emitting op_check_traps based on Options and Platform configurations.
But now we are always emitting op_check_traps. So it is not necessary to have separate bytecode as op_check_traps. We can do checking in
op_enter and op_loop_hint.

While this patch moves check_traps implementation to op_enter and op_loop_hint, we keep separate DFG nodes (CheckTraps or InvalidationPoint),
since inserted nodes are different based on configurations and options. And emitting multiple DFG nodes from one bytecode is easy.

We also inline op_enter's slow path's write-barrier emission in LLInt.

  • bytecode/BytecodeList.rb:
  • bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeOffset):
(JSC::computeDefsForBytecodeOffset):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitLoopHint):
(JSC::BytecodeGenerator::emitCheckTraps): Deleted.

  • bytecompiler/BytecodeGenerator.h:
  • dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::handleRecursiveTailCall):
(JSC::DFG::ByteCodeParser::parseBlock):

  • dfg/DFGCapabilities.cpp:

(JSC::DFG::capabilityLevel):

  • jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass):
(JSC::JIT::privateCompileSlowCases):
(JSC::JIT::emitEnterOptimizationCheck): Deleted.

  • jit/JIT.h:
  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_loop_hint):
(JSC::JIT::emitSlow_op_loop_hint):
(JSC::JIT::emit_op_enter):
(JSC::JIT::emitSlow_op_enter):
(JSC::JIT::emit_op_check_traps): Deleted.
(JSC::JIT::emitSlow_op_check_traps): Deleted.

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_enter): Deleted.

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/CommonSlowPaths.cpp:
  • runtime/CommonSlowPaths.h:
Location:
trunk/Source/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r249370 r249372  
     12019-09-01  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Merge op_check_traps into op_enter and op_loop_hint
     4        https://bugs.webkit.org/show_bug.cgi?id=201373
     5
     6        Reviewed by Mark Lam.
     7
     8        This patch removes op_check_traps. Previously we were conditionally emitting op_check_traps based on Options and Platform configurations.
     9        But now we are always emitting op_check_traps. So it is not necessary to have separate bytecode as op_check_traps. We can do checking in
     10        op_enter and op_loop_hint.
     11
     12        While this patch moves check_traps implementation to op_enter and op_loop_hint, we keep separate DFG nodes (CheckTraps or InvalidationPoint),
     13        since inserted nodes are different based on configurations and options. And emitting multiple DFG nodes from one bytecode is easy.
     14
     15        We also inline op_enter's slow path's write-barrier emission in LLInt.
     16
     17        * bytecode/BytecodeList.rb:
     18        * bytecode/BytecodeUseDef.h:
     19        (JSC::computeUsesForBytecodeOffset):
     20        (JSC::computeDefsForBytecodeOffset):
     21        * bytecompiler/BytecodeGenerator.cpp:
     22        (JSC::BytecodeGenerator::BytecodeGenerator):
     23        (JSC::BytecodeGenerator::emitLoopHint):
     24        (JSC::BytecodeGenerator::emitCheckTraps): Deleted.
     25        * bytecompiler/BytecodeGenerator.h:
     26        * dfg/DFGByteCodeParser.cpp:
     27        (JSC::DFG::ByteCodeParser::handleRecursiveTailCall):
     28        (JSC::DFG::ByteCodeParser::parseBlock):
     29        * dfg/DFGCapabilities.cpp:
     30        (JSC::DFG::capabilityLevel):
     31        * jit/JIT.cpp:
     32        (JSC::JIT::privateCompileMainPass):
     33        (JSC::JIT::privateCompileSlowCases):
     34        (JSC::JIT::emitEnterOptimizationCheck): Deleted.
     35        * jit/JIT.h:
     36        * jit/JITOpcodes.cpp:
     37        (JSC::JIT::emit_op_loop_hint):
     38        (JSC::JIT::emitSlow_op_loop_hint):
     39        (JSC::JIT::emit_op_enter):
     40        (JSC::JIT::emitSlow_op_enter):
     41        (JSC::JIT::emit_op_check_traps): Deleted.
     42        (JSC::JIT::emitSlow_op_check_traps): Deleted.
     43        * jit/JITOpcodes32_64.cpp:
     44        (JSC::JIT::emit_op_enter): Deleted.
     45        * llint/LowLevelInterpreter.asm:
     46        * llint/LowLevelInterpreter32_64.asm:
     47        * llint/LowLevelInterpreter64.asm:
     48        * runtime/CommonSlowPaths.cpp:
     49        * runtime/CommonSlowPaths.h:
     50
    1512019-09-01  Yusuke Suzuki  <ysuzuki@apple.com>
    252
  • trunk/Source/JavaScriptCore/bytecode/BytecodeList.rb

    r248426 r249372  
    10931093        argument: VirtualRegister,
    10941094    }
    1095 
    1096 op :check_traps
    10971095
    10981096op :log_shadow_chicken_prologue,
  • trunk/Source/JavaScriptCore/bytecode/BytecodeUseDef.h

    r248426 r249372  
    8787    case op_create_cloned_arguments:
    8888    case op_get_rest_length:
    89     case op_check_traps:
    9089    case op_get_argument:
    9190    case op_nop:
     
    347346    case op_put_to_arguments:
    348347    case op_set_function_name:
    349     case op_check_traps:
    350348    case op_log_shadow_chicken_prologue:
    351349    case op_log_shadow_chicken_tail:
  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r249337 r249372  
    353353    allocateAndEmitScope();
    354354
    355     emitCheckTraps();
    356 
    357355    const FunctionStack& functionStack = programNode->functionStack();
    358356
     
    474472    allocateAndEmitScope();
    475473
    476     emitCheckTraps();
    477    
    478474    if (functionNameIsInScope(functionNode->ident(), functionNode->functionMode())) {
    479475        ASSERT(parseMode != SourceParseMode::GeneratorBodyMode);
     
    883879    allocateAndEmitScope();
    884880
    885     emitCheckTraps();
    886    
    887881    for (FunctionMetadataNode* function : evalNode->functionStack()) {
    888882        m_codeBlock->addFunctionDecl(makeFunction(function));
     
    969963    allocateAndEmitScope();
    970964
    971     emitCheckTraps();
    972    
    973965    m_calleeRegister.setIndex(CallFrameSlot::callee);
    974966
     
    13981390{
    13991391    OpLoopHint::emit(this);
    1400     emitCheckTraps();
    14011392}
    14021393
     
    14041395{
    14051396    OpJmp::emit(this, target.bind(this));
    1406 }
    1407 
    1408 void BytecodeGenerator::emitCheckTraps()
    1409 {
    1410     OpCheckTraps::emit(this);
    14111397}
    14121398
  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

    r249337 r249372  
    848848
    849849        void emitEnter();
    850         void emitCheckTraps();
    851850
    852851        RegisterID* emitHasIndexedProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName);
  • trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

    r249319 r249372  
    14421442            setDirect(stackEntry->remapOperand(virtualRegisterForLocal(i)), undefined, NormalSet);
    14431443
    1444         // We want to emit the SetLocals with an exit origin that points to the place we are jumping to.
    14451444        unsigned oldIndex = m_currentIndex;
    14461445        auto oldStackTop = m_inlineStackTop;
     1446
     1447        // First, we emit check-traps operation pointing to bc#0 as exit.
    14471448        m_inlineStackTop = stackEntry;
     1449        m_currentIndex = 0;
     1450        m_exitOK = true;
     1451        addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
     1452
     1453        // Then, we want to emit the SetLocals with an exit origin that points to the place we are jumping to.
    14481454        m_currentIndex = opcodeLengths[op_enter];
    14491455        m_exitOK = true;
     
    47804786
    47814787        case op_enter: {
     4788            addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    47824789            Node* undefined = addToGraph(JSConstant, OpInfo(m_constantUndefined));
    47834790            // Initialize all locals to undefined.
    47844791            for (int i = 0; i < m_inlineStackTop->m_codeBlock->numVars(); ++i)
    47854792                set(virtualRegisterForLocal(i), undefined, ImmediateNakedSet);
    4786 
    47874793            NEXT_OPCODE(op_enter);
    47884794        }
     
    66416647
    66426648            addToGraph(LoopHint);
     6649            addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    66436650            NEXT_OPCODE(op_loop_hint);
    66446651        }
    66456652       
    6646         case op_check_traps: {
    6647             addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    6648             NEXT_OPCODE(op_check_traps);
    6649         }
    6650 
    66516653        case op_nop: {
    66526654            addToGraph(Check); // We add a nop here so that basic block linking doesn't break.
  • trunk/Source/JavaScriptCore/dfg/DFGCapabilities.cpp

    r248426 r249372  
    206206    case op_jbeloweq:
    207207    case op_loop_hint:
    208     case op_check_traps:
    209208    case op_nop:
    210209    case op_ret:
  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r249175 r249372  
    9191{
    9292}
    93 
    94 #if ENABLE(DFG_JIT)
    95 void JIT::emitEnterOptimizationCheck()
    96 {
    97     if (!canBeOptimized())
    98         return;
    99 
    100     JumpList skipOptimize;
    101    
    102     skipOptimize.append(branchAdd32(Signed, TrustedImm32(Options::executionCounterIncrementForEntry()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
    103     ASSERT(!m_bytecodeOffset);
    104 
    105     copyCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(vm().topEntryFrame);
    106 
    107     callOperation(operationOptimize, m_bytecodeOffset);
    108     skipOptimize.append(branchTestPtr(Zero, returnValueGPR));
    109     farJump(returnValueGPR, GPRInfo::callFrameRegister);
    110     skipOptimize.link(this);
    111 }
    112 #endif
    11393
    11494void JIT::emitNotifyWrite(WatchpointSet* set)
     
    384364        DEFINE_OP(op_jtrue)
    385365        DEFINE_OP(op_loop_hint)
    386         DEFINE_OP(op_check_traps)
    387366        DEFINE_OP(op_nop)
    388367        DEFINE_OP(op_super_sampler_begin)
     
    549528        DEFINE_SLOWCASE_OP(op_jnstricteq)
    550529        DEFINE_SLOWCASE_OP(op_loop_hint)
    551         DEFINE_SLOWCASE_OP(op_check_traps)
     530        DEFINE_SLOWCASE_OP(op_enter)
    552531        DEFINE_SLOWCASE_OP(op_mod)
    553532        DEFINE_SLOWCASE_OP(op_mul)
  • trunk/Source/JavaScriptCore/jit/JIT.h

    r249175 r249372  
    576576        void emit_op_jtrue(const Instruction*);
    577577        void emit_op_loop_hint(const Instruction*);
    578         void emit_op_check_traps(const Instruction*);
    579578        void emit_op_nop(const Instruction*);
    580579        void emit_op_super_sampler_begin(const Instruction*);
     
    674673        void emitSlow_op_jtrue(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    675674        void emitSlow_op_loop_hint(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    676         void emitSlow_op_check_traps(const Instruction*, Vector<SlowCaseEntry>::iterator&);
     675        void emitSlow_op_enter(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    677676        void emitSlow_op_mod(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    678677        void emitSlow_op_mul(const Instruction*, Vector<SlowCaseEntry>::iterator&);
     
    869868        int jumpTarget(const Instruction*, int target);
    870869       
    871 #if ENABLE(DFG_JIT)
    872         void emitEnterOptimizationCheck();
    873 #else
    874         void emitEnterOptimizationCheck() { }
    875 #endif
    876 
    877870#ifndef NDEBUG
    878871        void printBytecodeOperandTypes(int src1, int src2);
  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r249175 r249372  
    876876}
    877877
    878 void JIT::emit_op_enter(const Instruction*)
    879 {
    880     // Even though CTI doesn't use them, we initialize our constant
    881     // registers to zap stale pointers, to avoid unnecessarily prolonging
    882     // object lifetime and increasing GC pressure.
    883     size_t count = m_codeBlock->numVars();
    884     for (size_t j = CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters(); j < count; ++j)
    885         emitInitRegister(virtualRegisterForLocal(j).offset());
    886 
    887     emitWriteBarrier(m_codeBlock);
    888 
    889     emitEnterOptimizationCheck();
    890 }
    891 
    892878void JIT::emit_op_get_scope(const Instruction* currentInstruction)
    893879{
     
    10211007void JIT::emit_op_loop_hint(const Instruction*)
    10221008{
    1023     // Emit the JIT optimization check:
     1009    // Check traps.
     1010    addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->needTrapHandlingAddress())));
     1011#if ENABLE(DFG_JIT)
     1012    // Emit the JIT optimization check:
    10241013    if (canBeOptimized()) {
    10251014        addSlowCase(branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForLoop()),
    10261015            AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
    10271016    }
     1017#endif
    10281018}
    10291019
    10301020void JIT::emitSlow_op_loop_hint(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
    10311021{
     1022    linkSlowCase(iter);
     1023    callOperation(operationHandleTraps);
    10321024#if ENABLE(DFG_JIT)
    10331025    // Emit the slow path for the JIT optimization check:
    10341026    if (canBeOptimized()) {
    1035         linkAllSlowCases(iter);
     1027        emitJumpSlowToHot(branchAdd32(Signed, TrustedImm32(Options::executionCounterIncrementForLoop()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())), currentInstruction->size());
     1028        linkSlowCase(iter);
    10361029
    10371030        copyCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(vm().topEntryFrame);
    10381031
    10391032        callOperation(operationOptimize, m_bytecodeOffset);
    1040         Jump noOptimizedEntry = branchTestPtr(Zero, returnValueGPR);
     1033        emitJumpSlowToHot(branchTestPtr(Zero, returnValueGPR), currentInstruction->size());
    10411034        if (!ASSERT_DISABLED) {
    10421035            Jump ok = branchPtr(MacroAssembler::Above, returnValueGPR, TrustedImmPtr(bitwise_cast<void*>(static_cast<intptr_t>(1000))));
     
    10451038        }
    10461039        farJump(returnValueGPR, GPRInfo::callFrameRegister);
    1047         noOptimizedEntry.link(this);
    1048 
    1049         emitJumpSlowToHot(jump(), currentInstruction->size());
    10501040    }
    10511041#else
    10521042    UNUSED_PARAM(currentInstruction);
    1053     UNUSED_PARAM(iter);
    10541043#endif
    10551044}
    10561045
    1057 void JIT::emit_op_check_traps(const Instruction*)
    1058 {
     1046void JIT::emit_op_nop(const Instruction*)
     1047{
     1048}
     1049
     1050void JIT::emit_op_super_sampler_begin(const Instruction*)
     1051{
     1052    add32(TrustedImm32(1), AbsoluteAddress(bitwise_cast<void*>(&g_superSamplerCount)));
     1053}
     1054
     1055void JIT::emit_op_super_sampler_end(const Instruction*)
     1056{
     1057    sub32(TrustedImm32(1), AbsoluteAddress(bitwise_cast<void*>(&g_superSamplerCount)));
     1058}
     1059
     1060void JIT::emit_op_enter(const Instruction*)
     1061{
     1062    // Even though JIT doesn't use them, we initialize our constant
     1063    // registers to zap stale pointers, to avoid unnecessarily prolonging
     1064    // object lifetime and increasing GC pressure.
     1065    size_t count = m_codeBlock->numVars();
     1066    for (size_t i = CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters(); i < count; ++i)
     1067        emitInitRegister(virtualRegisterForLocal(i).offset());
     1068
     1069    emitWriteBarrier(m_codeBlock);
     1070
     1071    // Check traps.
    10591072    addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->needTrapHandlingAddress())));
    1060 }
    1061 
    1062 void JIT::emit_op_nop(const Instruction*)
    1063 {
    1064 }
    1065 
    1066 void JIT::emit_op_super_sampler_begin(const Instruction*)
    1067 {
    1068     add32(TrustedImm32(1), AbsoluteAddress(bitwise_cast<void*>(&g_superSamplerCount)));
    1069 }
    1070 
    1071 void JIT::emit_op_super_sampler_end(const Instruction*)
    1072 {
    1073     sub32(TrustedImm32(1), AbsoluteAddress(bitwise_cast<void*>(&g_superSamplerCount)));
    1074 }
    1075 
    1076 void JIT::emitSlow_op_check_traps(const Instruction*, Vector<SlowCaseEntry>::iterator& iter)
    1077 {
    1078     linkAllSlowCases(iter);
    1079 
     1073
     1074#if ENABLE(DFG_JIT)
     1075    if (canBeOptimized())
     1076        addSlowCase(branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForEntry()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
     1077#endif
     1078}
     1079
     1080void JIT::emitSlow_op_enter(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
     1081{
     1082    linkSlowCase(iter);
    10801083    callOperation(operationHandleTraps);
     1084#if ENABLE(DFG_JIT)
     1085    if (canBeOptimized()) {
     1086        emitJumpSlowToHot(branchAdd32(Signed, TrustedImm32(Options::executionCounterIncrementForEntry()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())), currentInstruction->size());
     1087        linkSlowCase(iter);
     1088
     1089        ASSERT(!m_bytecodeOffset);
     1090
     1091        copyCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(vm().topEntryFrame);
     1092
     1093        callOperation(operationOptimize, m_bytecodeOffset);
     1094        emitJumpSlowToHot(branchTestPtr(Zero, returnValueGPR), currentInstruction->size());
     1095        farJump(returnValueGPR, GPRInfo::callFrameRegister);
     1096    }
     1097#else
     1098    UNUSED_PARAM(currentInstruction);
     1099#endif
    10811100}
    10821101
  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r249175 r249372  
    10031003}
    10041004
    1005 
    1006 void JIT::emit_op_enter(const Instruction* currentInstruction)
    1007 {
    1008     emitEnterOptimizationCheck();
    1009    
    1010     // Even though JIT code doesn't use them, we initialize our constant
    1011     // registers to zap stale pointers, to avoid unnecessarily prolonging
    1012     // object lifetime and increasing GC pressure.
    1013     for (int i = CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters(); i < m_codeBlock->numVars(); ++i)
    1014         emitStore(virtualRegisterForLocal(i).offset(), jsUndefined());
    1015 
    1016     JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_enter);
    1017     slowPathCall.call();
    1018 }
    1019 
    10201005void JIT::emit_op_get_scope(const Instruction* currentInstruction)
    10211006{
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r249362 r249372  
    16721672
    16731673llintOp(op_loop_hint, OpLoopHint, macro (unused, unused, dispatch)
     1674    # CheckTraps.
     1675    loadp CodeBlock[cfr], t1
     1676    loadp CodeBlock::m_vm[t1], t1
     1677    btbnz VM::m_traps + VMTraps::m_needTrapHandling[t1], .handleTraps
     1678.afterHandlingTraps:
    16741679    checkSwitchToJITForLoop()
    16751680    dispatch()
    1676 end)
    1677 
    1678 
    1679 llintOp(op_check_traps, OpCheckTraps, macro (unused, unused, dispatch)
    1680     loadp CodeBlock[cfr], t1
    1681     loadp CodeBlock::m_vm[t1], t1
    1682     loadb VM::m_traps+VMTraps::m_needTrapHandling[t1], t0
    1683     btpnz t0, .handleTraps
    1684 .afterHandlingTraps:
    1685     dispatch()
    16861681.handleTraps:
    1687     callTrapHandler(.throwHandler)
     1682    callTrapHandler(_llint_throw_from_slow_path_trampoline)
    16881683    jmp .afterHandlingTraps
    1689 .throwHandler:
    1690     jmp _llint_throw_from_slow_path_trampoline
    16911684end)
    16921685
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r248829 r249372  
    547547end
    548548
    549 macro writeBarrierOnOperand(size, get, cellFieldName)
    550     get(cellFieldName, t1)
    551     loadConstantOrVariablePayload(size, t1, CellTag, t2, .writeBarrierDone)
     549macro writeBarrierOnCellWithReload(cell, reloadAfterSlowPath)
    552550    skipIfIsRememberedOrInEden(
    553         t2,
     551        cell,
    554552        macro()
    555553            push cfr, PC
    556554            # We make two extra slots because cCall2 will poke.
    557555            subp 8, sp
    558             move t2, a1 # t2 can be a0 on x86
     556            move cell, a1 # cell can be a0
    559557            move cfr, a0
    560558            cCall2Void(_llint_write_barrier_slow)
    561559            addp 8, sp
    562560            pop PC, cfr
     561            reloadAfterSlowPath()
    563562        end)
     563end
     564
     565macro writeBarrierOnOperand(size, get, cellFieldName)
     566    get(cellFieldName, t1)
     567    loadConstantOrVariablePayload(size, t1, CellTag, t2, .writeBarrierDone)
     568    writeBarrierOnCellWithReload(t2, macro() end)
    564569.writeBarrierDone:
    565570end
     
    581586    loadMacro(t3)
    582587
    583     skipIfIsRememberedOrInEden(
    584         t3,
    585         macro()
    586             push cfr, PC
    587             # We make two extra slots because cCall2 will poke.
    588             subp 8, sp
    589             move cfr, a0
    590             move t3, a1
    591             cCall2Void(_llint_write_barrier_slow)
    592             addp 8, sp
    593             pop PC, cfr
    594         end)
     588    writeBarrierOnCellWithReload(t3, macro() end)
    595589.writeBarrierDone:
    596590end
     
    708702    traceExecution()
    709703    checkStackPointerAlignment(t2, 0xdead00e1)
    710     loadp CodeBlock[cfr], t2                // t2<CodeBlock> = cfr.CodeBlock
    711     loadi CodeBlock::m_numVars[t2], t2      // t2<size_t> = t2<CodeBlock>.m_numVars
     704    loadp CodeBlock[cfr], t1                // t1<CodeBlock> = cfr.CodeBlock
     705    loadi CodeBlock::m_numVars[t1], t2      // t2<size_t> = t1<CodeBlock>.m_numVars
    712706    subi CalleeSaveSpaceAsVirtualRegisters, t2
    713707    move cfr, t3
     
    715709    btiz t2, .opEnterDone
    716710    move UndefinedTag, t0
    717     move 0, t1
    718711    negi t2
    719712.opEnterLoop:
    720713    storei t0, TagOffset[t3, t2, 8]
    721     storei t1, PayloadOffset[t3, t2, 8]
     714    storei 0, PayloadOffset[t3, t2, 8]
    722715    addi 1, t2
    723716    btinz t2, .opEnterLoop
    724717.opEnterDone:
    725     callSlowPath(_slow_path_enter)
     718    writeBarrierOnCellWithReload(t1, macro ()
     719        loadp CodeBlock[cfr], t1 # Reload CodeBlock
     720    end)
     721    # Checking traps.
     722    loadp CodeBlock::m_vm[t1], t1
     723    btpnz VM::m_traps + VMTraps::m_needTrapHandling[t1], .handleTraps
     724.afterHandlingTraps:
    726725    dispatchOp(narrow, op_enter)
    727 
     726.handleTraps:
     727    callTrapHandler(_llint_throw_from_slow_path_trampoline)
     728    jmp .afterHandlingTraps
    728729
    729730llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r249184 r249372  
    511511end
    512512
    513 macro writeBarrierOnOperandWithReload(size, get, cellFieldName, reloadAfterSlowPath)
    514     get(cellFieldName, t1)
    515     loadConstantOrVariableCell(size, t1, t2, .writeBarrierDone)
     513macro writeBarrierOnCellWithReload(cell, reloadAfterSlowPath)
    516514    skipIfIsRememberedOrInEden(
    517         t2,
     515        cell,
    518516        macro()
    519517            push PB, PC
    520             move t2, a1 # t2 can be a0 (not on 64 bits, but better safe than sorry)
     518            move cell, a1 # cell can be a0
    521519            move cfr, a0
    522520            cCall2Void(_llint_write_barrier_slow)
     
    524522            reloadAfterSlowPath()
    525523        end)
     524end
     525
     526macro writeBarrierOnOperandWithReload(size, get, cellFieldName, reloadAfterSlowPath)
     527    get(cellFieldName, t1)
     528    loadConstantOrVariableCell(size, t1, t2, .writeBarrierDone)
     529    writeBarrierOnCellWithReload(t2, reloadAfterSlowPath)
    526530.writeBarrierDone:
    527531end
     
    546550
    547551    loadMacro(t3)
    548     skipIfIsRememberedOrInEden(
    549         t3,
    550         macro()
    551             push PB, PC
    552             move cfr, a0
    553             move t3, a1
    554             cCall2Void(_llint_write_barrier_slow)
    555             pop PC, PB
    556         end)
     552    writeBarrierOnCellWithReload(t3, macro() end)
    557553.writeBarrierDone:
    558554end
     
    687683    traceExecution()
    688684    checkStackPointerAlignment(t2, 0xdead00e1)
    689     loadp CodeBlock[cfr], t2                // t2<CodeBlock> = cfr.CodeBlock
    690     loadi CodeBlock::m_numVars[t2], t2      // t2<size_t> = t2<CodeBlock>.m_numVars
     685    loadp CodeBlock[cfr], t3                // t3<CodeBlock> = cfr.CodeBlock
     686    loadi CodeBlock::m_numVars[t3], t2      // t2<size_t> = t3<CodeBlock>.m_numVars
    691687    subq CalleeSaveSpaceAsVirtualRegisters, t2
    692688    move cfr, t1
     
    701697    btqnz t2, .opEnterLoop
    702698.opEnterDone:
    703     callSlowPath(_slow_path_enter)
     699    writeBarrierOnCellWithReload(t3, macro ()
     700        loadp CodeBlock[cfr], t3 # Reload CodeBlock
     701    end)
     702    loadp CodeBlock::m_vm[t3], t1
     703    btbnz VM::m_traps + VMTraps::m_needTrapHandling[t1], .handleTraps
     704.afterHandlingTraps:
    704705    dispatchOp(narrow, op_enter)
    705 
     706.handleTraps:
     707    callTrapHandler(_llint_throw_from_slow_path_trampoline)
     708    jmp .afterHandlingTraps
    706709
    707710llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)
  • trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp

    r249175 r249372  
    889889}
    890890
    891 SLOW_PATH_DECL(slow_path_enter)
    892 {
    893     BEGIN();
    894     CodeBlock* codeBlock = exec->codeBlock();
    895     Heap::heap(codeBlock)->writeBarrier(codeBlock);
    896     END();
    897 }
    898 
    899891SLOW_PATH_DECL(slow_path_get_enumerable_length)
    900892{
  • trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.h

    r240254 r249372  
    324324SLOW_PATH_HIDDEN_DECL(slow_path_create_cloned_arguments);
    325325SLOW_PATH_HIDDEN_DECL(slow_path_create_this);
    326 SLOW_PATH_HIDDEN_DECL(slow_path_enter);
    327326SLOW_PATH_HIDDEN_DECL(slow_path_get_callee);
    328327SLOW_PATH_HIDDEN_DECL(slow_path_to_this);
Note: See TracChangeset for help on using the changeset viewer.