Changeset 249523 in webkit


Ignore:
Timestamp:
Sep 4, 2019 10:51:56 PM (5 years ago)
Author:
ysuzuki@apple.com
Message:

Unreviewed, partial roll out r249372 due to JetStream2/Basic ~10% regression
​https://bugs.webkit.org/show_bug.cgi?id=201373

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

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

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitLoopHint):
(JSC::BytecodeGenerator::emitCheckTraps):

  • 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::emitEnterOptimizationCheck):
(JSC::JIT::privateCompileMainPass):
(JSC::JIT::privateCompileSlowCases):

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

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

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_enter):

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL):

  • runtime/CommonSlowPaths.h:
Location:
trunk/Source/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r249520 r249523  
     12019-09-04  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        Unreviewed, partial roll out r249372 due to JetStream2/Basic ~10% regression
     4        https://bugs.webkit.org/show_bug.cgi?id=201373
     5
     6        * bytecode/BytecodeList.rb:
     7        * bytecode/BytecodeUseDef.h:
     8        (JSC::computeUsesForBytecodeOffset):
     9        (JSC::computeDefsForBytecodeOffset):
     10        * bytecompiler/BytecodeGenerator.cpp:
     11        (JSC::BytecodeGenerator::BytecodeGenerator):
     12        (JSC::BytecodeGenerator::emitLoopHint):
     13        (JSC::BytecodeGenerator::emitCheckTraps):
     14        * bytecompiler/BytecodeGenerator.h:
     15        * dfg/DFGByteCodeParser.cpp:
     16        (JSC::DFG::ByteCodeParser::handleRecursiveTailCall):
     17        (JSC::DFG::ByteCodeParser::parseBlock):
     18        * dfg/DFGCapabilities.cpp:
     19        (JSC::DFG::capabilityLevel):
     20        * jit/JIT.cpp:
     21        (JSC::JIT::emitEnterOptimizationCheck):
     22        (JSC::JIT::privateCompileMainPass):
     23        (JSC::JIT::privateCompileSlowCases):
     24        * jit/JIT.h:
     25        * jit/JITOpcodes.cpp:
     26        (JSC::JIT::emit_op_enter):
     27        (JSC::JIT::emit_op_loop_hint):
     28        (JSC::JIT::emitSlow_op_loop_hint):
     29        (JSC::JIT::emit_op_check_traps):
     30        (JSC::JIT::emitSlow_op_check_traps):
     31        (JSC::JIT::emitSlow_op_enter): Deleted.
     32        * jit/JITOpcodes32_64.cpp:
     33        (JSC::JIT::emit_op_enter):
     34        * llint/LowLevelInterpreter.asm:
     35        * llint/LowLevelInterpreter32_64.asm:
     36        * llint/LowLevelInterpreter64.asm:
     37        * runtime/CommonSlowPaths.cpp:
     38        (JSC::SLOW_PATH_DECL):
     39        * runtime/CommonSlowPaths.h:
     40
    1412019-09-04  Yusuke Suzuki  <ysuzuki@apple.com>
    242

  • trunk/Source/JavaScriptCore/bytecode/BytecodeList.rb

    r249509 r249523  
    11091109        argument: VirtualRegister,
    11101110    }
     1111
     1112op :check_traps
    11111113
    11121114op :log_shadow_chicken_prologue,

  • trunk/Source/JavaScriptCore/bytecode/BytecodeUseDef.h

    r249509 r249523  
    8888    case op_create_cloned_arguments:
    8989    case op_get_rest_length:
     90    case op_check_traps:
    9091    case op_get_argument:
    9192    case op_nop:
    … …  
    352353    case op_put_to_arguments:
    353354    case op_set_function_name:
     355    case op_check_traps:
    354356    case op_log_shadow_chicken_prologue:
    355357    case op_log_shadow_chicken_tail:

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r249509 r249523  
    362362    allocateAndEmitScope();
    363363
     364    emitCheckTraps();
     365
    364366    const FunctionStack& functionStack = programNode->functionStack();
    365367
    … …  
    483485    allocateAndEmitScope();
    484486
     487    emitCheckTraps();
     488   
    485489    if (functionNameIsInScope(functionNode->ident(), functionNode->functionMode())) {
    486490        ASSERT(parseMode != SourceParseMode::GeneratorBodyMode);
    … …  
    894898    allocateAndEmitScope();
    895899
     900    emitCheckTraps();
     901   
    896902    for (FunctionMetadataNode* function : evalNode->functionStack()) {
    897903        m_codeBlock->addFunctionDecl(makeFunction(function));
    … …  
    978984    allocateAndEmitScope();
    979985
     986    emitCheckTraps();
     987   
    980988    m_calleeRegister.setIndex(CallFrameSlot::callee);
    981989
    … …  
    14051413{
    14061414    OpLoopHint::emit(this);
     1415    emitCheckTraps();
    14071416}
    14081417
    … …  
    14101419{
    14111420    OpJmp::emit(this, target.bind(this));
     1421}
     1422
     1423void BytecodeGenerator::emitCheckTraps()
     1424{
     1425    OpCheckTraps::emit(this);
    14121426}
    14131427

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

    r249509 r249523  
    853853
    854854        void emitEnter();
     855        void emitCheckTraps();
    855856
    856857        RegisterID* emitHasIndexedProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName);

  • trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

    r249509 r249523  
    14451445            setDirect(stackEntry->remapOperand(virtualRegisterForLocal(i)), undefined, NormalSet);
    14461446
     1447        // We want to emit the SetLocals with an exit origin that points to the place we are jumping to.
    14471448        unsigned oldIndex = m_currentIndex;
    14481449        auto oldStackTop = m_inlineStackTop;
    1449 
    1450         // First, we emit check-traps operation pointing to bc#0 as exit.
    14511450        m_inlineStackTop = stackEntry;
    1452         m_currentIndex = 0;
    1453         m_exitOK = true;
    1454         addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    1455 
    1456         // Then, we want to emit the SetLocals with an exit origin that points to the place we are jumping to.
    14571451        m_currentIndex = opcodeLengths[op_enter];
    14581452        m_exitOK = true;
    … …  
    47894783
    47904784        case op_enter: {
    4791             addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    47924785            Node* undefined = addToGraph(JSConstant, OpInfo(m_constantUndefined));
    47934786            // Initialize all locals to undefined.
    47944787            for (int i = 0; i < m_inlineStackTop->m_codeBlock->numVars(); ++i)
    47954788                set(virtualRegisterForLocal(i), undefined, ImmediateNakedSet);
     4789
    47964790            NEXT_OPCODE(op_enter);
    47974791        }
    … …  
    67286722
    67296723            addToGraph(LoopHint);
     6724            NEXT_OPCODE(op_loop_hint);
     6725        }
     6726       
     6727        case op_check_traps: {
    67306728            addToGraph(Options::usePollingTraps() ? CheckTraps : InvalidationPoint);
    6731             NEXT_OPCODE(op_loop_hint);
    6732         }
    6733        
     6729            NEXT_OPCODE(op_check_traps);
     6730        }
     6731
    67346732        case op_nop: {
    67356733            addToGraph(Check); // We add a nop here so that basic block linking doesn't break.

  • trunk/Source/JavaScriptCore/dfg/DFGCapabilities.cpp

    r249509 r249523  
    207207    case op_jbeloweq:
    208208    case op_loop_hint:
     209    case op_check_traps:
    209210    case op_nop:
    210211    case op_ret:

  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r249509 r249523  
    9191{
    9292}
     93
     94#if ENABLE(DFG_JIT)
     95void 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
    93113
    94114void JIT::emitNotifyWrite(WatchpointSet* set)
    … …  
    366386        DEFINE_OP(op_jtrue)
    367387        DEFINE_OP(op_loop_hint)
     388        DEFINE_OP(op_check_traps)
    368389        DEFINE_OP(op_nop)
    369390        DEFINE_OP(op_super_sampler_begin)
    … …  
    533554        DEFINE_SLOWCASE_OP(op_jnstricteq)
    534555        DEFINE_SLOWCASE_OP(op_loop_hint)
    535         DEFINE_SLOWCASE_OP(op_enter)
     556        DEFINE_SLOWCASE_OP(op_check_traps)
    536557        DEFINE_SLOWCASE_OP(op_mod)
    537558        DEFINE_SLOWCASE_OP(op_mul)

  • trunk/Source/JavaScriptCore/jit/JIT.h

    r249509 r249523  
    576576        void emit_op_jtrue(const Instruction*);
    577577        void emit_op_loop_hint(const Instruction*);
     578        void emit_op_check_traps(const Instruction*);
    578579        void emit_op_nop(const Instruction*);
    579580        void emit_op_super_sampler_begin(const Instruction*);
    … …  
    675676        void emitSlow_op_jtrue(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    676677        void emitSlow_op_loop_hint(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    677         void emitSlow_op_enter(const Instruction*, Vector<SlowCaseEntry>::iterator&);
     678        void emitSlow_op_check_traps(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    678679        void emitSlow_op_mod(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    679680        void emitSlow_op_mul(const Instruction*, Vector<SlowCaseEntry>::iterator&);
    … …  
    870871        int jumpTarget(const Instruction*, int target);
    871872       
     873#if ENABLE(DFG_JIT)
     874        void emitEnterOptimizationCheck();
     875#else
     876        void emitEnterOptimizationCheck() { }
     877#endif
     878
    872879#ifndef NDEBUG
    873880        void printBytecodeOperandTypes(int src1, int src2);

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r249372 r249523  
    876876}
    877877
     878void 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
    878892void JIT::emit_op_get_scope(const Instruction* currentInstruction)
    879893{
    … …  
    10071021void JIT::emit_op_loop_hint(const Instruction*)
    10081022{
    1009     // Check traps.
    1010     addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->needTrapHandlingAddress())));
    1011 #if ENABLE(DFG_JIT)
    1012     // Emit the JIT optimization check:
     1023    // Emit the JIT optimization check:
    10131024    if (canBeOptimized()) {
    10141025        addSlowCase(branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForLoop()),
    10151026            AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
    10161027    }
    1017 #endif
    10181028}
    10191029
    10201030void JIT::emitSlow_op_loop_hint(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
    10211031{
    1022     linkSlowCase(iter);
    1023     callOperation(operationHandleTraps);
    10241032#if ENABLE(DFG_JIT)
    10251033    // Emit the slow path for the JIT optimization check:
    10261034    if (canBeOptimized()) {
    1027         emitJumpSlowToHot(branchAdd32(Signed, TrustedImm32(Options::executionCounterIncrementForLoop()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())), currentInstruction->size());
    1028         linkSlowCase(iter);
     1035        linkAllSlowCases(iter);
    10291036
    10301037        copyCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(vm().topEntryFrame);
    10311038
    10321039        callOperation(operationOptimize, m_bytecodeOffset);
    1033         emitJumpSlowToHot(branchTestPtr(Zero, returnValueGPR), currentInstruction->size());
     1040        Jump noOptimizedEntry = branchTestPtr(Zero, returnValueGPR);
    10341041        if (!ASSERT_DISABLED) {
    10351042            Jump ok = branchPtr(MacroAssembler::Above, returnValueGPR, TrustedImmPtr(bitwise_cast<void*>(static_cast<intptr_t>(1000))));
    … …  
    10381045        }
    10391046        farJump(returnValueGPR, GPRInfo::callFrameRegister);
     1047        noOptimizedEntry.link(this);
     1048
     1049        emitJumpSlowToHot(jump(), currentInstruction->size());
    10401050    }
    10411051#else
    10421052    UNUSED_PARAM(currentInstruction);
     1053    UNUSED_PARAM(iter);
    10431054#endif
    10441055}
    10451056
     1057void JIT::emit_op_check_traps(const Instruction*)
     1058{
     1059    addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->needTrapHandlingAddress())));
     1060}
     1061
    10461062void JIT::emit_op_nop(const Instruction*)
    10471063{
    … …  
    10581074}
    10591075
    1060 void 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.
    1072     addSlowCase(branchTest8(NonZero, AbsoluteAddress(m_vm->needTrapHandlingAddress())));
    1073 
    1074 #if ENABLE(DFG_JIT)
    1075     if (canBeOptimized())
    1076         addSlowCase(branchAdd32(PositiveOrZero, TrustedImm32(Options::executionCounterIncrementForEntry()), AbsoluteAddress(m_codeBlock->addressOfJITExecuteCounter())));
    1077 #endif
    1078 }
    1079 
    1080 void JIT::emitSlow_op_enter(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
    1081 {
    1082     linkSlowCase(iter);
     1076void JIT::emitSlow_op_check_traps(const Instruction*, Vector<SlowCaseEntry>::iterator& iter)
     1077{
     1078    linkAllSlowCases(iter);
     1079
    10831080    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
    11001081}
    11011082

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r249372 r249523  
    10031003}
    10041004
     1005
     1006void 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
    10051020void JIT::emit_op_get_scope(const Instruction* currentInstruction)
    10061021{

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r249509 r249523  
    16741674
    16751675llintOp(op_loop_hint, OpLoopHint, macro (unused, unused, dispatch)
    1676     # CheckTraps.
     1676    checkSwitchToJITForLoop()
     1677    dispatch()
     1678end)
     1679
     1680
     1681llintOp(op_check_traps, OpCheckTraps, macro (unused, unused, dispatch)
    16771682    loadp CodeBlock[cfr], t1
    16781683    loadp CodeBlock::m_vm[t1], t1
    1679     btbnz VM::m_traps + VMTraps::m_needTrapHandling[t1], .handleTraps
     1684    loadb VM::m_traps+VMTraps::m_needTrapHandling[t1], t0
     1685    btpnz t0, .handleTraps
    16801686.afterHandlingTraps:
    1681     checkSwitchToJITForLoop()
    16821687    dispatch()
    16831688.handleTraps:
    1684     callTrapHandler(_llint_throw_from_slow_path_trampoline)
     1689    callTrapHandler(.throwHandler)
    16851690    jmp .afterHandlingTraps
     1691.throwHandler:
     1692    jmp _llint_throw_from_slow_path_trampoline
    16861693end)
    16871694

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r249509 r249523  
    702702    traceExecution()
    703703    checkStackPointerAlignment(t2, 0xdead00e1)
    704     loadp CodeBlock[cfr], t1                // t1<CodeBlock> = cfr.CodeBlock
    705     loadi CodeBlock::m_numVars[t1], t2      // t2<size_t> = t1<CodeBlock>.m_numVars
     704    loadp CodeBlock[cfr], t2                // t2<CodeBlock> = cfr.CodeBlock
     705    loadi CodeBlock::m_numVars[t2], t2      // t2<size_t> = t2<CodeBlock>.m_numVars
    706706    subi CalleeSaveSpaceAsVirtualRegisters, t2
    707707    move cfr, t3
    … …  
    709709    btiz t2, .opEnterDone
    710710    move UndefinedTag, t0
     711    move 0, t1
    711712    negi t2
    712713.opEnterLoop:
    713714    storei t0, TagOffset[t3, t2, 8]
    714     storei 0, PayloadOffset[t3, t2, 8]
     715    storei t1, PayloadOffset[t3, t2, 8]
    715716    addi 1, t2
    716717    btinz t2, .opEnterLoop
    717718.opEnterDone:
    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:
     719    callSlowPath(_slow_path_enter)
    725720    dispatchOp(narrow, op_enter)
    726 .handleTraps:
    727     callTrapHandler(_llint_throw_from_slow_path_trampoline)
    728     jmp .afterHandlingTraps
     721
    729722
    730723llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r249509 r249523  
    690690    traceExecution()
    691691    checkStackPointerAlignment(t2, 0xdead00e1)
    692     loadp CodeBlock[cfr], t3                // t3<CodeBlock> = cfr.CodeBlock
    693     loadi CodeBlock::m_numVars[t3], t2      // t2<size_t> = t3<CodeBlock>.m_numVars
     692    loadp CodeBlock[cfr], t2                // t2<CodeBlock> = cfr.CodeBlock
     693    loadi CodeBlock::m_numVars[t2], t2      // t2<size_t> = t2<CodeBlock>.m_numVars
    694694    subq CalleeSaveSpaceAsVirtualRegisters, t2
    695695    move cfr, t1
    … …  
    704704    btqnz t2, .opEnterLoop
    705705.opEnterDone:
    706     writeBarrierOnCellWithReload(t3, macro ()
    707         loadp CodeBlock[cfr], t3 # Reload CodeBlock
    708     end)
    709     loadp CodeBlock::m_vm[t3], t1
    710     btbnz VM::m_traps + VMTraps::m_needTrapHandling[t1], .handleTraps
    711 .afterHandlingTraps:
     706    callSlowPath(_slow_path_enter)
    712707    dispatchOp(narrow, op_enter)
    713 .handleTraps:
    714     callTrapHandler(_llint_throw_from_slow_path_trampoline)
    715     jmp .afterHandlingTraps
     708
    716709
    717710llintOpWithProfile(op_get_argument, OpGetArgument, macro (size, get, dispatch, return)

  • trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp

    r249509 r249523  
    933933}
    934934
     935SLOW_PATH_DECL(slow_path_enter)
     936{
     937    BEGIN();
     938    CodeBlock* codeBlock = exec->codeBlock();
     939    Heap::heap(codeBlock)->writeBarrier(codeBlock);
     940    END();
     941}
     942
    935943SLOW_PATH_DECL(slow_path_get_enumerable_length)
    936944{

  • trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.h

    r249509 r249523  
    324324SLOW_PATH_HIDDEN_DECL(slow_path_create_cloned_arguments);
    325325SLOW_PATH_HIDDEN_DECL(slow_path_create_this);
     326SLOW_PATH_HIDDEN_DECL(slow_path_enter);
    326327SLOW_PATH_HIDDEN_DECL(slow_path_get_callee);
    327328SLOW_PATH_HIDDEN_DECL(slow_path_to_this);
Note: See TracChangeset for help on using the changeset viewer.