Ignore:
Timestamp:
Mar 28, 2017, 11:15:23 PM (8 years ago)
Author:
[email protected]
Message:

AssemblyHelpers should not have a VM field
​https://bugs.webkit.org/show_bug.cgi?id=170207

Reviewed by Yusuke Suzuki.

APIs that need VM should take one as a parameter. When doing position
independent code for Wasm, we can't tie code generation to a VM.

  • b3/B3Compile.cpp:

(JSC::B3::compile):

  • b3/air/testair.cpp:
  • b3/testb3.cpp:

(JSC::B3::testEntrySwitchSimple):
(JSC::B3::testEntrySwitchNoEntrySwitch):
(JSC::B3::testEntrySwitchWithCommonPaths):
(JSC::B3::testEntrySwitchWithCommonPathsAndNonTrivialEntrypoint):
(JSC::B3::testEntrySwitchLoop):

  • bytecode/AccessCase.cpp:

(JSC::AccessCase::generateWithGuard):
(JSC::AccessCase::generateImpl):

  • bytecode/DOMJITAccessCasePatchpointParams.cpp:

(JSC::SlowPathCallGeneratorWithArguments::generateImpl):

  • bytecode/InlineAccess.cpp:

(JSC::InlineAccess::dumpCacheSizesAndCrash):
(JSC::InlineAccess::generateSelfPropertyAccess):
(JSC::InlineAccess::generateSelfPropertyReplace):
(JSC::InlineAccess::generateArrayLength):
(JSC::InlineAccess::rewireStubAsJump):

  • bytecode/InlineAccess.h:
  • bytecode/PolymorphicAccess.cpp:

(JSC::AccessGenerationState::emitExplicitExceptionHandler):
(JSC::PolymorphicAccess::regenerate):

  • bytecode/PolymorphicAccess.h:

(JSC::AccessGenerationState::AccessGenerationState):

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::JITCompiler):
(JSC::DFG::JITCompiler::compileExceptionHandlers):
(JSC::DFG::JITCompiler::link):
(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):
(JSC::DFG::JITCompiler::exceptionCheck):

  • dfg/DFGJITCompiler.h:

(JSC::DFG::JITCompiler::exceptionCheckWithCallFrameRollback):
(JSC::DFG::JITCompiler::fastExceptionCheck):
(JSC::DFG::JITCompiler::vm):

  • dfg/DFGOSRExitCompiler.cpp:
  • dfg/DFGOSRExitCompiler.h:
  • dfg/DFGOSRExitCompiler32_64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

  • dfg/DFGOSRExitCompiler64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

  • dfg/DFGOSRExitCompilerCommon.cpp:

(JSC::DFG::adjustAndJumpToTarget):

  • dfg/DFGOSRExitCompilerCommon.h:
  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::emitAllocateRawObject):
(JSC::DFG::SpeculativeJIT::checkArray):
(JSC::DFG::SpeculativeJIT::compileCurrentBlock):
(JSC::DFG::SpeculativeJIT::compileInstanceOfForObject):
(JSC::DFG::SpeculativeJIT::compileMakeRope):
(JSC::DFG::SpeculativeJIT::compileGetGlobalObject):
(JSC::DFG::SpeculativeJIT::compileNewFunctionCommon):
(JSC::DFG::SpeculativeJIT::compileCreateActivation):
(JSC::DFG::SpeculativeJIT::compileCreateDirectArguments):
(JSC::DFG::SpeculativeJIT::compileSpread):
(JSC::DFG::SpeculativeJIT::compileArraySlice):
(JSC::DFG::SpeculativeJIT::compileNukeStructureAndSetButterfly):
(JSC::DFG::SpeculativeJIT::compileNewStringObject):
(JSC::DFG::SpeculativeJIT::compileNewTypedArray):
(JSC::DFG::SpeculativeJIT::compileStoreBarrier):

  • dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::emitAllocateJSObjectWithKnownSize):
(JSC::DFG::SpeculativeJIT::emitAllocateJSObject):
(JSC::DFG::SpeculativeJIT::emitAllocateVariableSizedJSObject):
(JSC::DFG::SpeculativeJIT::emitAllocateDestructibleObject):

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::nonSpeculativeNonPeepholeCompareNullOrUndefined):
(JSC::DFG::SpeculativeJIT::nonSpeculativePeepholeBranchNullOrUndefined):
(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):
(JSC::DFG::SpeculativeJIT::compileAllocateNewArrayWithSize):

  • dfg/DFGThunks.cpp:

(JSC::DFG::osrEntryThunkGenerator):

  • ftl/FTLCompile.cpp:

(JSC::FTL::compile):

  • ftl/FTLJITFinalizer.h:
  • ftl/FTLLazySlowPath.cpp:

(JSC::FTL::LazySlowPath::generate):

  • ftl/FTLLazySlowPathCall.h:

(JSC::FTL::createLazyCallGenerator):

  • ftl/FTLLink.cpp:

(JSC::FTL::link):

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::lower):
(JSC::FTL::DFG::LowerDFGToB3::compileCreateActivation):
(JSC::FTL::DFG::LowerDFGToB3::compileNewFunction):
(JSC::FTL::DFG::LowerDFGToB3::compileCreateDirectArguments):
(JSC::FTL::DFG::LowerDFGToB3::compileNewTypedArray):
(JSC::FTL::DFG::LowerDFGToB3::compileMakeRope):
(JSC::FTL::DFG::LowerDFGToB3::compileNotifyWrite):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargsSpread):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargs):
(JSC::FTL::DFG::LowerDFGToB3::compileCallEval):
(JSC::FTL::DFG::LowerDFGToB3::compileIsObjectOrNull):
(JSC::FTL::DFG::LowerDFGToB3::compileIsFunction):
(JSC::FTL::DFG::LowerDFGToB3::compileMaterializeNewObject):
(JSC::FTL::DFG::LowerDFGToB3::compileMaterializeCreateActivation):
(JSC::FTL::DFG::LowerDFGToB3::compileCheckTraps):
(JSC::FTL::DFG::LowerDFGToB3::allocatePropertyStorageWithSizeImpl):
(JSC::FTL::DFG::LowerDFGToB3::allocateObject):
(JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
(JSC::FTL::DFG::LowerDFGToB3::buildTypeOf):

  • ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileStub):

  • ftl/FTLSlowPathCall.h:

(JSC::FTL::callOperation):

  • ftl/FTLState.h:

(JSC::FTL::State::vm):

  • ftl/FTLThunks.cpp:

(JSC::FTL::genericGenerationThunkGenerator):
(JSC::FTL::slowPathCallThunkGenerator):

  • jit/AssemblyHelpers.cpp:

(JSC::AssemblyHelpers::jitReleaseAssertNoException):
(JSC::AssemblyHelpers::callExceptionFuzz):
(JSC::AssemblyHelpers::emitJumpIfException):
(JSC::AssemblyHelpers::emitExceptionCheck):
(JSC::AssemblyHelpers::emitNonPatchableExceptionCheck):
(JSC::AssemblyHelpers::emitLoadStructure):
(JSC::AssemblyHelpers::emitRandomThunk):
(JSC::AssemblyHelpers::restoreCalleeSavesFromVMEntryFrameCalleeSavesBuffer):
(JSC::AssemblyHelpers::emitConvertValueToBoolean):
(JSC::AssemblyHelpers::debugCall):

  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::AssemblyHelpers):
(JSC::AssemblyHelpers::codeBlock):
(JSC::AssemblyHelpers::copyCalleeSavesToVMEntryFrameCalleeSavesBuffer):
(JSC::AssemblyHelpers::copyCalleeSavesFromFrameOrRegisterToVMEntryFrameCalleeSavesBuffer):
(JSC::AssemblyHelpers::barrierBranch):
(JSC::AssemblyHelpers::barrierStoreLoadFence):
(JSC::AssemblyHelpers::mutatorFence):
(JSC::AssemblyHelpers::storeButterfly):
(JSC::AssemblyHelpers::nukeStructureAndStoreButterfly):
(JSC::AssemblyHelpers::jumpIfMutatorFenceNotNeeded):
(JSC::AssemblyHelpers::emitAllocateJSObjectWithKnownSize):
(JSC::AssemblyHelpers::emitAllocateJSObject):
(JSC::AssemblyHelpers::emitAllocateVariableSizedCell):
(JSC::AssemblyHelpers::emitAllocateVariableSizedJSObject):
(JSC::AssemblyHelpers::emitAllocateDestructibleObject):
(JSC::AssemblyHelpers::vm): Deleted.
(JSC::AssemblyHelpers::debugCall): Deleted.

  • jit/CCallHelpers.cpp:

(JSC::CCallHelpers::ensureShadowChickenPacket):

  • jit/CCallHelpers.h:

(JSC::CCallHelpers::CCallHelpers):
(JSC::CCallHelpers::jumpToExceptionHandler):

  • jit/JIT.cpp:

(JSC::JIT::emitEnterOptimizationCheck):
(JSC::JIT::privateCompileExceptionHandlers):

  • jit/JIT.h:

(JSC::JIT::exceptionCheck):
(JSC::JIT::exceptionCheckWithCallFrameRollback):

  • jit/JITMathIC.h:

(JSC::JITMathIC::generateOutOfLine):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_instanceof):
(JSC::JIT::emit_op_is_undefined):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jeq_null):
(JSC::JIT::emit_op_jneq_null):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_throw):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emitSlow_op_loop_hint):
(JSC::JIT::emit_op_log_shadow_chicken_prologue):
(JSC::JIT::emit_op_log_shadow_chicken_tail):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_new_object):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_throw):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_create_this):
(JSC::JIT::emit_op_log_shadow_chicken_prologue):
(JSC::JIT::emit_op_log_shadow_chicken_tail):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emitWriteBarrier):

  • jit/JSInterfaceJIT.h:

(JSC::JSInterfaceJIT::JSInterfaceJIT):
(JSC::JSInterfaceJIT::vm):

  • jit/Repatch.cpp:

(JSC::tryCacheGetByID):
(JSC::tryCachePutByID):
(JSC::linkPolymorphicCall):
(JSC::resetGetByID):
(JSC::resetPutByID):

  • jit/SetupVarargsFrame.cpp:

(JSC::emitSetupVarargsFrameFastCase):

  • jit/SetupVarargsFrame.h:
  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::loadArgumentWithSpecificClass):

  • jit/ThunkGenerators.cpp:

(JSC::throwExceptionFromCallSlowPathGenerator):
(JSC::linkCallThunkGenerator):
(JSC::linkPolymorphicCallThunkGenerator):
(JSC::virtualThunkFor):
(JSC::nativeForGenerator):
(JSC::randomThunkGenerator):
(JSC::boundThisNoArgsFunctionCallGenerator):
(JSC::throwExceptionFromWasmThunkGenerator):

  • wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::parseAndCompile):

  • wasm/WasmBinding.cpp:

(JSC::Wasm::wasmToJs):
(JSC::Wasm::wasmToWasm):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r214296 r214531  
    201201        m_out.storePtr(m_out.constIntPtr(bitwise_cast<intptr_t>(codeBlock())), addressFor(CallFrameSlot::codeBlock));
    202202
     203        VM* vm = &this->vm();
     204
    203205        // Stack Overflow Check.
    204206        unsigned exitFrameSize = m_graph.requiredRegisterCountForExit() * sizeof(Register);
    205         MacroAssembler::AbsoluteAddress addressOfStackLimit(vm().addressOfSoftStackLimit());
     207        MacroAssembler::AbsoluteAddress addressOfStackLimit(vm->addressOfSoftStackLimit());
    206208        PatchpointValue* stackOverflowHandler = m_out.patchpoint(Void);
    207209        CallSiteIndex callSiteIndex = callSiteIndexForCodeOrigin(m_ftlState, CodeOrigin(0));
    … …  
    227229                        MacroAssembler::TrustedImm32(callSiteIndex.bits()),
    228230                        CCallHelpers::tagFor(VirtualRegister(CallFrameSlot::argumentCount)));
    229                     jit.copyCalleeSavesToVMEntryFrameCalleeSavesBuffer();
     231                    jit.copyCalleeSavesToVMEntryFrameCalleeSavesBuffer(*vm);
    230232
    231233                    jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    … …  
    233235                    CCallHelpers::Call throwCall = jit.call();
    234236
    235                     jit.move(CCallHelpers::TrustedImmPtr(jit.vm()), GPRInfo::argumentGPR0);
     237                    jit.move(CCallHelpers::TrustedImmPtr(vm), GPRInfo::argumentGPR0);
    236238                    jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR1);
    237239                    CCallHelpers::Call lookupExceptionHandlerCall = jit.call();
    238                     jit.jumpToExceptionHandler();
     240                    jit.jumpToExceptionHandler(*vm);
    239241
    240242                    jit.addLinkTask(
    … …  
    40734075       
    40744076        m_out.appendTo(slowPath, continuation);
     4077        VM& vm = this->vm();
    40754078        LValue callResult = lazySlowPath(
    4076             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    4077                 return createLazyCallGenerator(
     4079            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     4080                return createLazyCallGenerator(vm,
    40784081                    operationCreateActivationDirect, locations[0].directGPR(),
    40794082                    CCallHelpers::TrustedImmPtr(structure.get()), locations[1].directGPR(),
    … …  
    41374140        Vector<LValue> slowPathArguments;
    41384141        slowPathArguments.append(scope);
     4142        VM& vm = this->vm();
    41394143        LValue callResult = lazySlowPath(
    4140             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     4144            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    41414145                if (isGeneratorFunction) {
    4142                     return createLazyCallGenerator(
     4146                    return createLazyCallGenerator(vm,
    41434147                        operationNewGeneratorFunctionWithInvalidatedReallocationWatchpoint,
    41444148                        locations[0].directGPR(), locations[1].directGPR(),
    … …  
    41464150                }
    41474151                if (isAsyncFunction) {
    4148                     return createLazyCallGenerator(
     4152                    return createLazyCallGenerator(vm,
    41494153                        operationNewAsyncFunctionWithInvalidatedReallocationWatchpoint,
    41504154                        locations[0].directGPR(), locations[1].directGPR(),
    41514155                        CCallHelpers::TrustedImmPtr(executable));
    41524156                }
    4153                 return createLazyCallGenerator(
     4157                return createLazyCallGenerator(vm,
    41544158                    operationNewFunctionWithInvalidatedReallocationWatchpoint,
    41554159                    locations[0].directGPR(), locations[1].directGPR(),
    … …  
    42094213       
    42104214        m_out.appendTo(slowPath, continuation);
     4215        VM& vm = this->vm();
    42114216        LValue callResult = lazySlowPath(
    4212             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    4213                 return createLazyCallGenerator(
     4217            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     4218                return createLazyCallGenerator(vm,
    42144219                    operationCreateDirectArguments, locations[0].directGPR(),
    42154220                    CCallHelpers::TrustedImmPtr(structure.get()), locations[1].directGPR(),
    … …  
    48214826            LValue storageValue = m_out.phi(pointerType(), noStorage, haveStorage);
    48224827
     4828            VM& vm = this->vm();
    48234829            LValue slowResultValue = lazySlowPath(
    4824                 [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    4825                     return createLazyCallGenerator(
     4830                [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     4831                    return createLazyCallGenerator(vm,
    48264832                        operationNewTypedArrayWithSizeForType(type), locations[0].directGPR(),
    48274833                        CCallHelpers::TrustedImmPtr(structure.get()), locations[1].directGPR(),
    … …  
    50845090        m_out.appendTo(slowPath, continuation);
    50855091        LValue slowResultValue;
     5092        VM& vm = this->vm();
    50865093        switch (numKids) {
    50875094        case 2:
    50885095            slowResultValue = lazySlowPath(
    5089                 [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    5090                     return createLazyCallGenerator(
     5096                [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     5097                    return createLazyCallGenerator(vm,
    50915098                        operationMakeRope2, locations[0].directGPR(), locations[1].directGPR(),
    50925099                        locations[2].directGPR());
    … …  
    50955102        case 3:
    50965103            slowResultValue = lazySlowPath(
    5097                 [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    5098                     return createLazyCallGenerator(
     5104                [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     5105                    return createLazyCallGenerator(vm,
    50995106                        operationMakeRope3, locations[0].directGPR(), locations[1].directGPR(),
    51005107                        locations[2].directGPR(), locations[3].directGPR());
    … …  
    55135520        LBasicBlock lastNext = m_out.appendTo(isNotInvalidated, continuation);
    55145521
     5522        VM& vm = this->vm();
    55155523        lazySlowPath(
    5516             [=] (const Vector<Location>&) -> RefPtr<LazySlowPath::Generator> {
    5517                 return createLazyCallGenerator(
     5524            [=, &vm] (const Vector<Location>&) -> RefPtr<LazySlowPath::Generator> {
     5525                return createLazyCallGenerator(vm,
    55185526                    operationNotifyWrite, InvalidGPRReg, CCallHelpers::TrustedImmPtr(set));
    55195527            });
    … …  
    64496457                    jit.move(CCallHelpers::TrustedImmPtr(callee), GPRInfo::nonPreservedNonArgumentGPR);
    64506458                    jit.call(GPRInfo::nonPreservedNonArgumentGPR);
    6451                     exceptions->append(jit.emitExceptionCheck(AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
     6459                    exceptions->append(jit.emitExceptionCheck(state->vm(), AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
    64526460                };
    64536461
    … …  
    67566764                    jit.move(CCallHelpers::TrustedImmPtr(callee), GPRInfo::nonPreservedNonArgumentGPR);
    67576765                    jit.call(GPRInfo::nonPreservedNonArgumentGPR);
    6758                     exceptions->append(jit.emitExceptionCheck(AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
     6766                    exceptions->append(jit.emitExceptionCheck(state->vm(), AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
    67596767                };
    67606768
    … …  
    67726780
    67736781                    // emitSetupVarargsFrameFastCase modifies the stack pointer if it succeeds.
    6774                     emitSetupVarargsFrameFastCase(jit, scratchGPR2, scratchGPR1, scratchGPR2, scratchGPR3, inlineCallFrame, data->firstVarArgOffset, slowCase);
     6782                    emitSetupVarargsFrameFastCase(state->vm(), jit, scratchGPR2, scratchGPR1, scratchGPR2, scratchGPR3, inlineCallFrame, data->firstVarArgOffset, slowCase);
    67756783
    67766784                    CCallHelpers::Jump done = jit.jump();
    … …  
    69436951                jit.move(CCallHelpers::TrustedImmPtr(bitwise_cast<void*>(operationCallEval)), GPRInfo::nonPreservedNonArgumentGPR);
    69446952                jit.call(GPRInfo::nonPreservedNonArgumentGPR);
    6945                 exceptions->append(jit.emitExceptionCheck(AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
     6953                exceptions->append(jit.emitExceptionCheck(state->vm(), AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));
    69466954               
    69476955                CCallHelpers::Jump done = jit.branchTest64(CCallHelpers::NonZero, GPRInfo::returnValueGPR);
    … …  
    79867994       
    79877995        m_out.appendTo(slowPath, notCellCase);
     7996        VM& vm = this->vm();
    79887997        LValue slowResultValue = lazySlowPath(
    7989             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    7990                 return createLazyCallGenerator(
     7998            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     7999                return createLazyCallGenerator(vm,
    79918000                    operationObjectIsObject, locations[0].directGPR(),
    79928001                    CCallHelpers::TrustedImmPtr(globalObject), locations[1].directGPR());
    … …  
    80368045       
    80378046        m_out.appendTo(slowPath, continuation);
     8047        VM& vm = this->vm();
    80388048        LValue slowResultValue = lazySlowPath(
    8039             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    8040                 return createLazyCallGenerator(
     8049            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     8050                return createLazyCallGenerator(vm,
    80418051                    operationObjectIsFunction, locations[0].directGPR(),
    80428052                    CCallHelpers::TrustedImmPtr(globalObject), locations[1].directGPR());
    … …  
    87808790                LValue butterflyValue = m_out.phi(pointerType(), noButterfly, haveButterfly);
    87818791
     8792                VM& vm = this->vm();
    87828793                LValue slowObjectValue;
    87838794                if (hasIndexingHeader) {
    87848795                    slowObjectValue = lazySlowPath(
    8785                         [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    8786                             return createLazyCallGenerator(
     8796                        [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     8797                            return createLazyCallGenerator(vm,
    87878798                                operationNewObjectWithButterflyWithIndexingHeaderAndVectorLength,
    87888799                                locations[0].directGPR(), CCallHelpers::TrustedImmPtr(structure.get()),
    … …  
    87928803                } else {
    87938804                    slowObjectValue = lazySlowPath(
    8794                         [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    8795                             return createLazyCallGenerator(
     8805                        [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     8806                            return createLazyCallGenerator(vm,
    87968807                                operationNewObjectWithButterfly, locations[0].directGPR(),
    87978808                                CCallHelpers::TrustedImmPtr(structure.get()), locations[1].directGPR());
    … …  
    89919002        // FIXME: It may be worth creating an operation that calls a constructor on JSLexicalEnvironment that
    89929003        // doesn't initialize every slot because we are guaranteed to do that here.
     9004        VM& vm = this->vm();
    89939005        LValue callResult = lazySlowPath(
    8994             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    8995                 return createLazyCallGenerator(
     9006            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     9007                return createLazyCallGenerator(vm,
    89969008                    operationCreateActivationDirect, locations[0].directGPR(),
    89979009                    CCallHelpers::TrustedImmPtr(structure.get()), locations[1].directGPR(),
    … …  
    90469058        LBasicBlock lastNext = m_out.appendTo(needTrapHandling, continuation);
    90479059
     9060        VM& vm = this->vm();
    90489061        lazySlowPath(
    9049             [=] (const Vector<Location>&) -> RefPtr<LazySlowPath::Generator> {
    9050                 return createLazyCallGenerator(operationHandleTraps, InvalidGPRReg);
     9062            [=, &vm] (const Vector<Location>&) -> RefPtr<LazySlowPath::Generator> {
     9063                return createLazyCallGenerator(vm, operationHandleTraps, InvalidGPRReg);
    90519064            });
    90529065        m_out.jump(continuation);
    … …  
    97139726       
    97149727        LValue slowButterflyValue;
     9728        VM& vm = this->vm();
    97159729        if (sizeInValues == initialOutOfLineCapacity) {
    97169730            slowButterflyValue = lazySlowPath(
    9717                 [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    9718                     return createLazyCallGenerator(
     9731                [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     9732                    return createLazyCallGenerator(vm,
    97199733                        operationAllocateSimplePropertyStorageWithInitialCapacity,
    97209734                        locations[0].directGPR());
    … …  
    97229736        } else {
    97239737            slowButterflyValue = lazySlowPath(
    9724                 [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    9725                     return createLazyCallGenerator(
     9738                [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     9739                    return createLazyCallGenerator(vm,
    97269740                        operationAllocateSimplePropertyStorage, locations[0].directGPR(),
    97279741                        CCallHelpers::TrustedImmPtr(sizeInValues));
    … …  
    1080210816        m_out.appendTo(slowPath, continuation);
    1080310817
     10818        VM& vm = this->vm();
    1080410819        LValue slowResultValue = lazySlowPath(
    10805             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    10806                 return createLazyCallGenerator(
     10820            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     10821                return createLazyCallGenerator(vm,
    1080710822                    operationNewObject, locations[0].directGPR(),
    1080810823                    CCallHelpers::TrustedImmPtr(structure.get()));
    … …  
    1092010935        LValue butterflyValue = m_out.phi(pointerType(), noButterfly, haveButterfly);
    1092110936
     10937        VM& vm = this->vm();
    1092210938        LValue slowResultValue = lazySlowPath(
    10923             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    10924                 return createLazyCallGenerator(
     10939            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     10940                return createLazyCallGenerator(vm,
    1092510941                    operationNewArrayWithSize, locations[0].directGPR(),
    1092610942                    locations[1].directGPR(), locations[2].directGPR(), locations[3].directGPR());
    … …  
    1166811684       
    1166911685        m_out.appendTo(slowPath, unreachable);
     11686        VM& vm = this->vm();
    1167011687        LValue result = lazySlowPath(
    11671             [=] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
    11672                 return createLazyCallGenerator(
     11688            [=, &vm] (const Vector<Location>& locations) -> RefPtr<LazySlowPath::Generator> {
     11689                return createLazyCallGenerator(vm,
    1167311690                    operationTypeOfObjectAsTypeofType, locations[0].directGPR(),
    1167411691                    CCallHelpers::TrustedImmPtr(globalObject), locations[1].directGPR());
Note: See TracChangeset for help on using the changeset viewer.