Context Navigation

← Previous Change
Next Change →

Changeset 148696 in webkit for trunk/Source/JavaScriptCore/jit

Timestamp:

Apr 18, 2013, 12:32:17 PM (12 years ago)

Author:

[email protected]

Message:

Renamed JSGlobalData to VM
https://bugs.webkit.org/show_bug.cgi?id=114777

Reviewed by Phil Pizlo.

../JavaScriptCore:

API/APICast.h:

(JSC):
(toJS):
(toRef):

API/APIShims.h:

(JSC::APIEntryShimWithoutLock::APIEntryShimWithoutLock):
(APIEntryShimWithoutLock):
(JSC::APIEntryShim::APIEntryShim):
(APIEntryShim):
(JSC::APIEntryShim::~APIEntryShim):
(JSC::APICallbackShim::APICallbackShim):
(JSC::APICallbackShim::~APICallbackShim):
(APICallbackShim):

API/JSAPIWrapperObject.h:

(JSAPIWrapperObject):

API/JSAPIWrapperObject.mm:

(JSC::::createStructure):
(JSC::JSAPIWrapperObject::JSAPIWrapperObject):
(JSC::JSAPIWrapperObject::finishCreation):
(JSC::JSAPIWrapperObject::visitChildren):

API/JSBase.cpp:

(JSGarbageCollect):
(JSReportExtraMemoryCost):
(JSSynchronousGarbageCollectForDebugging):

API/JSCallbackConstructor.cpp:

(JSC::JSCallbackConstructor::JSCallbackConstructor):
(JSC::JSCallbackConstructor::finishCreation):

API/JSCallbackConstructor.h:

(JSC::JSCallbackConstructor::createStructure):

API/JSCallbackFunction.cpp:

(JSC::JSCallbackFunction::finishCreation):
(JSC::JSCallbackFunction::create):

API/JSCallbackFunction.h:

(JSCallbackFunction):
(JSC::JSCallbackFunction::createStructure):

API/JSCallbackObject.cpp:

(JSC::::create):
(JSC::::createStructure):

API/JSCallbackObject.h:

(JSC::JSCallbackObjectData::setPrivateProperty):
(JSC::JSCallbackObjectData::JSPrivatePropertyMap::setPrivateProperty):
(JSCallbackObject):
(JSC::JSCallbackObject::setPrivateProperty):

API/JSCallbackObjectFunctions.h:

(JSC::::JSCallbackObject):
(JSC::::finishCreation):
(JSC::::put):
(JSC::::staticFunctionGetter):

API/JSClassRef.cpp:

(OpaqueJSClassContextData::OpaqueJSClassContextData):
(OpaqueJSClass::contextData):
(OpaqueJSClass::prototype):

API/JSClassRef.h:

(OpaqueJSClassContextData):

API/JSContext.mm:

(-[JSContext setException:]):
(-[JSContext initWithGlobalContextRef:]):
(+[JSContext contextWithGlobalContextRef:]):

API/JSContextRef.cpp:

(JSContextGroupCreate):
(JSContextGroupRelease):
(JSGlobalContextCreate):
(JSGlobalContextCreateInGroup):
(JSGlobalContextRetain):
(JSGlobalContextRelease):
(JSContextGetGroup):
(JSContextCreateBacktrace):

API/JSObjectRef.cpp:

(JSObjectMake):
(JSObjectMakeConstructor):
(JSObjectMakeFunction):
(JSObjectSetPrototype):
(JSObjectHasProperty):
(JSObjectGetProperty):
(JSObjectSetProperty):
(JSObjectDeleteProperty):
(JSObjectGetPrivateProperty):
(JSObjectSetPrivateProperty):
(JSObjectDeletePrivateProperty):
(OpaqueJSPropertyNameArray::OpaqueJSPropertyNameArray):
(OpaqueJSPropertyNameArray):
(JSObjectCopyPropertyNames):
(JSPropertyNameArrayRelease):
(JSPropertyNameAccumulatorAddName):

API/JSScriptRef.cpp:

(OpaqueJSScript::create):
(OpaqueJSScript::vm):
(OpaqueJSScript::OpaqueJSScript):
(OpaqueJSScript):
(parseScript):

API/JSVirtualMachine.mm:

(scanExternalObjectGraph):

API/JSVirtualMachineInternal.h:

(JSC):

API/JSWrapperMap.mm:

(makeWrapper):

API/ObjCCallbackFunction.h:

(JSC::ObjCCallbackFunction::createStructure):

API/ObjCCallbackFunction.mm:

(JSC::ObjCCallbackFunction::create):

API/OpaqueJSString.cpp:

(OpaqueJSString::identifier):

API/OpaqueJSString.h:

(JSC):
(OpaqueJSString):

GNUmakefile.list.am:
JSCTypedArrayStubs.h:

(JSC):

JavaScriptCore.order:
JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreExports.def:
JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
JavaScriptCore.vcxproj/JavaScriptCoreExportGenerator/JavaScriptCoreExports.def.in:
JavaScriptCore.xcodeproj/project.pbxproj:
KeywordLookupGenerator.py:

(Trie.printSubTreeAsC):

Target.pri:
assembler/ARMAssembler.cpp:

(JSC::ARMAssembler::executableCopy):

assembler/ARMAssembler.h:

(ARMAssembler):

assembler/AssemblerBuffer.h:

(JSC::AssemblerBuffer::executableCopy):

assembler/AssemblerBufferWithConstantPool.h:

(JSC::AssemblerBufferWithConstantPool::executableCopy):

assembler/LinkBuffer.cpp:

(JSC::LinkBuffer::linkCode):

assembler/LinkBuffer.h:

(JSC):
(JSC::LinkBuffer::LinkBuffer):
(LinkBuffer):

assembler/MIPSAssembler.h:

(JSC::MIPSAssembler::executableCopy):

assembler/SH4Assembler.h:

(JSC::SH4Assembler::executableCopy):

assembler/X86Assembler.h:

(JSC::X86Assembler::executableCopy):
(JSC::X86Assembler::X86InstructionFormatter::executableCopy):

bytecode/CallLinkInfo.cpp:

(JSC::CallLinkInfo::unlink):

bytecode/CallLinkInfo.h:

(CallLinkInfo):

bytecode/CodeBlock.cpp:

(JSC::dumpStructure):
(JSC::CodeBlock::printStructures):
(JSC::CodeBlock::CodeBlock):
(JSC::CodeBlock::~CodeBlock):
(JSC::CodeBlock::visitStructures):
(JSC::CodeBlock::finalizeUnconditionally):
(JSC::CodeBlock::createActivation):
(JSC::CodeBlock::unlinkCalls):
(JSC::CodeBlock::unlinkIncomingCalls):
(JSC::CodeBlock::findClosureCallForReturnPC):
(JSC::ProgramCodeBlock::jettisonImpl):
(JSC::EvalCodeBlock::jettisonImpl):
(JSC::FunctionCodeBlock::jettisonImpl):
(JSC::CodeBlock::predictedMachineCodeSize):
(JSC::CodeBlock::usesOpcode):

bytecode/CodeBlock.h:

(JSC::CodeBlock::appendWeakReference):
(JSC::CodeBlock::appendWeakReferenceTransition):
(JSC::CodeBlock::setJITCode):
(JSC::CodeBlock::setGlobalData):
(JSC::CodeBlock::vm):
(JSC::CodeBlock::valueProfileForBytecodeOffset):
(JSC::CodeBlock::addConstant):
(JSC::CodeBlock::setConstantRegisters):
(CodeBlock):
(JSC::CodeBlock::WeakReferenceTransition::WeakReferenceTransition):

bytecode/EvalCodeCache.h:

(JSC::EvalCodeCache::getSlow):

bytecode/GetByIdStatus.cpp:

(JSC::GetByIdStatus::computeFromLLInt):
(JSC::GetByIdStatus::computeForChain):
(JSC::GetByIdStatus::computeFor):

bytecode/GetByIdStatus.h:

(GetByIdStatus):

bytecode/Instruction.h:

(JSC::Instruction::Instruction):

bytecode/ObjectAllocationProfile.h:

(JSC::ObjectAllocationProfile::initialize):
(JSC::ObjectAllocationProfile::possibleDefaultPropertyCount):

bytecode/PolymorphicAccessStructureList.h:

(JSC::PolymorphicAccessStructureList::PolymorphicStubInfo::set):
(JSC::PolymorphicAccessStructureList::PolymorphicAccessStructureList):

bytecode/PolymorphicPutByIdList.h:

(JSC::PutByIdAccess::transition):
(JSC::PutByIdAccess::replace):

bytecode/PreciseJumpTargets.cpp:

(JSC::computePreciseJumpTargets):

bytecode/PutByIdStatus.cpp:

(JSC::PutByIdStatus::computeFromLLInt):
(JSC::PutByIdStatus::computeFor):

bytecode/PutByIdStatus.h:

(JSC):
(PutByIdStatus):

bytecode/ResolveGlobalStatus.cpp:

(JSC::computeForStructure):

bytecode/SamplingTool.cpp:

(JSC::SamplingTool::notifyOfScope):

bytecode/SamplingTool.h:

(JSC::ScriptSampleRecord::ScriptSampleRecord):
(SamplingTool):

bytecode/StructureStubInfo.h:

(JSC::StructureStubInfo::initGetByIdSelf):
(JSC::StructureStubInfo::initGetByIdProto):
(JSC::StructureStubInfo::initGetByIdChain):
(JSC::StructureStubInfo::initPutByIdTransition):
(JSC::StructureStubInfo::initPutByIdReplace):

bytecode/UnlinkedCodeBlock.cpp:

(JSC::generateFunctionCodeBlock):
(JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
(JSC::UnlinkedFunctionExecutable::link):
(JSC::UnlinkedFunctionExecutable::fromGlobalCode):
(JSC::UnlinkedFunctionExecutable::codeBlockFor):
(JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):

bytecode/UnlinkedCodeBlock.h:

(JSC::UnlinkedFunctionExecutable::create):
(UnlinkedFunctionExecutable):
(JSC::UnlinkedFunctionExecutable::finishCreation):
(JSC::UnlinkedFunctionExecutable::createStructure):
(JSC::UnlinkedCodeBlock::addRegExp):
(JSC::UnlinkedCodeBlock::addConstant):
(JSC::UnlinkedCodeBlock::addFunctionDecl):
(JSC::UnlinkedCodeBlock::addFunctionExpr):
(JSC::UnlinkedCodeBlock::vm):
(UnlinkedCodeBlock):
(JSC::UnlinkedCodeBlock::finishCreation):
(JSC::UnlinkedGlobalCodeBlock::UnlinkedGlobalCodeBlock):
(JSC::UnlinkedProgramCodeBlock::create):
(JSC::UnlinkedProgramCodeBlock::addFunctionDeclaration):
(JSC::UnlinkedProgramCodeBlock::UnlinkedProgramCodeBlock):
(JSC::UnlinkedProgramCodeBlock::createStructure):
(JSC::UnlinkedEvalCodeBlock::create):
(JSC::UnlinkedEvalCodeBlock::UnlinkedEvalCodeBlock):
(JSC::UnlinkedEvalCodeBlock::createStructure):
(JSC::UnlinkedFunctionCodeBlock::create):
(JSC::UnlinkedFunctionCodeBlock::UnlinkedFunctionCodeBlock):
(JSC::UnlinkedFunctionCodeBlock::createStructure):

bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::addConstant):
(JSC::BytecodeGenerator::emitLoad):
(JSC::BytecodeGenerator::emitDirectPutById):
(JSC::BytecodeGenerator::addStringConstant):
(JSC::BytecodeGenerator::expectedFunctionForIdentifier):
(JSC::BytecodeGenerator::emitThrowReferenceError):
(JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):

bytecompiler/BytecodeGenerator.h:

(BytecodeGenerator):
(JSC::BytecodeGenerator::vm):
(JSC::BytecodeGenerator::propertyNames):
(JSC::BytecodeGenerator::makeFunction):

bytecompiler/NodesCodegen.cpp:

(JSC::RegExpNode::emitBytecode):
(JSC::ArrayNode::toArgumentList):
(JSC::ApplyFunctionCallDotNode::emitBytecode):
(JSC::InstanceOfNode::emitBytecode):

debugger/Debugger.cpp:

(JSC::Debugger::recompileAllJSFunctions):
(JSC::evaluateInGlobalCallFrame):

debugger/Debugger.h:

(JSC):

debugger/DebuggerActivation.cpp:

(JSC::DebuggerActivation::DebuggerActivation):
(JSC::DebuggerActivation::finishCreation):

debugger/DebuggerActivation.h:

(JSC::DebuggerActivation::create):
(JSC::DebuggerActivation::createStructure):
(DebuggerActivation):

debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluate):

dfg/DFGAbstractState.cpp:

(JSC::DFG::AbstractState::executeEffects):

dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::AssemblyHelpers):
(JSC::DFG::AssemblyHelpers::vm):
(JSC::DFG::AssemblyHelpers::debugCall):
(JSC::DFG::AssemblyHelpers::emitExceptionCheck):
(AssemblyHelpers):

dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::ByteCodeParser):
(ByteCodeParser):
(JSC::DFG::ByteCodeParser::handleConstantInternalFunction):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
(JSC::DFG::ByteCodeParser::parseCodeBlock):

dfg/DFGByteCodeParser.h:

(JSC):

dfg/DFGCCallHelpers.h:

(JSC::DFG::CCallHelpers::CCallHelpers):

dfg/DFGCapabilities.cpp:

(JSC::DFG::canHandleOpcodes):

dfg/DFGConstantFoldingPhase.cpp:

(JSC::DFG::ConstantFoldingPhase::foldConstants):

dfg/DFGDisassembler.cpp:

(JSC::DFG::Disassembler::reportToProfiler):

dfg/DFGDriver.cpp:

(JSC::DFG::compile):

dfg/DFGDriver.h:

(JSC):

dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::isStringPrototypeMethodSane):
(JSC::DFG::FixupPhase::canOptimizeStringObjectAccess):

dfg/DFGGraph.cpp:

(JSC::DFG::Graph::Graph):

dfg/DFGGraph.h:

(Graph):

dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::JITCompiler):
(JSC::DFG::JITCompiler::linkOSRExits):
(JSC::DFG::JITCompiler::link):
(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):

dfg/DFGJITCompiler.h:

(JSC):

dfg/DFGOSREntry.cpp:

(JSC::DFG::prepareOSREntry):

dfg/DFGOSRExitCompiler.cpp:
dfg/DFGOSRExitCompiler32_64.cpp:

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

dfg/DFGOSRExitCompiler64.cpp:

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

dfg/DFGOperations.cpp:

(JSC::DFG::putByVal):
(JSC::DFG::operationPutByValInternal):
(JSC::getHostCallReturnValueWithExecState):

dfg/DFGPhase.h:

(JSC::DFG::Phase::vm):

dfg/DFGRepatch.cpp:

(JSC::DFG::generateProtoChainAccessStub):
(JSC::DFG::tryCacheGetByID):
(JSC::DFG::tryBuildGetByIDList):
(JSC::DFG::tryBuildGetByIDProtoList):
(JSC::DFG::emitPutReplaceStub):
(JSC::DFG::emitPutTransitionStub):
(JSC::DFG::tryCachePutByID):
(JSC::DFG::tryBuildPutByIdList):
(JSC::DFG::linkSlowFor):
(JSC::DFG::dfgLinkFor):
(JSC::DFG::dfgLinkSlowFor):
(JSC::DFG::dfgLinkClosureCall):

dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::typedArrayDescriptor):
(JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
(JSC::DFG::SpeculativeJIT::compileGetByValOnString):
(JSC::DFG::SpeculativeJIT::compileFromCharCode):
(JSC::DFG::SpeculativeJIT::compileMakeRope):
(JSC::DFG::SpeculativeJIT::compileStringEquality):
(JSC::DFG::SpeculativeJIT::compileToStringOnCell):
(JSC::DFG::SpeculativeJIT::speculateObject):
(JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
(JSC::DFG::SpeculativeJIT::speculateString):
(JSC::DFG::SpeculativeJIT::speculateStringOrStringObject):

dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::prepareForExternalCall):
(JSC::DFG::SpeculativeJIT::emitAllocateBasicStorage):
(JSC::DFG::SpeculativeJIT::emitAllocateJSObject):

dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compileObjectEquality):
(JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
(JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
(JSC::DFG::SpeculativeJIT::compile):

dfg/DFGSpeculativeJIT64.cpp:

dfg/DFGThunks.cpp:

(JSC::DFG::osrExitGenerationThunkGenerator):
(JSC::DFG::throwExceptionFromCallSlowPathGenerator):
(JSC::DFG::slowPathFor):
(JSC::DFG::linkForThunkGenerator):
(JSC::DFG::linkCallThunkGenerator):
(JSC::DFG::linkConstructThunkGenerator):
(JSC::DFG::linkClosureCallThunkGenerator):
(JSC::DFG::virtualForThunkGenerator):
(JSC::DFG::virtualCallThunkGenerator):
(JSC::DFG::virtualConstructThunkGenerator):

dfg/DFGThunks.h:

(JSC):
(DFG):

heap/BlockAllocator.h:

(JSC):

heap/CopiedSpace.cpp:

(JSC::CopiedSpace::tryAllocateSlowCase):
(JSC::CopiedSpace::tryReallocate):

heap/CopiedSpaceInlines.h:

(JSC::CopiedSpace::tryAllocate):

heap/GCThreadSharedData.cpp:

(JSC::GCThreadSharedData::GCThreadSharedData):
(JSC::GCThreadSharedData::reset):

heap/GCThreadSharedData.h:

(JSC):
(GCThreadSharedData):

heap/HandleSet.cpp:

(JSC::HandleSet::HandleSet):
(JSC::HandleSet::~HandleSet):
(JSC::HandleSet::grow):

heap/HandleSet.h:

(JSC):
(HandleSet):
(JSC::HandleSet::vm):

heap/Heap.cpp:

(JSC::Heap::Heap):
(JSC):
(JSC::Heap::lastChanceToFinalize):
(JSC::Heap::protect):
(JSC::Heap::unprotect):
(JSC::Heap::stack):
(JSC::Heap::getConservativeRegisterRoots):
(JSC::Heap::markRoots):
(JSC::Heap::deleteAllCompiledCode):
(JSC::Heap::collect):
(JSC::Heap::isValidAllocation):

heap/Heap.h:

(JSC):
(Heap):
(JSC::Heap::vm):

heap/HeapTimer.cpp:

(JSC::HeapTimer::HeapTimer):
(JSC::HeapTimer::timerDidFire):
(JSC::HeapTimer::timerEvent):

heap/HeapTimer.h:

(JSC):
(HeapTimer):

heap/IncrementalSweeper.cpp:

(JSC::IncrementalSweeper::IncrementalSweeper):
(JSC::IncrementalSweeper::sweepNextBlock):
(JSC::IncrementalSweeper::willFinishSweeping):
(JSC::IncrementalSweeper::create):

heap/IncrementalSweeper.h:

(IncrementalSweeper):

heap/Local.h:

(Local):
(JSC::::Local):
(JSC::LocalStack::LocalStack):
(JSC::LocalStack::push):
(LocalStack):

heap/LocalScope.h:

(JSC):
(LocalScope):
(JSC::LocalScope::LocalScope):

heap/MachineStackMarker.cpp:

(JSC::MachineThreads::addCurrentThread):

heap/MarkedAllocator.cpp:

(JSC::MarkedAllocator::allocateSlowCase):

heap/MarkedBlock.cpp:

(JSC::MarkedBlock::MarkedBlock):

heap/MarkedBlock.h:

(JSC::MarkedBlock::vm):

heap/SlotVisitor.cpp:

(JSC::SlotVisitor::SlotVisitor):
(JSC::SlotVisitor::setup):

heap/Strong.h:

(JSC):
(Strong):
(JSC::Strong::operator=):

heap/StrongInlines.h:

(JSC::::Strong):
(JSC::::set):

heap/SuperRegion.h:

(JSC):

heap/WeakSet.cpp:
heap/WeakSet.h:

(WeakSet):
(JSC::WeakSet::WeakSet):
(JSC::WeakSet::vm):

interpreter/AbstractPC.cpp:

(JSC::AbstractPC::AbstractPC):

interpreter/AbstractPC.h:

(JSC):
(AbstractPC):

interpreter/CachedCall.h:

(JSC::CachedCall::CachedCall):

interpreter/CallFrame.h:

(ExecState):
(JSC::ExecState::clearException):
(JSC::ExecState::clearSupplementaryExceptionInfo):
(JSC::ExecState::exception):
(JSC::ExecState::hadException):
(JSC::ExecState::propertyNames):
(JSC::ExecState::emptyList):
(JSC::ExecState::interpreter):
(JSC::ExecState::heap):
(JSC::ExecState::arrayConstructorTable):
(JSC::ExecState::arrayPrototypeTable):
(JSC::ExecState::booleanPrototypeTable):
(JSC::ExecState::dateTable):
(JSC::ExecState::dateConstructorTable):
(JSC::ExecState::errorPrototypeTable):
(JSC::ExecState::globalObjectTable):
(JSC::ExecState::jsonTable):
(JSC::ExecState::mathTable):
(JSC::ExecState::numberConstructorTable):
(JSC::ExecState::numberPrototypeTable):
(JSC::ExecState::objectConstructorTable):
(JSC::ExecState::privateNamePrototypeTable):
(JSC::ExecState::regExpTable):
(JSC::ExecState::regExpConstructorTable):
(JSC::ExecState::regExpPrototypeTable):
(JSC::ExecState::stringConstructorTable):
(JSC::ExecState::abstractReturnPC):

interpreter/CallFrameClosure.h:

(CallFrameClosure):

interpreter/Interpreter.cpp:

(JSC):
(JSC::eval):
(JSC::loadVarargs):
(JSC::Interpreter::Interpreter):
(JSC::Interpreter::dumpRegisters):
(JSC::Interpreter::unwindCallFrame):
(JSC::appendSourceToError):
(JSC::getCallerInfo):
(JSC::Interpreter::getStackTrace):
(JSC::Interpreter::addStackTraceIfNecessary):
(JSC::Interpreter::throwException):
(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::prepareForRepeatCall):
(JSC::Interpreter::retrieveArgumentsFromVMCode):
(JSC::Interpreter::retrieveCallerFromVMCode):

interpreter/Interpreter.h:

(JSC):
(JSC::TopCallFrameSetter::TopCallFrameSetter):
(JSC::TopCallFrameSetter::~TopCallFrameSetter):
(TopCallFrameSetter):
(JSC::NativeCallFrameTracer::NativeCallFrameTracer):
(Interpreter):

interpreter/JSStack.cpp:

(JSC::JSStack::JSStack):

interpreter/JSStack.h:

(JSC):

jit/ClosureCallStubRoutine.cpp:

(JSC::ClosureCallStubRoutine::ClosureCallStubRoutine):

jit/ClosureCallStubRoutine.h:

(ClosureCallStubRoutine):

jit/ExecutableAllocator.cpp:

(JSC::ExecutableAllocator::ExecutableAllocator):
(JSC::ExecutableAllocator::allocate):

jit/ExecutableAllocator.h:

(JSC):
(ExecutableAllocator):

jit/ExecutableAllocatorFixedVMPool.cpp:

(JSC::ExecutableAllocator::ExecutableAllocator):
(JSC::ExecutableAllocator::allocate):

jit/GCAwareJITStubRoutine.cpp:

(JSC::GCAwareJITStubRoutine::GCAwareJITStubRoutine):
(JSC::MarkingGCAwareJITStubRoutineWithOneObject::MarkingGCAwareJITStubRoutineWithOneObject):
(JSC::createJITStubRoutine):

jit/GCAwareJITStubRoutine.h:

(GCAwareJITStubRoutine):
(MarkingGCAwareJITStubRoutineWithOneObject):
(JSC):

jit/JIT.cpp:

(JSC::JIT::JIT):
(JSC::JIT::privateCompile):
(JSC::JIT::linkFor):
(JSC::JIT::linkSlowCall):

jit/JIT.h:

(JSC::JIT::compile):
(JSC::JIT::compileClosureCall):
(JSC::JIT::compileGetByIdProto):
(JSC::JIT::compileGetByIdSelfList):
(JSC::JIT::compileGetByIdProtoList):
(JSC::JIT::compileGetByIdChainList):
(JSC::JIT::compileGetByIdChain):
(JSC::JIT::compilePutByIdTransition):
(JSC::JIT::compileGetByVal):
(JSC::JIT::compilePutByVal):
(JSC::JIT::compileCTINativeCall):
(JSC::JIT::compilePatchGetArrayLength):
(JIT):

jit/JITCall.cpp:

(JSC::JIT::compileLoadVarargs):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileOpCallSlowCase):
(JSC::JIT::privateCompileClosureCall):

jit/JITCall32_64.cpp:

(JSC::JIT::compileLoadVarargs):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileOpCallSlowCase):
(JSC::JIT::privateCompileClosureCall):

jit/JITCode.h:

(JSC):
(JSC::JITCode::execute):

jit/JITDriver.h:

(JSC::jitCompileIfAppropriate):
(JSC::jitCompileFunctionIfAppropriate):

jit/JITExceptions.cpp:

(JSC::genericThrow):
(JSC::jitThrow):

jit/JITExceptions.h:

(JSC):

jit/JITInlines.h:

(JSC::JIT::emitLoadCharacterString):
(JSC::JIT::updateTopCallFrame):

jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_new_object):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_convert_this):
(JSC::JIT::emitSlow_op_convert_this):

jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_new_object):
(JSC::JIT::emit_op_to_primitive):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::compileOpStrictEq):
(JSC::JIT::emit_op_catch):
(JSC::JIT::emit_op_convert_this):
(JSC::JIT::emitSlow_op_convert_this):

jit/JITPropertyAccess.cpp:

(JSC::JIT::stringGetByValStubGenerator):
(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::compileGetByIdHotPath):
(JSC::JIT::privateCompilePutByIdTransition):
(JSC::JIT::privateCompilePatchGetArrayLength):
(JSC::JIT::privateCompileGetByIdProto):
(JSC::JIT::privateCompileGetByIdSelfList):
(JSC::JIT::privateCompileGetByIdProtoList):
(JSC::JIT::privateCompileGetByIdChainList):
(JSC::JIT::privateCompileGetByIdChain):
(JSC::JIT::privateCompileGetByVal):
(JSC::JIT::privateCompilePutByVal):

jit/JITPropertyAccess32_64.cpp:

jit/JITStubs.cpp:

(JSC::ctiTrampoline):
(JSC):
(JSC::performPlatformSpecificJITAssertions):
(JSC::tryCachePutByID):
(JSC::tryCacheGetByID):
(JSC::returnToThrowTrampoline):
(JSC::throwExceptionFromOpCall):
(JSC::DEFINE_STUB_FUNCTION):
(JSC::getPolymorphicAccessStructureListSlot):
(JSC::jitCompileFor):
(JSC::lazyLinkFor):
(JSC::putByVal):

jit/JITStubs.h:

(JSC):
(JITStackFrame):

jit/JITThunks.cpp:

(JSC::JITThunks::ctiNativeCall):
(JSC::JITThunks::ctiNativeConstruct):
(JSC::JITThunks::ctiStub):
(JSC::JITThunks::hostFunctionStub):

jit/JITThunks.h:

(JSC):
(JITThunks):

jit/JITWriteBarrier.h:

(JSC):
(JSC::JITWriteBarrierBase::set):
(JSC::JITWriteBarrier::set):

jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::loadJSStringArgument):
(JSC::SpecializedThunkJIT::finalize):

jit/ThunkGenerator.h:

(JSC):

jit/ThunkGenerators.cpp:

(JSC::generateSlowCaseFor):
(JSC::linkForGenerator):
(JSC::linkCallGenerator):
(JSC::linkConstructGenerator):
(JSC::linkClosureCallGenerator):
(JSC::virtualForGenerator):
(JSC::virtualCallGenerator):
(JSC::virtualConstructGenerator):
(JSC::stringLengthTrampolineGenerator):
(JSC::nativeForGenerator):
(JSC::nativeCallGenerator):
(JSC::nativeConstructGenerator):
(JSC::stringCharLoad):
(JSC::charToString):
(JSC::charCodeAtThunkGenerator):
(JSC::charAtThunkGenerator):
(JSC::fromCharCodeThunkGenerator):
(JSC::sqrtThunkGenerator):
(JSC::floorThunkGenerator):
(JSC::ceilThunkGenerator):
(JSC::roundThunkGenerator):
(JSC::expThunkGenerator):
(JSC::logThunkGenerator):
(JSC::absThunkGenerator):
(JSC::powThunkGenerator):

jit/ThunkGenerators.h:

(JSC):

jsc.cpp:

(GlobalObject):
(GlobalObject::create):
(GlobalObject::createStructure):
(GlobalObject::finishCreation):
(GlobalObject::addFunction):
(GlobalObject::addConstructableFunction):
(functionDumpCallFrame):
(functionJSCStack):
(functionReleaseExecutableMemory):
(functionRun):
(main):
(runWithScripts):
(jscmain):

llint/LLIntData.cpp:

(JSC::LLInt::Data::performAssertions):

llint/LLIntData.h:

(JSC):
(Data):
(JSC::LLInt::Data::performAssertions):

llint/LLIntEntrypoints.cpp:

(JSC::LLInt::getFunctionEntrypoint):
(JSC::LLInt::getEvalEntrypoint):
(JSC::LLInt::getProgramEntrypoint):

llint/LLIntEntrypoints.h:

(JSC):
(LLInt):
(JSC::LLInt::getEntrypoint):

llint/LLIntExceptions.cpp:

(JSC::LLInt::interpreterThrowInCaller):
(JSC::LLInt::returnToThrow):
(JSC::LLInt::callToThrow):

llint/LLIntOffsetsExtractor.cpp:
llint/LLIntSlowPaths.cpp:

(LLInt):
(JSC::LLInt::llint_trace_operand):
(JSC::LLInt::llint_trace_value):
(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::shouldJIT):
(JSC::LLInt::handleHostCall):
(JSC::LLInt::setUpCall):

llint/LLIntThunks.cpp:

(JSC::LLInt::generateThunkWithJumpTo):
(JSC::LLInt::functionForCallEntryThunkGenerator):
(JSC::LLInt::functionForConstructEntryThunkGenerator):
(JSC::LLInt::functionForCallArityCheckThunkGenerator):
(JSC::LLInt::functionForConstructArityCheckThunkGenerator):
(JSC::LLInt::evalEntryThunkGenerator):
(JSC::LLInt::programEntryThunkGenerator):

llint/LLIntThunks.h:

(JSC):
(LLInt):

llint/LowLevelInterpreter.asm:
llint/LowLevelInterpreter.cpp:

(JSC::CLoop::execute):

llint/LowLevelInterpreter32_64.asm:
llint/LowLevelInterpreter64.asm:
offlineasm/cloop.rb:
parser/ASTBuilder.h:

(JSC::ASTBuilder::ASTBuilder):
(JSC::ASTBuilder::createSourceElements):
(JSC::ASTBuilder::createCommaExpr):
(JSC::ASTBuilder::createLogicalNot):
(JSC::ASTBuilder::createUnaryPlus):
(JSC::ASTBuilder::createVoid):
(JSC::ASTBuilder::thisExpr):
(JSC::ASTBuilder::createResolve):
(JSC::ASTBuilder::createObjectLiteral):
(JSC::ASTBuilder::createArray):
(JSC::ASTBuilder::createNumberExpr):
(JSC::ASTBuilder::createString):
(JSC::ASTBuilder::createBoolean):
(JSC::ASTBuilder::createNull):
(JSC::ASTBuilder::createBracketAccess):
(JSC::ASTBuilder::createDotAccess):
(JSC::ASTBuilder::createRegExp):
(JSC::ASTBuilder::createNewExpr):
(JSC::ASTBuilder::createConditionalExpr):
(JSC::ASTBuilder::createAssignResolve):
(JSC::ASTBuilder::createFunctionExpr):
(JSC::ASTBuilder::createFunctionBody):
(JSC::ASTBuilder::createGetterOrSetterProperty):
(JSC::ASTBuilder::createArguments):
(JSC::ASTBuilder::createArgumentsList):
(JSC::ASTBuilder::createProperty):
(JSC::ASTBuilder::createPropertyList):
(JSC::ASTBuilder::createElementList):
(JSC::ASTBuilder::createFormalParameterList):
(JSC::ASTBuilder::createClause):
(JSC::ASTBuilder::createClauseList):
(JSC::ASTBuilder::createFuncDeclStatement):
(JSC::ASTBuilder::createBlockStatement):
(JSC::ASTBuilder::createExprStatement):
(JSC::ASTBuilder::createIfStatement):
(JSC::ASTBuilder::createForLoop):
(JSC::ASTBuilder::createForInLoop):
(JSC::ASTBuilder::createEmptyStatement):
(JSC::ASTBuilder::createVarStatement):
(JSC::ASTBuilder::createReturnStatement):
(JSC::ASTBuilder::createBreakStatement):
(JSC::ASTBuilder::createContinueStatement):
(JSC::ASTBuilder::createTryStatement):
(JSC::ASTBuilder::createSwitchStatement):
(JSC::ASTBuilder::createWhileStatement):
(JSC::ASTBuilder::createDoWhileStatement):
(JSC::ASTBuilder::createLabelStatement):
(JSC::ASTBuilder::createWithStatement):
(JSC::ASTBuilder::createThrowStatement):
(JSC::ASTBuilder::createDebugger):
(JSC::ASTBuilder::createConstStatement):
(JSC::ASTBuilder::appendConstDecl):
(JSC::ASTBuilder::addVar):
(JSC::ASTBuilder::combineCommaNodes):
(JSC::ASTBuilder::Scope::Scope):
(JSC::ASTBuilder::createNumber):
(ASTBuilder):
(JSC::ASTBuilder::makeTypeOfNode):
(JSC::ASTBuilder::makeDeleteNode):
(JSC::ASTBuilder::makeNegateNode):
(JSC::ASTBuilder::makeBitwiseNotNode):
(JSC::ASTBuilder::makeMultNode):
(JSC::ASTBuilder::makeDivNode):
(JSC::ASTBuilder::makeModNode):
(JSC::ASTBuilder::makeAddNode):
(JSC::ASTBuilder::makeSubNode):
(JSC::ASTBuilder::makeLeftShiftNode):
(JSC::ASTBuilder::makeRightShiftNode):
(JSC::ASTBuilder::makeURightShiftNode):
(JSC::ASTBuilder::makeBitOrNode):
(JSC::ASTBuilder::makeBitAndNode):
(JSC::ASTBuilder::makeBitXOrNode):
(JSC::ASTBuilder::makeFunctionCallNode):
(JSC::ASTBuilder::makeBinaryNode):
(JSC::ASTBuilder::makeAssignNode):
(JSC::ASTBuilder::makePrefixNode):
(JSC::ASTBuilder::makePostfixNode):

parser/Lexer.cpp:

(JSC::Keywords::Keywords):
(JSC::::Lexer):
(JSC::::parseIdentifier):
(JSC::::parseIdentifierSlowCase):

parser/Lexer.h:

(JSC::Keywords::isKeyword):
(JSC::Keywords::getKeyword):
(Keywords):
(Lexer):
(JSC::::makeIdentifier):
(JSC::::makeRightSizedIdentifier):
(JSC::::makeIdentifierLCharFromUChar):
(JSC::::makeLCharIdentifier):

parser/NodeConstructors.h:

(JSC::ParserArenaFreeable::operator new):
(JSC::ParserArenaDeletable::operator new):
(JSC::ParserArenaRefCounted::ParserArenaRefCounted):
(JSC::PropertyNode::PropertyNode):
(JSC::ContinueNode::ContinueNode):
(JSC::BreakNode::BreakNode):
(JSC::ForInNode::ForInNode):

parser/Nodes.cpp:

(JSC::ScopeNode::ScopeNode):
(JSC::ProgramNode::ProgramNode):
(JSC::ProgramNode::create):
(JSC::EvalNode::EvalNode):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::FunctionBodyNode):
(JSC::FunctionBodyNode::create):

parser/Nodes.h:

(ParserArenaFreeable):
(ParserArenaDeletable):
(ParserArenaRefCounted):
(ArrayNode):
(ForInNode):
(ContinueNode):
(BreakNode):
(ScopeNode):
(ProgramNode):
(EvalNode):
(FunctionBodyNode):

parser/Parser.cpp:

(JSC::::Parser):
(JSC::::parseInner):
(JSC::::parseSourceElements):
(JSC::::parseTryStatement):
(JSC::::parseFunctionBody):
(JSC::::parseFunctionInfo):
(JSC::::parseAssignmentExpression):
(JSC::::parseProperty):
(JSC::::parsePrimaryExpression):
(JSC::::parseMemberExpression):
(JSC::::parseUnaryExpression):

parser/Parser.h:

(JSC):
(JSC::Scope::Scope):
(JSC::Scope::declareVariable):
(JSC::Scope::declareParameter):
(Scope):
(Parser):
(JSC::Parser::pushScope):
(JSC::::parse):
(JSC::parse):

parser/ParserArena.h:

(IdentifierArena):
(JSC::IdentifierArena::makeIdentifier):
(JSC::IdentifierArena::makeIdentifierLCharFromUChar):
(JSC::IdentifierArena::makeNumericIdentifier):

parser/SyntaxChecker.h:

(JSC::SyntaxChecker::SyntaxChecker):
(JSC::SyntaxChecker::createProperty):
(JSC::SyntaxChecker::createGetterOrSetterProperty):

profiler/LegacyProfiler.cpp:

(JSC::LegacyProfiler::startProfiling):
(JSC::LegacyProfiler::stopProfiling):

profiler/LegacyProfiler.h:

(JSC):

profiler/ProfilerBytecode.cpp:

(JSC::Profiler::Bytecode::toJS):

profiler/ProfilerBytecodeSequence.cpp:

(JSC::Profiler::BytecodeSequence::BytecodeSequence):
(JSC::Profiler::BytecodeSequence::addSequenceProperties):

profiler/ProfilerBytecodes.cpp:

(JSC::Profiler::Bytecodes::toJS):

profiler/ProfilerCompilation.cpp:

(JSC::Profiler::Compilation::toJS):

profiler/ProfilerCompiledBytecode.cpp:

(JSC::Profiler::CompiledBytecode::toJS):

profiler/ProfilerDatabase.cpp:

(JSC::Profiler::Database::Database):
(JSC::Profiler::Database::toJS):
(JSC::Profiler::Database::toJSON):

profiler/ProfilerDatabase.h:

(Database):

profiler/ProfilerOSRExit.cpp:

(JSC::Profiler::OSRExit::toJS):

profiler/ProfilerOrigin.cpp:

(JSC::Profiler::Origin::toJS):

profiler/ProfilerProfiledBytecodes.cpp:

(JSC::Profiler::ProfiledBytecodes::toJS):

runtime/ArgList.h:

(MarkedArgumentBuffer):

runtime/Arguments.cpp:

(JSC::Arguments::putByIndex):
(JSC::Arguments::put):
(JSC::Arguments::deleteProperty):
(JSC::Arguments::defineOwnProperty):
(JSC::Arguments::tearOff):
(JSC::Arguments::didTearOffActivation):
(JSC::Arguments::tearOffForInlineCallFrame):

runtime/Arguments.h:

(JSC::Arguments::create):
(JSC::Arguments::createStructure):
(Arguments):
(JSC::Arguments::Arguments):
(JSC::Arguments::trySetArgument):
(JSC::Arguments::finishCreation):

runtime/ArrayConstructor.cpp:

(JSC::ArrayConstructor::finishCreation):

runtime/ArrayConstructor.h:

(JSC::ArrayConstructor::createStructure):

runtime/ArrayPrototype.cpp:

(JSC::ArrayPrototype::ArrayPrototype):
(JSC::ArrayPrototype::finishCreation):
(JSC::arrayProtoFuncSort):
(JSC::arrayProtoFuncSplice):

runtime/ArrayPrototype.h:

(JSC::ArrayPrototype::createStructure):

runtime/BatchedTransitionOptimizer.h:

(JSC::BatchedTransitionOptimizer::BatchedTransitionOptimizer):
(JSC::BatchedTransitionOptimizer::~BatchedTransitionOptimizer):
(BatchedTransitionOptimizer):

runtime/BooleanConstructor.cpp:

(JSC::BooleanConstructor::finishCreation):
(JSC::constructBoolean):
(JSC::constructBooleanFromImmediateBoolean):

runtime/BooleanConstructor.h:

(JSC::BooleanConstructor::createStructure):

runtime/BooleanObject.cpp:

(JSC::BooleanObject::BooleanObject):
(JSC::BooleanObject::finishCreation):

runtime/BooleanObject.h:

(BooleanObject):
(JSC::BooleanObject::create):
(JSC::BooleanObject::createStructure):

runtime/BooleanPrototype.cpp:

(JSC::BooleanPrototype::BooleanPrototype):
(JSC::BooleanPrototype::finishCreation):
(JSC::booleanProtoFuncToString):

runtime/BooleanPrototype.h:

(JSC::BooleanPrototype::createStructure):

runtime/Butterfly.h:

(JSC):
(Butterfly):

runtime/ButterflyInlines.h:

(JSC::Butterfly::createUninitialized):
(JSC::Butterfly::create):
(JSC::Butterfly::growPropertyStorage):
(JSC::Butterfly::createOrGrowArrayRight):
(JSC::Butterfly::growArrayRight):
(JSC::Butterfly::resizeArray):

runtime/CodeCache.cpp:

(JSC::CodeCache::getCodeBlock):
(JSC::CodeCache::getProgramCodeBlock):
(JSC::CodeCache::getEvalCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode):

runtime/CodeCache.h:

(JSC):
(JSC::SourceCodeValue::SourceCodeValue):
(CodeCache):

runtime/CommonIdentifiers.cpp:

(JSC):
(JSC::CommonIdentifiers::CommonIdentifiers):

runtime/CommonIdentifiers.h:

(CommonIdentifiers):

runtime/CommonSlowPaths.h:

(JSC::CommonSlowPaths::opIn):

runtime/Completion.cpp:

(JSC::checkSyntax):
(JSC::evaluate):

runtime/DateConstructor.cpp:

(JSC::DateConstructor::finishCreation):

runtime/DateConstructor.h:

(JSC::DateConstructor::createStructure):

runtime/DateInstance.cpp:

(JSC::DateInstance::DateInstance):
(JSC::DateInstance::finishCreation):
(JSC::DateInstance::calculateGregorianDateTime):
(JSC::DateInstance::calculateGregorianDateTimeUTC):

runtime/DateInstance.h:

(DateInstance):
(JSC::DateInstance::create):
(JSC::DateInstance::createStructure):

runtime/DatePrototype.cpp:

(JSC::DatePrototype::finishCreation):
(JSC::dateProtoFuncSetTime):
(JSC::setNewValueFromTimeArgs):
(JSC::setNewValueFromDateArgs):
(JSC::dateProtoFuncSetYear):
(JSC::dateProtoFuncToJSON):

runtime/DatePrototype.h:

(JSC::DatePrototype::createStructure):

runtime/Error.cpp:

(JSC::createError):
(JSC::createEvalError):
(JSC::createRangeError):
(JSC::createReferenceError):
(JSC::createSyntaxError):
(JSC::createTypeError):
(JSC::createURIError):
(JSC::addErrorInfo):
(JSC::throwError):

runtime/Error.h:

(JSC):
(JSC::StrictModeTypeErrorFunction::create):
(JSC::StrictModeTypeErrorFunction::createStructure):

runtime/ErrorConstructor.cpp:

(JSC::ErrorConstructor::finishCreation):

runtime/ErrorConstructor.h:

(JSC::ErrorConstructor::createStructure):

runtime/ErrorInstance.cpp:

(JSC::ErrorInstance::ErrorInstance):

runtime/ErrorInstance.h:

(JSC::ErrorInstance::createStructure):
(JSC::ErrorInstance::create):
(ErrorInstance):
(JSC::ErrorInstance::finishCreation):

runtime/ErrorPrototype.cpp:

(JSC::ErrorPrototype::ErrorPrototype):
(JSC::ErrorPrototype::finishCreation):

runtime/ErrorPrototype.h:

(JSC::ErrorPrototype::createStructure):

runtime/ExceptionHelpers.cpp:

(JSC::createInterruptedExecutionException):
(JSC::createTerminatedExecutionException):

runtime/ExceptionHelpers.h:

(JSC):
(JSC::InterruptedExecutionError::InterruptedExecutionError):
(JSC::InterruptedExecutionError::create):
(JSC::InterruptedExecutionError::createStructure):
(JSC::TerminatedExecutionError::TerminatedExecutionError):
(JSC::TerminatedExecutionError::create):
(JSC::TerminatedExecutionError::createStructure):

runtime/Executable.cpp:

(JSC::jettisonCodeBlock):
(JSC::EvalExecutable::EvalExecutable):
(JSC::ProgramExecutable::ProgramExecutable):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::EvalExecutable::compileOptimized):
(JSC::EvalExecutable::compileInternal):
(JSC::EvalExecutable::jettisonOptimizedCode):
(JSC::ProgramExecutable::checkSyntax):
(JSC::ProgramExecutable::compileOptimized):
(JSC::ProgramExecutable::jettisonOptimizedCode):
(JSC::ProgramExecutable::initializeGlobalProperties):
(JSC::FunctionExecutable::compileOptimizedForCall):
(JSC::FunctionExecutable::compileOptimizedForConstruct):
(JSC::FunctionExecutable::produceCodeBlockFor):
(JSC::FunctionExecutable::jettisonOptimizedCodeForCall):
(JSC::FunctionExecutable::jettisonOptimizedCodeForConstruct):
(JSC::FunctionExecutable::fromGlobalCode):

runtime/Executable.h:

(JSC::ExecutableBase::ExecutableBase):
(JSC::ExecutableBase::finishCreation):
(JSC::ExecutableBase::createStructure):
(JSC::NativeExecutable::create):
(JSC::NativeExecutable::createStructure):
(JSC::NativeExecutable::finishCreation):
(JSC::NativeExecutable::NativeExecutable):
(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ScriptExecutable::finishCreation):
(JSC::EvalExecutable::compile):
(EvalExecutable):
(JSC::EvalExecutable::create):
(JSC::EvalExecutable::createStructure):
(JSC::ProgramExecutable::create):
(ProgramExecutable):
(JSC::ProgramExecutable::compile):
(JSC::ProgramExecutable::createStructure):
(JSC::FunctionExecutable::create):
(JSC::FunctionExecutable::compileForCall):
(FunctionExecutable):
(JSC::FunctionExecutable::compileForConstruct):
(JSC::FunctionExecutable::jettisonOptimizedCodeFor):
(JSC::FunctionExecutable::createStructure):
(JSC::JSFunction::JSFunction):

runtime/ExecutionHarness.h:

(JSC::prepareForExecution):
(JSC::prepareFunctionForExecution):

runtime/FunctionConstructor.cpp:

(JSC::FunctionConstructor::finishCreation):

runtime/FunctionConstructor.h:

(JSC::FunctionConstructor::createStructure):

runtime/FunctionPrototype.cpp:

(JSC::FunctionPrototype::finishCreation):
(JSC::FunctionPrototype::addFunctionProperties):
(JSC::functionProtoFuncBind):

runtime/FunctionPrototype.h:

(JSC::FunctionPrototype::createStructure):

runtime/GCActivityCallback.cpp:

(JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
(JSC::DefaultGCActivityCallback::doWork):
(JSC::DefaultGCActivityCallback::didAllocate):

runtime/GCActivityCallback.h:

(JSC::GCActivityCallback::GCActivityCallback):

runtime/GCActivityCallbackBlackBerry.cpp:

(JSC::DefaultGCActivityCallback::DefaultGCActivityCallback):
(JSC::DefaultGCActivityCallback::doWork):
(JSC::DefaultGCActivityCallback::didAllocate):

runtime/GetterSetter.h:

(JSC::GetterSetter::GetterSetter):
(JSC::GetterSetter::create):
(JSC::GetterSetter::setGetter):
(JSC::GetterSetter::setSetter):
(JSC::GetterSetter::createStructure):

runtime/Identifier.cpp:

(JSC::Identifier::add):
(JSC::Identifier::add8):
(JSC::Identifier::addSlowCase):
(JSC::Identifier::from):
(JSC::Identifier::checkCurrentIdentifierTable):

runtime/Identifier.h:

(JSC::Identifier::Identifier):
(JSC::Identifier::createLCharFromUChar):
(Identifier):
(JSC::Identifier::add):

runtime/InternalFunction.cpp:

(JSC::InternalFunction::InternalFunction):
(JSC::InternalFunction::finishCreation):
(JSC::InternalFunction::name):
(JSC::InternalFunction::displayName):

runtime/InternalFunction.h:

(JSC::InternalFunction::createStructure):
(InternalFunction):

runtime/JSAPIValueWrapper.h:

(JSC::JSAPIValueWrapper::createStructure):
(JSC::JSAPIValueWrapper::finishCreation):
(JSC::JSAPIValueWrapper::JSAPIValueWrapper):

runtime/JSActivation.cpp:

(JSC::JSActivation::symbolTablePut):
(JSC::JSActivation::symbolTablePutWithAttributes):
(JSC::JSActivation::getOwnPropertySlot):
(JSC::JSActivation::put):
(JSC::JSActivation::putDirectVirtual):
(JSC::JSActivation::argumentsGetter):

runtime/JSActivation.h:

(JSActivation):
(JSC::JSActivation::create):
(JSC::JSActivation::createStructure):
(JSC::JSActivation::JSActivation):
(JSC::JSActivation::tearOff):

runtime/JSArray.cpp:

(JSC::createArrayButterflyInDictionaryIndexingMode):
(JSC::JSArray::setLengthWritable):
(JSC::JSArray::unshiftCountSlowCase):
(JSC::JSArray::setLength):
(JSC::JSArray::push):
(JSC::JSArray::shiftCountWithAnyIndexingType):
(JSC::JSArray::unshiftCountWithArrayStorage):
(JSC::JSArray::unshiftCountWithAnyIndexingType):
(JSC::ContiguousTypeAccessor::setWithValue):
(JSC::JSArray::sortCompactedVector):
(JSC::JSArray::sortVector):

runtime/JSArray.h:

(JSC::JSArray::JSArray):
(JSArray):
(JSC::JSArray::shiftCountForShift):
(JSC::JSArray::unshiftCountForShift):
(JSC::JSArray::createStructure):
(JSC::createContiguousArrayButterfly):
(JSC::createArrayButterfly):
(JSC):
(JSC::JSArray::create):
(JSC::JSArray::tryCreateUninitialized):
(JSC::constructArray):

runtime/JSBoundFunction.cpp:

(JSC::JSBoundFunction::create):
(JSC::JSBoundFunction::JSBoundFunction):

runtime/JSBoundFunction.h:

(JSC::JSBoundFunction::createStructure):

runtime/JSCJSValue.cpp:

(JSC::JSValue::putToPrimitive):
(JSC::JSValue::toStringSlowCase):

runtime/JSCJSValue.h:

(JSC):

runtime/JSCell.h:

(JSCell):

runtime/JSCellInlines.h:

(JSC::JSCell::JSCell):
(JSC::JSCell::finishCreation):
(JSC::allocateCell):
(JSC::JSCell::setStructure):
(JSC::JSCell::fastGetOwnProperty):

runtime/JSDateMath.cpp:

(JSC::getDSTOffset):
(JSC::getUTCOffset):
(JSC::parseDate):

runtime/JSDestructibleObject.h:

(JSC::JSDestructibleObject::JSDestructibleObject):

runtime/JSFunction.cpp:

(JSC::JSFunction::create):
(JSC::JSFunction::JSFunction):
(JSC::JSFunction::finishCreation):
(JSC::JSFunction::createAllocationProfile):
(JSC::JSFunction::name):
(JSC::JSFunction::displayName):
(JSC::JSFunction::getOwnPropertySlot):
(JSC::JSFunction::deleteProperty):

runtime/JSFunction.h:

(JSFunction):
(JSC::JSFunction::create):
(JSC::JSFunction::setScope):
(JSC::JSFunction::createStructure):

runtime/JSGlobalData.cpp: Removed.
runtime/JSGlobalData.h: Removed.
runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::JSGlobalObject):
(JSC::JSGlobalObject::~JSGlobalObject):
(JSC::JSGlobalObject::setGlobalThis):
(JSC::JSGlobalObject::init):
(JSC::JSGlobalObject::putDirectVirtual):
(JSC::JSGlobalObject::reset):
(JSC):
(JSC::JSGlobalObject::haveABadTime):
(JSC::JSGlobalObject::createThrowTypeError):
(JSC::JSGlobalObject::resetPrototype):
(JSC::JSGlobalObject::addStaticGlobals):
(JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope):
(JSC::JSGlobalObject::createProgramCodeBlock):
(JSC::JSGlobalObject::createEvalCodeBlock):

runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::create):
(JSGlobalObject):
(JSC::JSGlobalObject::finishCreation):
(JSC::JSGlobalObject::vm):
(JSC::JSGlobalObject::createStructure):
(JSC::ExecState::dynamicGlobalObject):
(JSC::constructEmptyArray):
(DynamicGlobalObjectScope):

runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncProtoSetter):

runtime/JSLock.cpp:

(JSC::JSLockHolder::JSLockHolder):
(JSC::JSLockHolder::init):
(JSC::JSLockHolder::~JSLockHolder):
(JSC::JSLock::JSLock):
(JSC::JSLock::willDestroyGlobalData):
(JSC::JSLock::lock):
(JSC::JSLock::unlock):
(JSC::JSLock::DropAllLocks::DropAllLocks):
(JSC::JSLock::DropAllLocks::~DropAllLocks):

runtime/JSLock.h:

(JSC):
(JSLockHolder):
(JSLock):
(JSC::JSLock::vm):
(DropAllLocks):

runtime/JSNameScope.h:

(JSC::JSNameScope::createStructure):
(JSC::JSNameScope::finishCreation):
(JSC::JSNameScope::JSNameScope):

runtime/JSNotAnObject.h:

(JSC::JSNotAnObject::JSNotAnObject):
(JSC::JSNotAnObject::create):
(JSC::JSNotAnObject::createStructure):

runtime/JSONObject.cpp:

(JSC::JSONObject::JSONObject):
(JSC::JSONObject::finishCreation):
(Holder):
(JSC::Stringifier::Stringifier):
(JSC::Stringifier::stringify):
(JSC::Stringifier::toJSON):
(JSC::Stringifier::appendStringifiedValue):
(JSC::Stringifier::Holder::Holder):
(JSC::Stringifier::Holder::appendNextProperty):
(JSC::Walker::Walker):
(JSC::Walker::walk):
(JSC::JSONProtoFuncParse):
(JSC::JSONProtoFuncStringify):
(JSC::JSONStringify):

runtime/JSONObject.h:

(JSC::JSONObject::createStructure):

runtime/JSObject.cpp:

(JSC::JSObject::put):
(JSC::JSObject::putByIndex):
(JSC::JSObject::enterDictionaryIndexingModeWhenArrayStorageAlreadyExists):
(JSC::JSObject::enterDictionaryIndexingMode):
(JSC::JSObject::notifyPresenceOfIndexedAccessors):
(JSC::JSObject::createInitialIndexedStorage):
(JSC::JSObject::createInitialUndecided):
(JSC::JSObject::createInitialInt32):
(JSC::JSObject::createInitialDouble):
(JSC::JSObject::createInitialContiguous):
(JSC::JSObject::createArrayStorage):
(JSC::JSObject::createInitialArrayStorage):
(JSC::JSObject::convertUndecidedToInt32):
(JSC::JSObject::convertUndecidedToDouble):
(JSC::JSObject::convertUndecidedToContiguous):
(JSC::JSObject::constructConvertedArrayStorageWithoutCopyingElements):
(JSC::JSObject::convertUndecidedToArrayStorage):
(JSC::JSObject::convertInt32ToDouble):
(JSC::JSObject::convertInt32ToContiguous):
(JSC::JSObject::convertInt32ToArrayStorage):
(JSC::JSObject::genericConvertDoubleToContiguous):
(JSC::JSObject::convertDoubleToContiguous):
(JSC::JSObject::rageConvertDoubleToContiguous):
(JSC::JSObject::convertDoubleToArrayStorage):
(JSC::JSObject::convertContiguousToArrayStorage):
(JSC::JSObject::convertUndecidedForValue):
(JSC::JSObject::convertInt32ForValue):
(JSC::JSObject::setIndexQuicklyToUndecided):
(JSC::JSObject::convertInt32ToDoubleOrContiguousWhilePerformingSetIndex):
(JSC::JSObject::convertDoubleToContiguousWhilePerformingSetIndex):
(JSC::JSObject::ensureInt32Slow):
(JSC::JSObject::ensureDoubleSlow):
(JSC::JSObject::ensureContiguousSlow):
(JSC::JSObject::rageEnsureContiguousSlow):
(JSC::JSObject::ensureArrayStorageSlow):
(JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
(JSC::JSObject::switchToSlowPutArrayStorage):
(JSC::JSObject::putDirectVirtual):
(JSC::JSObject::setPrototype):
(JSC::JSObject::setPrototypeWithCycleCheck):
(JSC::JSObject::putDirectAccessor):
(JSC::JSObject::deleteProperty):
(JSC::JSObject::getPropertySpecificValue):
(JSC::JSObject::getOwnNonIndexPropertyNames):
(JSC::JSObject::seal):
(JSC::JSObject::freeze):
(JSC::JSObject::preventExtensions):
(JSC::JSObject::reifyStaticFunctionsForDelete):
(JSC::JSObject::removeDirect):
(JSC::JSObject::putIndexedDescriptor):
(JSC::JSObject::defineOwnIndexedProperty):
(JSC::JSObject::allocateSparseIndexMap):
(JSC::JSObject::putByIndexBeyondVectorLengthWithoutAttributes):
(JSC::JSObject::putByIndexBeyondVectorLengthWithArrayStorage):
(JSC::JSObject::putByIndexBeyondVectorLength):
(JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
(JSC::JSObject::putDirectIndexBeyondVectorLength):
(JSC::JSObject::putDirectNativeFunction):
(JSC::JSObject::increaseVectorLength):
(JSC::JSObject::ensureLengthSlow):
(JSC::JSObject::growOutOfLineStorage):
(JSC::JSObject::getOwnPropertyDescriptor):
(JSC::putDescriptor):
(JSC::JSObject::putDirectMayBeIndex):
(JSC::DefineOwnPropertyScope::DefineOwnPropertyScope):
(JSC::DefineOwnPropertyScope::~DefineOwnPropertyScope):
(DefineOwnPropertyScope):
(JSC::JSObject::defineOwnNonIndexProperty):

runtime/JSObject.h:

(JSObject):
(JSC::JSObject::putByIndexInline):
(JSC::JSObject::putDirectIndex):
(JSC::JSObject::setIndexQuickly):
(JSC::JSObject::initializeIndex):
(JSC::JSObject::getDirect):
(JSC::JSObject::getDirectOffset):
(JSC::JSObject::putDirect):
(JSC::JSObject::isSealed):
(JSC::JSObject::isFrozen):
(JSC::JSObject::flattenDictionaryObject):
(JSC::JSObject::ensureInt32):
(JSC::JSObject::ensureDouble):
(JSC::JSObject::ensureContiguous):
(JSC::JSObject::rageEnsureContiguous):
(JSC::JSObject::ensureArrayStorage):
(JSC::JSObject::finishCreation):
(JSC::JSObject::createStructure):
(JSC::JSObject::ensureLength):
(JSC::JSNonFinalObject::createStructure):
(JSC::JSNonFinalObject::JSNonFinalObject):
(JSC::JSNonFinalObject::finishCreation):
(JSC::JSFinalObject::createStructure):
(JSC::JSFinalObject::finishCreation):
(JSC::JSFinalObject::JSFinalObject):
(JSC::JSFinalObject::create):
(JSC::JSObject::setButterfly):
(JSC::JSObject::JSObject):
(JSC::JSObject::inlineGetOwnPropertySlot):
(JSC::JSObject::putDirectInternal):
(JSC::JSObject::setStructureAndReallocateStorageIfNecessary):
(JSC::JSObject::putOwnDataProperty):
(JSC::JSObject::putDirectWithoutTransition):
(JSC):

runtime/JSPropertyNameIterator.cpp:

(JSC::JSPropertyNameIterator::JSPropertyNameIterator):
(JSC::JSPropertyNameIterator::create):

runtime/JSPropertyNameIterator.h:

(JSC::JSPropertyNameIterator::createStructure):
(JSC::JSPropertyNameIterator::setCachedStructure):
(JSC::JSPropertyNameIterator::setCachedPrototypeChain):
(JSC::JSPropertyNameIterator::finishCreation):
(JSC::StructureRareData::setEnumerationCache):

runtime/JSProxy.cpp:

(JSC::JSProxy::setTarget):

runtime/JSProxy.h:

(JSC::JSProxy::create):
(JSC::JSProxy::createStructure):
(JSC::JSProxy::JSProxy):
(JSC::JSProxy::finishCreation):
(JSProxy):

runtime/JSScope.cpp:

(JSC::executeResolveOperations):
(JSC::JSScope::resolveContainingScopeInternal):
(JSC::JSScope::resolveWithBase):
(JSC::JSScope::resolveWithThis):
(JSC::JSScope::resolvePut):

runtime/JSScope.h:

(JSScope):
(JSC::JSScope::JSScope):
(JSC::JSScope::vm):
(JSC::ExecState::vm):

runtime/JSSegmentedVariableObject.h:

(JSC::JSSegmentedVariableObject::JSSegmentedVariableObject):
(JSC::JSSegmentedVariableObject::finishCreation):

runtime/JSString.cpp:

(JSC::JSRopeString::RopeBuilder::expand):
(JSC::StringObject::create):

runtime/JSString.h:

(JSC):
(JSString):
(JSC::JSString::JSString):
(JSC::JSString::finishCreation):
(JSC::JSString::create):
(JSC::JSString::createHasOtherOwner):
(JSC::JSString::createStructure):
(JSRopeString):
(JSC::JSRopeString::RopeBuilder::RopeBuilder):
(JSC::JSRopeString::RopeBuilder::append):
(RopeBuilder):
(JSC::JSRopeString::JSRopeString):
(JSC::JSRopeString::finishCreation):
(JSC::JSRopeString::append):
(JSC::JSRopeString::createNull):
(JSC::JSRopeString::create):
(JSC::jsEmptyString):
(JSC::jsSingleCharacterString):
(JSC::jsSingleCharacterSubstring):
(JSC::jsNontrivialString):
(JSC::jsString):
(JSC::jsSubstring):
(JSC::jsSubstring8):
(JSC::jsOwnedString):
(JSC::jsStringBuilder):
(JSC::inlineJSValueNotStringtoString):

runtime/JSStringJoiner.cpp:

(JSC::JSStringJoiner::build):

runtime/JSSymbolTableObject.h:

(JSC::JSSymbolTableObject::JSSymbolTableObject):
(JSC::JSSymbolTableObject::finishCreation):
(JSC::symbolTablePut):
(JSC::symbolTablePutWithAttributes):

runtime/JSVariableObject.h:

(JSC::JSVariableObject::JSVariableObject):

runtime/JSWithScope.h:

(JSC::JSWithScope::create):
(JSC::JSWithScope::createStructure):
(JSC::JSWithScope::JSWithScope):

runtime/JSWrapperObject.h:

(JSWrapperObject):
(JSC::JSWrapperObject::createStructure):
(JSC::JSWrapperObject::JSWrapperObject):
(JSC::JSWrapperObject::setInternalValue):

runtime/LiteralParser.cpp:

(JSC::::tryJSONPParse):
(JSC::::makeIdentifier):
(JSC::::parse):

runtime/Lookup.cpp:

(JSC::HashTable::createTable):
(JSC::setUpStaticFunctionSlot):

runtime/Lookup.h:

(JSC::HashTable::initializeIfNeeded):
(JSC::HashTable::entry):
(JSC::HashTable::begin):
(JSC::HashTable::end):
(HashTable):
(JSC::lookupPut):

runtime/MathObject.cpp:

(JSC::MathObject::MathObject):
(JSC::MathObject::finishCreation):
(JSC::mathProtoFuncSin):

runtime/MathObject.h:

(JSC::MathObject::createStructure):

runtime/MemoryStatistics.cpp:
runtime/MemoryStatistics.h:
runtime/NameConstructor.cpp:

(JSC::NameConstructor::finishCreation):
(JSC::constructPrivateName):

runtime/NameConstructor.h:

(JSC::NameConstructor::createStructure):

runtime/NameInstance.cpp:

(JSC::NameInstance::NameInstance):

runtime/NameInstance.h:

(JSC::NameInstance::createStructure):
(JSC::NameInstance::create):
(NameInstance):
(JSC::NameInstance::finishCreation):

runtime/NamePrototype.cpp:

(JSC::NamePrototype::NamePrototype):
(JSC::NamePrototype::finishCreation):

runtime/NamePrototype.h:

(JSC::NamePrototype::createStructure):

runtime/NativeErrorConstructor.h:

(JSC::NativeErrorConstructor::createStructure):
(JSC::NativeErrorConstructor::finishCreation):

runtime/NativeErrorPrototype.cpp:

(JSC::NativeErrorPrototype::finishCreation):

runtime/NumberConstructor.cpp:

(JSC::NumberConstructor::finishCreation):
(JSC::constructWithNumberConstructor):

runtime/NumberConstructor.h:

(JSC::NumberConstructor::createStructure):

runtime/NumberObject.cpp:

(JSC::NumberObject::NumberObject):
(JSC::NumberObject::finishCreation):
(JSC::constructNumber):

runtime/NumberObject.h:

(NumberObject):
(JSC::NumberObject::create):
(JSC::NumberObject::createStructure):

runtime/NumberPrototype.cpp:

(JSC::NumberPrototype::NumberPrototype):
(JSC::NumberPrototype::finishCreation):
(JSC::integerValueToString):
(JSC::numberProtoFuncToString):

runtime/NumberPrototype.h:

(JSC::NumberPrototype::createStructure):

runtime/ObjectConstructor.cpp:

(JSC::ObjectConstructor::finishCreation):
(JSC::objectConstructorGetOwnPropertyDescriptor):
(JSC::objectConstructorSeal):
(JSC::objectConstructorFreeze):
(JSC::objectConstructorPreventExtensions):
(JSC::objectConstructorIsSealed):
(JSC::objectConstructorIsFrozen):

runtime/ObjectConstructor.h:

(JSC::ObjectConstructor::createStructure):
(JSC::constructEmptyObject):

runtime/ObjectPrototype.cpp:

(JSC::ObjectPrototype::ObjectPrototype):
(JSC::ObjectPrototype::finishCreation):
(JSC::objectProtoFuncToString):

runtime/ObjectPrototype.h:

(JSC::ObjectPrototype::createStructure):

runtime/Operations.cpp:

(JSC::jsTypeStringForValue):

runtime/Operations.h:

(JSC):
(JSC::jsString):
(JSC::jsStringFromArguments):
(JSC::normalizePrototypeChainForChainAccess):
(JSC::normalizePrototypeChain):

runtime/PropertyMapHashTable.h:

(JSC::PropertyMapEntry::PropertyMapEntry):
(JSC::PropertyTable::createStructure):
(PropertyTable):
(JSC::PropertyTable::copy):

runtime/PropertyNameArray.h:

(JSC::PropertyNameArray::PropertyNameArray):
(JSC::PropertyNameArray::vm):
(JSC::PropertyNameArray::addKnownUnique):
(PropertyNameArray):

runtime/PropertyTable.cpp:

(JSC::PropertyTable::create):
(JSC::PropertyTable::clone):
(JSC::PropertyTable::PropertyTable):

runtime/PrototypeMap.cpp:

(JSC::PrototypeMap::emptyObjectStructureForPrototype):

runtime/RegExp.cpp:

(JSC::RegExp::RegExp):
(JSC::RegExp::finishCreation):
(JSC::RegExp::createWithoutCaching):
(JSC::RegExp::create):
(JSC::RegExp::compile):
(JSC::RegExp::compileIfNecessary):
(JSC::RegExp::match):
(JSC::RegExp::compileMatchOnly):
(JSC::RegExp::compileIfNecessaryMatchOnly):

runtime/RegExp.h:

(JSC):
(RegExp):
(JSC::RegExp::createStructure):

runtime/RegExpCache.cpp:

(JSC::RegExpCache::lookupOrCreate):
(JSC::RegExpCache::RegExpCache):
(JSC::RegExpCache::addToStrongCache):

runtime/RegExpCache.h:

(RegExpCache):

runtime/RegExpCachedResult.cpp:

(JSC::RegExpCachedResult::lastResult):
(JSC::RegExpCachedResult::setInput):

runtime/RegExpCachedResult.h:

(JSC::RegExpCachedResult::RegExpCachedResult):
(JSC::RegExpCachedResult::record):

runtime/RegExpConstructor.cpp:

(JSC::RegExpConstructor::RegExpConstructor):
(JSC::RegExpConstructor::finishCreation):
(JSC::constructRegExp):

runtime/RegExpConstructor.h:

(JSC::RegExpConstructor::createStructure):
(RegExpConstructor):
(JSC::RegExpConstructor::performMatch):

runtime/RegExpMatchesArray.cpp:

(JSC::RegExpMatchesArray::RegExpMatchesArray):
(JSC::RegExpMatchesArray::create):
(JSC::RegExpMatchesArray::finishCreation):
(JSC::RegExpMatchesArray::reifyAllProperties):

runtime/RegExpMatchesArray.h:

(RegExpMatchesArray):
(JSC::RegExpMatchesArray::createStructure):

runtime/RegExpObject.cpp:

(JSC::RegExpObject::RegExpObject):
(JSC::RegExpObject::finishCreation):
(JSC::RegExpObject::match):

runtime/RegExpObject.h:

(JSC::RegExpObject::create):
(JSC::RegExpObject::setRegExp):
(JSC::RegExpObject::setLastIndex):
(JSC::RegExpObject::createStructure):

runtime/RegExpPrototype.cpp:

(JSC::regExpProtoFuncCompile):

runtime/RegExpPrototype.h:

(JSC::RegExpPrototype::createStructure):

runtime/SmallStrings.cpp:

(JSC::SmallStrings::initializeCommonStrings):
(JSC::SmallStrings::createEmptyString):
(JSC::SmallStrings::createSingleCharacterString):
(JSC::SmallStrings::initialize):

runtime/SmallStrings.h:

(JSC):
(JSC::SmallStrings::singleCharacterString):
(SmallStrings):

runtime/SparseArrayValueMap.cpp:

(JSC::SparseArrayValueMap::SparseArrayValueMap):
(JSC::SparseArrayValueMap::finishCreation):
(JSC::SparseArrayValueMap::create):
(JSC::SparseArrayValueMap::createStructure):
(JSC::SparseArrayValueMap::putDirect):
(JSC::SparseArrayEntry::put):

runtime/SparseArrayValueMap.h:
runtime/StrictEvalActivation.cpp:

(JSC::StrictEvalActivation::StrictEvalActivation):

runtime/StrictEvalActivation.h:

(JSC::StrictEvalActivation::create):
(JSC::StrictEvalActivation::createStructure):

runtime/StringConstructor.cpp:

(JSC::StringConstructor::finishCreation):

runtime/StringConstructor.h:

(JSC::StringConstructor::createStructure):

runtime/StringObject.cpp:

(JSC::StringObject::StringObject):
(JSC::StringObject::finishCreation):
(JSC::constructString):

runtime/StringObject.h:

(JSC::StringObject::create):
(JSC::StringObject::createStructure):
(StringObject):

runtime/StringPrototype.cpp:

(JSC::StringPrototype::StringPrototype):
(JSC::StringPrototype::finishCreation):
(JSC::removeUsingRegExpSearch):
(JSC::replaceUsingRegExpSearch):
(JSC::stringProtoFuncMatch):
(JSC::stringProtoFuncSearch):
(JSC::stringProtoFuncSplit):

runtime/StringPrototype.h:

(JSC::StringPrototype::createStructure):

runtime/StringRecursionChecker.h:

(JSC::StringRecursionChecker::performCheck):
(JSC::StringRecursionChecker::~StringRecursionChecker):

runtime/Structure.cpp:

(JSC::StructureTransitionTable::add):
(JSC::Structure::Structure):
(JSC::Structure::materializePropertyMap):
(JSC::Structure::despecifyDictionaryFunction):
(JSC::Structure::addPropertyTransition):
(JSC::Structure::removePropertyTransition):
(JSC::Structure::changePrototypeTransition):
(JSC::Structure::despecifyFunctionTransition):
(JSC::Structure::attributeChangeTransition):
(JSC::Structure::toDictionaryTransition):
(JSC::Structure::toCacheableDictionaryTransition):
(JSC::Structure::toUncacheableDictionaryTransition):
(JSC::Structure::sealTransition):
(JSC::Structure::freezeTransition):
(JSC::Structure::preventExtensionsTransition):
(JSC::Structure::takePropertyTableOrCloneIfPinned):
(JSC::Structure::nonPropertyTransition):
(JSC::Structure::isSealed):
(JSC::Structure::isFrozen):
(JSC::Structure::flattenDictionaryStructure):
(JSC::Structure::addPropertyWithoutTransition):
(JSC::Structure::removePropertyWithoutTransition):
(JSC::Structure::allocateRareData):
(JSC::Structure::cloneRareDataFrom):
(JSC::Structure::copyPropertyTable):
(JSC::Structure::copyPropertyTableForPinning):
(JSC::Structure::get):
(JSC::Structure::despecifyFunction):
(JSC::Structure::despecifyAllFunctions):
(JSC::Structure::putSpecificValue):
(JSC::Structure::createPropertyMap):
(JSC::Structure::getPropertyNamesFromStructure):
(JSC::Structure::prototypeChainMayInterceptStoreTo):

runtime/Structure.h:

(Structure):
(JSC::Structure::finishCreation):
(JSC::Structure::setPrototypeWithoutTransition):
(JSC::Structure::setGlobalObject):
(JSC::Structure::setObjectToStringValue):
(JSC::Structure::materializePropertyMapIfNecessary):
(JSC::Structure::materializePropertyMapIfNecessaryForPinning):
(JSC::Structure::setPreviousID):

runtime/StructureChain.cpp:

(JSC::StructureChain::StructureChain):

runtime/StructureChain.h:

(JSC::StructureChain::create):
(JSC::StructureChain::createStructure):
(JSC::StructureChain::finishCreation):
(StructureChain):

runtime/StructureInlines.h:

(JSC::Structure::create):
(JSC::Structure::createStructure):
(JSC::Structure::get):
(JSC::Structure::setEnumerationCache):
(JSC::Structure::prototypeChain):
(JSC::Structure::propertyTable):

runtime/StructureRareData.cpp:

(JSC::StructureRareData::createStructure):
(JSC::StructureRareData::create):
(JSC::StructureRareData::clone):
(JSC::StructureRareData::StructureRareData):

runtime/StructureRareData.h:

(StructureRareData):

runtime/StructureRareDataInlines.h:

(JSC::StructureRareData::setPreviousID):
(JSC::StructureRareData::setObjectToStringValue):

runtime/StructureTransitionTable.h:

(StructureTransitionTable):
(JSC::StructureTransitionTable::setSingleTransition):

runtime/SymbolTable.h:

(JSC::SharedSymbolTable::create):
(JSC::SharedSymbolTable::createStructure):
(JSC::SharedSymbolTable::SharedSymbolTable):

runtime/VM.cpp: Copied from Source/JavaScriptCore/runtime/JSGlobalData.cpp.

(JSC::VM::VM):
(JSC::VM::~VM):
(JSC::VM::createContextGroup):
(JSC::VM::create):
(JSC::VM::createLeaked):
(JSC::VM::sharedInstanceExists):
(JSC::VM::sharedInstance):
(JSC::VM::sharedInstanceInternal):
(JSC::VM::getHostFunction):
(JSC::VM::ClientData::~ClientData):
(JSC::VM::resetDateCache):
(JSC::VM::startSampling):
(JSC::VM::stopSampling):
(JSC::VM::discardAllCode):
(JSC::VM::dumpSampleData):
(JSC::VM::addSourceProviderCache):
(JSC::VM::clearSourceProviderCaches):
(JSC::VM::releaseExecutableMemory):
(JSC::releaseExecutableMemory):
(JSC::VM::gatherConservativeRoots):
(JSC::VM::addRegExpToTrace):
(JSC::VM::dumpRegExpTrace):

runtime/VM.h: Copied from Source/JavaScriptCore/runtime/JSGlobalData.h.

(VM):
(JSC::VM::isSharedInstance):
(JSC::VM::usingAPI):
(JSC::VM::isInitializingObject):
(JSC::VM::setInitializingObjectClass):
(JSC::WeakSet::heap):

runtime/WriteBarrier.h:

(JSC):
(JSC::WriteBarrierBase::set):
(JSC::WriteBarrierBase::setMayBeNull):
(JSC::WriteBarrierBase::setEarlyValue):
(JSC::WriteBarrier::WriteBarrier):

testRegExp.cpp:

(GlobalObject):
(GlobalObject::create):
(GlobalObject::createStructure):
(GlobalObject::finishCreation):
(main):
(testOneRegExp):
(parseRegExpLine):
(runFromFiles):
(realMain):

yarr/YarrInterpreter.h:

(BytecodePattern):

yarr/YarrJIT.cpp:

(YarrGenerator):
(JSC::Yarr::YarrGenerator::compile):
(JSC::Yarr::jitCompile):

yarr/YarrJIT.h:

(JSC):

../WebCore:

ForwardingHeaders/runtime/JSGlobalData.h: Removed.
ForwardingHeaders/runtime/VM.h: Copied from Source/WebCore/ForwardingHeaders/runtime/JSGlobalData.h.
WebCore.exp.in:
WebCore.order:
WebCore.vcxproj/WebCore.vcxproj:
WebCore.vcxproj/WebCore.vcxproj.filters:
bindings/js/DOMObjectHashTableMap.cpp:

(WebCore::DOMObjectHashTableMap::mapFor):

bindings/js/DOMObjectHashTableMap.h:

(JSC):
(DOMObjectHashTableMap):

bindings/js/DOMWrapperWorld.cpp:

(WebCore::DOMWrapperWorld::DOMWrapperWorld):
(WebCore::DOMWrapperWorld::~DOMWrapperWorld):
(WebCore::normalWorld):
(WebCore::mainThreadNormalWorld):

bindings/js/DOMWrapperWorld.h:

(WebCore::DOMWrapperWorld::create):
(WebCore::DOMWrapperWorld::vm):
(DOMWrapperWorld):
(WebCore):

bindings/js/GCController.cpp:

(WebCore::collect):
(WebCore::GCController::garbageCollectSoon):
(WebCore::GCController::garbageCollectNow):
(WebCore::GCController::setJavaScriptGarbageCollectorTimerEnabled):
(WebCore::GCController::discardAllCompiledCode):

bindings/js/IDBBindingUtilities.cpp:

(WebCore::get):
(WebCore::set):
(WebCore::deserializeIDBValue):
(WebCore::deserializeIDBValueBuffer):
(WebCore::idbKeyToScriptValue):

bindings/js/JSCallbackData.h:

(WebCore::JSCallbackData::JSCallbackData):

bindings/js/JSCustomSQLStatementErrorCallback.cpp:

(WebCore::JSSQLStatementErrorCallback::handleEvent):

bindings/js/JSCustomXPathNSResolver.cpp:

(WebCore::JSCustomXPathNSResolver::JSCustomXPathNSResolver):
(WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):

bindings/js/JSDOMBinding.cpp:

(WebCore::getHashTableForGlobalData):
(WebCore::reportException):
(WebCore::cacheDOMStructure):

bindings/js/JSDOMBinding.h:

(WebCore::DOMConstructorObject::createStructure):
(WebCore::DOMConstructorWithDocument::finishCreation):
(WebCore::getDOMStructure):
(WebCore::setInlineCachedWrapper):
(WebCore):
(WebCore::jsStringWithCache):

bindings/js/JSDOMGlobalObject.cpp:

(WebCore::JSDOMGlobalObject::JSDOMGlobalObject):
(WebCore::JSDOMGlobalObject::finishCreation):

bindings/js/JSDOMGlobalObject.h:

(JSDOMGlobalObject):
(WebCore::JSDOMGlobalObject::createStructure):
(WebCore::getDOMConstructor):

bindings/js/JSDOMWindowBase.cpp:

(WebCore::JSDOMWindowBase::JSDOMWindowBase):
(WebCore::JSDOMWindowBase::finishCreation):
(WebCore::JSDOMWindowBase::updateDocument):
(WebCore::JSDOMWindowBase::commonVM):

bindings/js/JSDOMWindowBase.h:

(JSDOMWindowBase):
(WebCore::JSDOMWindowBase::createStructure):

bindings/js/JSDOMWindowCustom.cpp:

(WebCore::JSDOMWindow::setLocation):
(WebCore::DialogHandler::dialogCreated):
(WebCore::DialogHandler::returnValue):

bindings/js/JSDOMWindowShell.cpp:

(WebCore::JSDOMWindowShell::JSDOMWindowShell):
(WebCore::JSDOMWindowShell::finishCreation):
(WebCore::JSDOMWindowShell::setWindow):

bindings/js/JSDOMWindowShell.h:

(JSDOMWindowShell):
(WebCore::JSDOMWindowShell::create):
(WebCore::JSDOMWindowShell::createStructure):

bindings/js/JSDOMWrapper.h:

(WebCore::JSDOMWrapper::JSDOMWrapper):

bindings/js/JSDeviceMotionEventCustom.cpp:

(WebCore::createAccelerationObject):
(WebCore::createRotationRateObject):

bindings/js/JSDictionary.cpp:

(WebCore::JSDictionary::convertValue):

bindings/js/JSDictionary.h:

(WebCore::JSDictionary::JSDictionary):

bindings/js/JSErrorHandler.cpp:

(WebCore::JSErrorHandler::handleEvent):

bindings/js/JSEventListener.cpp:

(WebCore::JSEventListener::handleEvent):

bindings/js/JSEventListener.h:

(WebCore::JSEventListener::setWrapper):
(WebCore::JSEventListener::jsFunction):

bindings/js/JSHTMLDocumentCustom.cpp:

(WebCore::JSHTMLDocument::all):
(WebCore::JSHTMLDocument::setAll):

bindings/js/JSHTMLTemplateElementCustom.cpp:

(WebCore::JSHTMLTemplateElement::content):

bindings/js/JSHistoryCustom.cpp:

(WebCore::JSHistory::state):

bindings/js/JSImageConstructor.cpp:

(WebCore::JSImageConstructor::finishCreation):

bindings/js/JSImageConstructor.h:

(WebCore::JSImageConstructor::createStructure):

bindings/js/JSImageDataCustom.cpp:

(WebCore::toJS):

bindings/js/JSInjectedScriptHostCustom.cpp:

(WebCore::InjectedScriptHost::nodeAsScriptValue):
(WebCore::JSInjectedScriptHost::functionDetails):
(WebCore::getJSListenerFunctions):
(WebCore::JSInjectedScriptHost::getEventListeners):
(WebCore::JSInjectedScriptHost::inspect):

bindings/js/JSLazyEventListener.cpp:

(WebCore::JSLazyEventListener::initializeJSFunction):

bindings/js/JSMessageEventCustom.cpp:

(WebCore::JSMessageEvent::data):
(WebCore::handleInitMessageEvent):

bindings/js/JSMutationCallback.cpp:

(WebCore::JSMutationCallback::call):

bindings/js/JSMutationObserverCustom.cpp:

(WebCore::JSMutationObserverConstructor::constructJSMutationObserver):

bindings/js/JSNodeFilterCondition.cpp:

(WebCore::JSNodeFilterCondition::JSNodeFilterCondition):

bindings/js/JSNodeFilterCondition.h:

(WebCore::JSNodeFilterCondition::create):
(JSNodeFilterCondition):

bindings/js/JSNodeFilterCustom.cpp:

(WebCore::toNodeFilter):

bindings/js/JSPopStateEventCustom.cpp:

(WebCore::cacheState):

bindings/js/JSRequestAnimationFrameCallbackCustom.cpp:

(WebCore::JSRequestAnimationFrameCallback::handleEvent):

bindings/js/JSSQLResultSetRowListCustom.cpp:

(WebCore::JSSQLResultSetRowList::item):

bindings/js/JSWorkerContextBase.cpp:

(WebCore::JSWorkerContextBase::JSWorkerContextBase):
(WebCore::JSWorkerContextBase::finishCreation):

bindings/js/JSWorkerContextBase.h:

(WebCore::JSWorkerContextBase::createStructure):
(JSWorkerContextBase):

bindings/js/PageScriptDebugServer.cpp:

(WebCore::PageScriptDebugServer::recompileAllJSFunctions):

bindings/js/ScheduledAction.cpp:

(WebCore::ScheduledAction::ScheduledAction):
(WebCore::ScheduledAction::executeFunctionInContext):

bindings/js/ScheduledAction.h:

(WebCore::ScheduledAction::ScheduledAction):

bindings/js/ScriptCachedFrameData.cpp:

(WebCore::ScriptCachedFrameData::ScriptCachedFrameData):
(WebCore::ScriptCachedFrameData::restore):
(WebCore::ScriptCachedFrameData::clear):

bindings/js/ScriptCallStackFactory.cpp:

(WebCore::createScriptCallStack):
(WebCore::createScriptArguments):

bindings/js/ScriptController.cpp:

(WebCore::ScriptController::createWindowShell):
(WebCore::ScriptController::evaluateInWorld):
(WebCore::ScriptController::createWorld):
(WebCore::ScriptController::getAllWorlds):
(WebCore::ScriptController::clearWindowShell):
(WebCore::ScriptController::initScript):
(WebCore::ScriptController::updateDocument):
(WebCore::ScriptController::cacheableBindingRootObject):
(WebCore::ScriptController::bindingRootObject):
(WebCore::ScriptController::clearScriptObjects):
(WebCore::ScriptController::shouldBypassMainWorldContentSecurityPolicy):

bindings/js/ScriptControllerMac.mm:

(WebCore::ScriptController::windowScriptObject):

bindings/js/ScriptDebugServer.cpp:

(WebCore::ScriptDebugServer::dispatchDidPause):

bindings/js/ScriptEventListener.cpp:

(WebCore::eventListenerHandlerBody):
(WebCore::eventListenerHandler):
(WebCore::eventListenerHandlerLocation):

bindings/js/ScriptFunctionCall.cpp:

(WebCore::ScriptFunctionCall::call):
(WebCore::ScriptCallback::call):

bindings/js/ScriptGCEvent.cpp:

(WebCore::ScriptGCEvent::getHeapSize):

bindings/js/ScriptObject.cpp:

(WebCore::ScriptObject::ScriptObject):
(WebCore::ScriptGlobalObject::set):

bindings/js/ScriptState.h:

(WebCore):

bindings/js/ScriptValue.cpp:

(WebCore::ScriptValue::deserialize):

bindings/js/ScriptValue.h:

(WebCore::ScriptValue::ScriptValue):

bindings/js/ScriptWrappable.h:

(JSC):
(ScriptWrappable):

bindings/js/ScriptWrappableInlines.h:

(WebCore::ScriptWrappable::setWrapper):

bindings/js/SerializedScriptValue.cpp:

(WebCore::CloneDeserializer::readTerminal):
(WebCore::SerializedScriptValue::deserializeForInspector):
(WebCore::SerializedScriptValue::maybeThrowExceptionIfSerializationFailed):

bindings/js/WebCoreJSClientData.h:

(WebCoreJSClientData):
(WebCore::initNormalWorldClientData):

bindings/js/WorkerScriptController.cpp:

(WebCore::WorkerScriptController::WorkerScriptController):
(WebCore::WorkerScriptController::~WorkerScriptController):
(WebCore::WorkerScriptController::initScript):
(WebCore::WorkerScriptController::evaluate):
(WebCore::WorkerScriptController::scheduleExecutionTermination):
(WebCore::WorkerScriptController::isExecutionTerminating):
(WebCore::WorkerScriptController::disableEval):

bindings/js/WorkerScriptController.h:

(JSC):
(WebCore::WorkerScriptController::vm):
(WorkerScriptController):

bindings/js/WorkerScriptDebugServer.cpp:

(WebCore::WorkerScriptDebugServer::recompileAllJSFunctions):

bindings/objc/WebScriptObject.mm:

(+[WebScriptObject _convertValueToObjcValue:JSC::originRootObject:rootObject:]):

bindings/scripts/CodeGeneratorJS.pm:

(GenerateHeader):
(GenerateImplementation):
(GenerateCallbackImplementation):
(JSValueToNative):
(GenerateConstructorDeclaration):
(GenerateConstructorHelperMethods):

bindings/scripts/test/JS/JSFloat64Array.cpp:

(WebCore::getJSFloat64ArrayConstructorTable):
(WebCore::JSFloat64ArrayConstructor::finishCreation):
(WebCore::getJSFloat64ArrayPrototypeTable):
(WebCore::getJSFloat64ArrayTable):
(WebCore::JSFloat64Array::finishCreation):
(WebCore::JSFloat64Array::createPrototype):

bindings/scripts/test/JS/JSFloat64Array.h:

(WebCore::JSFloat64Array::create):
(WebCore::JSFloat64Array::createStructure):
(JSFloat64Array):
(WebCore::JSFloat64ArrayPrototype::create):
(WebCore::JSFloat64ArrayPrototype::createStructure):
(WebCore::JSFloat64ArrayPrototype::JSFloat64ArrayPrototype):
(WebCore::JSFloat64ArrayConstructor::createStructure):

bindings/scripts/test/JS/JSTestActiveDOMObject.cpp:

(WebCore::JSTestActiveDOMObjectConstructor::finishCreation):
(WebCore::JSTestActiveDOMObject::finishCreation):
(WebCore::JSTestActiveDOMObject::createPrototype):

bindings/scripts/test/JS/JSTestActiveDOMObject.h:

(WebCore::JSTestActiveDOMObject::create):
(WebCore::JSTestActiveDOMObject::createStructure):
(JSTestActiveDOMObject):
(WebCore::JSTestActiveDOMObjectPrototype::create):
(WebCore::JSTestActiveDOMObjectPrototype::createStructure):
(WebCore::JSTestActiveDOMObjectPrototype::JSTestActiveDOMObjectPrototype):
(WebCore::JSTestActiveDOMObjectConstructor::createStructure):

bindings/scripts/test/JS/JSTestCallback.cpp:

(WebCore::JSTestCallback::callbackWithNoParam):
(WebCore::JSTestCallback::callbackWithClass1Param):
(WebCore::JSTestCallback::callbackWithClass2Param):
(WebCore::JSTestCallback::callbackWithStringList):
(WebCore::JSTestCallback::callbackWithBoolean):
(WebCore::JSTestCallback::callbackRequiresThisToPass):

bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp:

(WebCore::JSTestCustomNamedGetterConstructor::finishCreation):
(WebCore::JSTestCustomNamedGetter::finishCreation):
(WebCore::JSTestCustomNamedGetter::createPrototype):

bindings/scripts/test/JS/JSTestCustomNamedGetter.h:

(WebCore::JSTestCustomNamedGetter::create):
(WebCore::JSTestCustomNamedGetter::createStructure):
(JSTestCustomNamedGetter):
(WebCore::JSTestCustomNamedGetterPrototype::create):
(WebCore::JSTestCustomNamedGetterPrototype::createStructure):
(WebCore::JSTestCustomNamedGetterPrototype::JSTestCustomNamedGetterPrototype):
(WebCore::JSTestCustomNamedGetterConstructor::createStructure):

bindings/scripts/test/JS/JSTestEventConstructor.cpp:

(WebCore::JSTestEventConstructorConstructor::finishCreation):
(WebCore::JSTestEventConstructor::finishCreation):
(WebCore::JSTestEventConstructor::createPrototype):

bindings/scripts/test/JS/JSTestEventConstructor.h:

(WebCore::JSTestEventConstructor::create):
(WebCore::JSTestEventConstructor::createStructure):
(JSTestEventConstructor):
(WebCore::JSTestEventConstructorPrototype::create):
(WebCore::JSTestEventConstructorPrototype::createStructure):
(WebCore::JSTestEventConstructorPrototype::JSTestEventConstructorPrototype):
(WebCore::JSTestEventConstructorConstructor::createStructure):

bindings/scripts/test/JS/JSTestEventTarget.cpp:

(WebCore::JSTestEventTargetConstructor::finishCreation):
(WebCore::JSTestEventTarget::finishCreation):
(WebCore::JSTestEventTarget::createPrototype):

bindings/scripts/test/JS/JSTestEventTarget.h:

(WebCore::JSTestEventTarget::create):
(WebCore::JSTestEventTarget::createStructure):
(JSTestEventTarget):
(WebCore::JSTestEventTargetPrototype::create):
(WebCore::JSTestEventTargetPrototype::createStructure):
(WebCore::JSTestEventTargetPrototype::JSTestEventTargetPrototype):
(WebCore::JSTestEventTargetConstructor::createStructure):

bindings/scripts/test/JS/JSTestException.cpp:

(WebCore::JSTestExceptionConstructor::finishCreation):
(WebCore::JSTestException::finishCreation):
(WebCore::JSTestException::createPrototype):

bindings/scripts/test/JS/JSTestException.h:

(WebCore::JSTestException::create):
(WebCore::JSTestException::createStructure):
(JSTestException):
(WebCore::JSTestExceptionPrototype::create):
(WebCore::JSTestExceptionPrototype::createStructure):
(WebCore::JSTestExceptionPrototype::JSTestExceptionPrototype):
(WebCore::JSTestExceptionConstructor::createStructure):

bindings/scripts/test/JS/JSTestInterface.cpp:

(WebCore::JSTestInterfaceConstructor::finishCreation):
(WebCore::JSTestInterface::finishCreation):
(WebCore::JSTestInterface::createPrototype):

bindings/scripts/test/JS/JSTestInterface.h:

(WebCore::JSTestInterface::create):
(WebCore::JSTestInterface::createStructure):
(JSTestInterface):
(WebCore::JSTestInterfacePrototype::create):
(WebCore::JSTestInterfacePrototype::createStructure):
(WebCore::JSTestInterfacePrototype::JSTestInterfacePrototype):
(WebCore::JSTestInterfaceConstructor::createStructure):

bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp:

(WebCore::JSTestMediaQueryListListenerConstructor::finishCreation):
(WebCore::JSTestMediaQueryListListener::finishCreation):
(WebCore::JSTestMediaQueryListListener::createPrototype):
(WebCore::jsTestMediaQueryListListenerPrototypeFunctionMethod):

bindings/scripts/test/JS/JSTestMediaQueryListListener.h:

(WebCore::JSTestMediaQueryListListener::create):
(WebCore::JSTestMediaQueryListListener::createStructure):
(JSTestMediaQueryListListener):
(WebCore::JSTestMediaQueryListListenerPrototype::create):
(WebCore::JSTestMediaQueryListListenerPrototype::createStructure):
(WebCore::JSTestMediaQueryListListenerPrototype::JSTestMediaQueryListListenerPrototype):
(WebCore::JSTestMediaQueryListListenerConstructor::createStructure):

bindings/scripts/test/JS/JSTestNamedConstructor.cpp:

(WebCore::JSTestNamedConstructorConstructor::finishCreation):
(WebCore::JSTestNamedConstructorNamedConstructor::finishCreation):
(WebCore::JSTestNamedConstructor::finishCreation):
(WebCore::JSTestNamedConstructor::createPrototype):

bindings/scripts/test/JS/JSTestNamedConstructor.h:

(WebCore::JSTestNamedConstructor::create):
(WebCore::JSTestNamedConstructor::createStructure):
(JSTestNamedConstructor):
(WebCore::JSTestNamedConstructorPrototype::create):
(WebCore::JSTestNamedConstructorPrototype::createStructure):
(WebCore::JSTestNamedConstructorPrototype::JSTestNamedConstructorPrototype):
(WebCore::JSTestNamedConstructorConstructor::createStructure):
(WebCore::JSTestNamedConstructorNamedConstructor::createStructure):

bindings/scripts/test/JS/JSTestNode.cpp:

(WebCore::JSTestNodeConstructor::finishCreation):
(WebCore::JSTestNode::finishCreation):
(WebCore::JSTestNode::createPrototype):

bindings/scripts/test/JS/JSTestNode.h:

(WebCore::JSTestNode::create):
(WebCore::JSTestNode::createStructure):
(JSTestNode):
(WebCore::JSTestNodePrototype::create):
(WebCore::JSTestNodePrototype::createStructure):
(WebCore::JSTestNodePrototype::JSTestNodePrototype):
(WebCore::JSTestNodeConstructor::createStructure):

bindings/scripts/test/JS/JSTestObj.cpp:

(WebCore::JSTestObjConstructor::finishCreation):
(WebCore::JSTestObj::finishCreation):
(WebCore::JSTestObj::createPrototype):
(WebCore::jsTestObjCachedAttribute1):
(WebCore::jsTestObjCachedAttribute2):
(WebCore::setJSTestObjConditionalAttr4Constructor):
(WebCore::setJSTestObjConditionalAttr5Constructor):
(WebCore::setJSTestObjConditionalAttr6Constructor):
(WebCore::setJSTestObjAnyAttribute):
(WebCore::setJSTestObjReplaceableAttribute):

bindings/scripts/test/JS/JSTestObj.h:

(WebCore::JSTestObj::create):
(WebCore::JSTestObj::createStructure):
(JSTestObj):
(WebCore::JSTestObjPrototype::create):
(WebCore::JSTestObjPrototype::createStructure):
(WebCore::JSTestObjPrototype::JSTestObjPrototype):
(WebCore::JSTestObjConstructor::createStructure):

bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp:

(WebCore::JSTestOverloadedConstructorsConstructor::finishCreation):
(WebCore::JSTestOverloadedConstructors::finishCreation):
(WebCore::JSTestOverloadedConstructors::createPrototype):

bindings/scripts/test/JS/JSTestOverloadedConstructors.h:

(WebCore::JSTestOverloadedConstructors::create):
(WebCore::JSTestOverloadedConstructors::createStructure):
(JSTestOverloadedConstructors):
(WebCore::JSTestOverloadedConstructorsPrototype::create):
(WebCore::JSTestOverloadedConstructorsPrototype::createStructure):
(WebCore::JSTestOverloadedConstructorsPrototype::JSTestOverloadedConstructorsPrototype):
(WebCore::JSTestOverloadedConstructorsConstructor::createStructure):

bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp:

(WebCore::JSTestSerializedScriptValueInterfaceConstructor::finishCreation):
(WebCore::JSTestSerializedScriptValueInterface::finishCreation):
(WebCore::JSTestSerializedScriptValueInterface::createPrototype):
(WebCore::jsTestSerializedScriptValueInterfaceCachedValue):
(WebCore::jsTestSerializedScriptValueInterfaceCachedReadonlyValue):

bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.h:

(WebCore::JSTestSerializedScriptValueInterface::create):
(WebCore::JSTestSerializedScriptValueInterface::createStructure):
(JSTestSerializedScriptValueInterface):
(WebCore::JSTestSerializedScriptValueInterfacePrototype::create):
(WebCore::JSTestSerializedScriptValueInterfacePrototype::createStructure):
(WebCore::JSTestSerializedScriptValueInterfacePrototype::JSTestSerializedScriptValueInterfacePrototype):
(WebCore::JSTestSerializedScriptValueInterfaceConstructor::createStructure):

bindings/scripts/test/JS/JSTestTypedefs.cpp:

(WebCore::JSTestTypedefsConstructor::finishCreation):
(WebCore::JSTestTypedefs::finishCreation):
(WebCore::JSTestTypedefs::createPrototype):

bindings/scripts/test/JS/JSTestTypedefs.h:

(WebCore::JSTestTypedefs::create):
(WebCore::JSTestTypedefs::createStructure):
(JSTestTypedefs):
(WebCore::JSTestTypedefsPrototype::create):
(WebCore::JSTestTypedefsPrototype::createStructure):
(WebCore::JSTestTypedefsPrototype::JSTestTypedefsPrototype):
(WebCore::JSTestTypedefsConstructor::createStructure):

bridge/c/CRuntimeObject.h:

(JSC::Bindings::CRuntimeObject::createStructure):

bridge/c/c_instance.cpp:

(JSC::Bindings::CRuntimeMethod::create):
(JSC::Bindings::CRuntimeMethod::createStructure):
(JSC::Bindings::CRuntimeMethod::finishCreation):

bridge/jsc/BridgeJSC.cpp:

(JSC::Bindings::Instance::createRuntimeObject):

bridge/objc/ObjCRuntimeObject.h:

(JSC::Bindings::ObjCRuntimeObject::createStructure):

bridge/objc/objc_instance.mm:

(ObjCRuntimeMethod::create):
(ObjCRuntimeMethod::createStructure):
(ObjCRuntimeMethod::finishCreation):

bridge/objc/objc_runtime.h:

(JSC::Bindings::ObjcFallbackObjectImp::createStructure):

bridge/objc/objc_runtime.mm:

(JSC::Bindings::ObjcFallbackObjectImp::ObjcFallbackObjectImp):
(JSC::Bindings::ObjcFallbackObjectImp::finishCreation):

bridge/qt/qt_instance.cpp:

(JSC::Bindings::QtRuntimeObject::createStructure):
(JSC::Bindings::QtInstance::~QtInstance):
(JSC::Bindings::QtInstance::getQtInstance):

bridge/runtime_array.cpp:

(JSC::RuntimeArray::RuntimeArray):
(JSC::RuntimeArray::finishCreation):

bridge/runtime_array.h:

(JSC::RuntimeArray::create):
(JSC::RuntimeArray::createStructure):
(RuntimeArray):

bridge/runtime_method.cpp:

(JSC::RuntimeMethod::finishCreation):

bridge/runtime_method.h:

(JSC::RuntimeMethod::create):
(JSC::RuntimeMethod::createStructure):
(RuntimeMethod):

bridge/runtime_object.cpp:

(JSC::Bindings::RuntimeObject::RuntimeObject):
(JSC::Bindings::RuntimeObject::finishCreation):

bridge/runtime_object.h:

(JSC::Bindings::RuntimeObject::createStructure):

bridge/runtime_root.cpp:

(JSC::Bindings::RootObject::RootObject):
(JSC::Bindings::RootObject::gcProtect):
(JSC::Bindings::RootObject::gcUnprotect):
(JSC::Bindings::RootObject::updateGlobalObject):
(JSC::Bindings::RootObject::addRuntimeObject):

bridge/runtime_root.h:

(RootObject):

dom/Node.cpp:
dom/Node.h:

(JSC):

dom/ScriptExecutionContext.cpp:

(WebCore::ScriptExecutionContext::vm):

dom/ScriptExecutionContext.h:

(JSC):
(ScriptExecutionContext):

html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::createImageBuffer):

html/HTMLImageLoader.cpp:

(WebCore::HTMLImageLoader::notifyFinished):

inspector/ScriptArguments.cpp:

(WebCore::ScriptArguments::ScriptArguments):

loader/icon/IconDatabaseBase.cpp:

(WebCore):
(WebCore::iconDatabase):
(WebCore::setGlobalIconDatabase):

platform/qt/MemoryUsageSupportQt.cpp:

(WebCore::memoryUsageKB):
(WebCore::actualMemoryUsageKB):

platform/win/ClipboardUtilitiesWin.cpp:

(WebCore::createGlobalData):

plugins/PluginView.cpp:

(WebCore::PluginView::start):
(WebCore::PluginView::stop):
(WebCore::PluginView::performRequest):
(WebCore::PluginView::npObject):
(WebCore::PluginView::privateBrowsingStateChanged):

plugins/blackberry/PluginViewBlackBerry.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::platformStart):
(WebCore::PluginView::getWindowInfo):

plugins/efl/PluginViewEfl.cpp:

(WebCore::PluginView::dispatchNPEvent):

plugins/gtk/PluginViewGtk.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::handleKeyboardEvent):
(WebCore::PluginView::handleMouseEvent):
(WebCore::PluginView::setNPWindowIfNeeded):
(WebCore::PluginView::platformStart):

plugins/mac/PluginViewMac.mm:

(WebCore::PluginView::platformStart):

plugins/qt/PluginViewQt.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::setNPWindowIfNeeded):

plugins/win/PluginViewWin.cpp:

(WebCore::PluginView::dispatchNPEvent):
(WebCore::PluginView::handleKeyboardEvent):
(WebCore::PluginView::handleMouseEvent):
(WebCore::PluginView::setNPWindowRect):

testing/js/WebCoreTestSupport.cpp:

(WebCoreTestSupport::injectInternalsObject):

xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::dropProtection):

../WebKit/blackberry:

Api/BlackBerryGlobal.cpp:

(BlackBerry::WebKit::clearMemoryCaches):

WebKitSupport/AboutData.cpp:
WebKitSupport/DumpRenderTreeSupport.cpp:

(DumpRenderTreeSupport::javaScriptObjectsCount):

../WebKit/efl:

WebCoreSupport/DumpRenderTreeSupportEfl.cpp:

(DumpRenderTreeSupportEfl::javaScriptObjectsCount):

../WebKit/gtk:

WebCoreSupport/DumpRenderTreeSupportGtk.cpp:

(DumpRenderTreeSupportGtk::gcCountJavascriptObjects):

../WebKit/mac:

Misc/WebCoreStatistics.mm:

(+[WebCoreStatistics javaScriptObjectsCount]):
(+[WebCoreStatistics javaScriptGlobalObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedGlobalObjectsCount]):
(+[WebCoreStatistics javaScriptProtectedObjectTypeCounts]):
(+[WebCoreStatistics javaScriptObjectTypeCounts]):
(+[WebCoreStatistics shouldPrintExceptions]):
(+[WebCoreStatistics setShouldPrintExceptions:]):
(+[WebCoreStatistics memoryStatistics]):
(+[WebCoreStatistics javaScriptReferencedObjectsCount]):

Plugins/Hosted/NetscapePluginHostProxy.mm:

(identifierFromIdentifierRep):

Plugins/Hosted/NetscapePluginInstanceProxy.h:

(LocalObjectMap):

Plugins/Hosted/NetscapePluginInstanceProxy.mm:

(WebKit::NetscapePluginInstanceProxy::LocalObjectMap::idForObject):
(WebKit::NetscapePluginInstanceProxy::getWindowNPObject):
(WebKit::NetscapePluginInstanceProxy::getPluginElementNPObject):
(WebKit::NetscapePluginInstanceProxy::evaluate):
(WebKit::NetscapePluginInstanceProxy::addValueToArray):

Plugins/Hosted/ProxyInstance.mm:

(WebKit::ProxyRuntimeMethod::create):
(WebKit::ProxyRuntimeMethod::createStructure):
(WebKit::ProxyRuntimeMethod::finishCreation):
(WebKit::ProxyInstance::getPropertyNames):

Plugins/Hosted/ProxyRuntimeObject.h:

(WebKit::ProxyRuntimeObject::create):
(WebKit::ProxyRuntimeObject::createStructure):

Plugins/WebNetscapePluginStream.mm:

(WebNetscapePluginStream::wantsAllStreams):

Plugins/WebNetscapePluginView.mm:

(-[WebNetscapePluginView sendEvent:isDrawRect:]):
(-[WebNetscapePluginView privateBrowsingModeDidChange]):
(-[WebNetscapePluginView setWindowIfNecessary]):
(-[WebNetscapePluginView createPluginScriptableObject]):
(-[WebNetscapePluginView getFormValue:]):
(-[WebNetscapePluginView evaluateJavaScriptPluginRequest:]):
(-[WebNetscapePluginView webFrame:didFinishLoadWithReason:]):
(-[WebNetscapePluginView loadPluginRequest:]):
(-[WebNetscapePluginView _printedPluginBitmap]):

Plugins/WebPluginController.mm:

(+[WebPluginController plugInViewWithArguments:fromPluginPackage:]):
(-[WebPluginController stopOnePlugin:]):
(-[WebPluginController destroyOnePlugin:]):
(-[WebPluginController startAllPlugins]):
(-[WebPluginController addPlugin:]):

WebKit.order:
WebView/WebScriptDebugDelegate.mm:

(-[WebScriptCallFrame scopeChain]):
(-[WebScriptCallFrame evaluateWebScript:]):

WebView/WebScriptDebugger.mm:

(WebScriptDebugger::WebScriptDebugger):

../WebKit/qt:

WebCoreSupport/DumpRenderTreeSupportQt.cpp:

(DumpRenderTreeSupportQt::javaScriptObjectsCount):

WebCoreSupport/QWebFrameAdapter.cpp:

(QWebFrameAdapter::addToJavaScriptWindowObject):

../WebKit/win:

WebCoreStatistics.cpp:

(WebCoreStatistics::javaScriptObjectsCount):
(WebCoreStatistics::javaScriptGlobalObjectsCount):
(WebCoreStatistics::javaScriptProtectedObjectsCount):
(WebCoreStatistics::javaScriptProtectedGlobalObjectsCount):
(WebCoreStatistics::javaScriptProtectedObjectTypeCounts):

WebJavaScriptCollector.cpp:

(WebJavaScriptCollector::objectCount):

../WebKit2:

Shared/linux/WebMemorySamplerLinux.cpp:

(WebKit::WebMemorySampler::sampleWebKit):

Shared/mac/WebMemorySampler.mac.mm:

(WebKit::WebMemorySampler::sampleWebKit):

WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::javaScriptObjectsCount):

WebProcess/Plugins/Netscape/JSNPMethod.cpp:

(WebKit::JSNPMethod::finishCreation):

WebProcess/Plugins/Netscape/JSNPMethod.h:

(WebKit::JSNPMethod::create):
(JSNPMethod):
(WebKit::JSNPMethod::createStructure):

WebProcess/Plugins/Netscape/JSNPObject.cpp:

(WebKit::JSNPObject::JSNPObject):
(WebKit::JSNPObject::finishCreation):
(WebKit::JSNPObject::callMethod):
(WebKit::JSNPObject::callObject):
(WebKit::JSNPObject::callConstructor):
(WebKit::JSNPObject::put):
(WebKit::JSNPObject::deleteProperty):
(WebKit::JSNPObject::getOwnPropertyNames):
(WebKit::JSNPObject::propertyGetter):

WebProcess/Plugins/Netscape/JSNPObject.h:

(WebKit::JSNPObject::create):
(WebKit::JSNPObject::createStructure):

WebProcess/Plugins/Netscape/NPJSObject.cpp:

(WebKit::NPJSObject::create):
(WebKit::NPJSObject::initialize):

WebProcess/Plugins/Netscape/NPJSObject.h:

(JSC):
(NPJSObject):

WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp:

(WebKit::NPRuntimeObjectMap::getOrCreateNPObject):
(WebKit::NPRuntimeObjectMap::convertJSValueToNPVariant):
(WebKit::NPRuntimeObjectMap::evaluate):

WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h:

(JSC):
(NPRuntimeObjectMap):

WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::windowScriptNPObject):
(WebKit::PluginView::pluginElementNPObject):

WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::runJavaScriptInMainFrame):

WebProcess/WebProcess.cpp:

(WebKit::WebProcess::getWebCoreStatistics):

Location:

trunk/Source/JavaScriptCore/jit

Files:

: 29 edited

ClosureCallStubRoutine.cpp (modified) (2 diffs)
ClosureCallStubRoutine.h (modified) (1 diff)
ExecutableAllocator.cpp (modified) (2 diffs)
ExecutableAllocator.h (modified) (3 diffs)
ExecutableAllocatorFixedVMPool.cpp (modified) (3 diffs)
GCAwareJITStubRoutine.cpp (modified) (7 diffs)
GCAwareJITStubRoutine.h (modified) (4 diffs)
JIT.cpp (modified) (9 diffs)
JIT.h (modified) (7 diffs)
JITCall.cpp (modified) (6 diffs)
JITCall32_64.cpp (modified) (6 diffs)
JITCode.h (modified) (2 diffs)
JITDriver.h (modified) (4 diffs)
JITExceptions.cpp (modified) (4 diffs)
JITExceptions.h (modified) (2 diffs)
JITInlines.h (modified) (2 diffs)
JITOpcodes.cpp (modified) (6 diffs)
JITOpcodes32_64.cpp (modified) (12 diffs)
JITPropertyAccess.cpp (modified) (22 diffs)
JITPropertyAccess32_64.cpp (modified) (18 diffs)
JITStubs.cpp (modified) (59 diffs)
JITStubs.h (modified) (11 diffs)
JITThunks.cpp (modified) (3 diffs)
JITThunks.h (modified) (2 diffs)
JITWriteBarrier.h (modified) (3 diffs)
SpecializedThunkJIT.h (modified) (2 diffs)
ThunkGenerator.h (modified) (1 diff)
ThunkGenerators.cpp (modified) (24 diffs)
ThunkGenerators.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed

trunk/Source/JavaScriptCore/jit/ClosureCallStubRoutine.cpp

-              r139541
+              r148696
 #include "Executable.h"
 #include "Heap.h"
 #include "JSGlobalData.h"
+#include "VM.h"
 #include "Operations.h"
 #include "SlotVisitor.h"
 …
 ClosureCallStubRoutine::ClosureCallStubRoutine(
     const MacroAssemblerCodeRef& code, JSGlobalData& globalData, const JSCell* owner,
+    const MacroAssemblerCodeRef& code, VM& vm, const JSCell* owner,
     Structure* structure, ExecutableBase* executable, const CodeOrigin& codeOrigin)
     : GCAwareJITStubRoutine(code, globalData, true)
     , m_structure(globalData, owner, structure)
     , m_executable(globalData, owner, executable)
+    : GCAwareJITStubRoutine(code, vm, true)
+    , m_structure(vm, owner, structure)
+    , m_executable(vm, owner, executable)
     , m_codeOrigin(codeOrigin)
+{

trunk/Source/JavaScriptCore/jit/ClosureCallStubRoutine.h

r135336	r148696
39	39	public:
40	40	ClosureCallStubRoutine(
41		const MacroAssemblerCodeRef&, ~~JSGlobalData~~&, const JSCell* owner,
	41	const MacroAssemblerCodeRef&, VM&, const JSCell* owner,
42	42	Structure, ExecutableBase, const CodeOrigin&);
43	43

trunk/Source/JavaScriptCore/jit/ExecutableAllocator.cpp

-              r140584
+              r148696
 #endif
 ExecutableAllocator::ExecutableAllocator(JSGlobalData&)
+ExecutableAllocator::ExecutableAllocator(VM&)
 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
     : m_allocator(adoptPtr(new  DemandExecutableAllocator()))
 …
+}
 PassRefPtr<ExecutableMemoryHandle> ExecutableAllocator::allocate(JSGlobalData&, size_t sizeInBytes, void* ownerUID, JITCompilationEffort effort)
+PassRefPtr<ExecutableMemoryHandle> ExecutableAllocator::allocate(VM&, size_t sizeInBytes, void* ownerUID, JITCompilationEffort effort)
+{
     RefPtr<ExecutableMemoryHandle> result = allocator()->allocate(sizeInBytes, ownerUID);

trunk/Source/JavaScriptCore/jit/ExecutableAllocator.h

-              r140584
+              r148696
 namespace JSC {
 class JSGlobalData;
 void releaseExecutableMemory(JSGlobalData&);
+class VM;
+void releaseExecutableMemory(VM&);
 static const unsigned jitAllocationGranule = 32;
 …
 public:
     ExecutableAllocator(JSGlobalData&);
+    ExecutableAllocator(VM&);
     ~ExecutableAllocator();
 …
 #endif
     PassRefPtr<ExecutableMemoryHandle> allocate(JSGlobalData&, size_t sizeInBytes, void* ownerUID, JITCompilationEffort);
+    PassRefPtr<ExecutableMemoryHandle> allocate(VM&, size_t sizeInBytes, void* ownerUID, JITCompilationEffort);
 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE)

trunk/Source/JavaScriptCore/jit/ExecutableAllocatorFixedVMPool.cpp

r140594	r148696
121	121	}
122	122
123		ExecutableAllocator::ExecutableAllocator(~~JSGlobalData~~&)
	123	ExecutableAllocator::ExecutableAllocator(VM&)
124	124	{
125	125	ASSERT(allocator);
…	…
157	157	}
158	158
159		PassRefPtr<ExecutableMemoryHandle> ExecutableAllocator::allocate(~~JSGlobalData& globalData~~, size_t sizeInBytes, void* ownerUID, JITCompilationEffort effort)
	159	PassRefPtr<ExecutableMemoryHandle> ExecutableAllocator::allocate(VM& vm, size_t sizeInBytes, void* ownerUID, JITCompilationEffort effort)
160	160	{
161	161	RefPtr<ExecutableMemoryHandle> result = allocator->allocate(sizeInBytes, ownerUID);
…	…
163	163	if (effort == JITCompilationCanFail)
164	164	return result;
165		releaseExecutableMemory(~~globalData~~);
	165	releaseExecutableMemory(vm);
166	166	result = allocator->allocate(sizeInBytes, ownerUID);
167	167	RELEASE_ASSERT(result);

trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.cpp

-              r140619
+              r148696
 #include "Heap.h"
 #include "JSGlobalData.h"
+#include "VM.h"
 #include "Operations.h"
 #include "SlotVisitor.h"
 …
 GCAwareJITStubRoutine::GCAwareJITStubRoutine(
     const MacroAssemblerCodeRef& code, JSGlobalData& globalData, bool isClosureCall)
+    const MacroAssemblerCodeRef& code, VM& vm, bool isClosureCall)
     : JITStubRoutine(code)
     , m_mayBeExecuting(false)
 …
     , m_isClosureCall(isClosureCall)
+{
     globalData.heap.m_jitStubRoutines.add(this);
+    vm.heap.m_jitStubRoutines.add(this);
+}
 …
 MarkingGCAwareJITStubRoutineWithOneObject::MarkingGCAwareJITStubRoutineWithOneObject(
     const MacroAssemblerCodeRef& code, JSGlobalData& globalData, const JSCell* owner,
+    const MacroAssemblerCodeRef& code, VM& vm, const JSCell* owner,
     JSCell* object)
     : GCAwareJITStubRoutine(code, globalData)
     , m_object(globalData, owner, object)
+    : GCAwareJITStubRoutine(code, vm)
+    , m_object(vm, owner, object)
+{
+}
 …
 PassRefPtr<JITStubRoutine> createJITStubRoutine(
     const MacroAssemblerCodeRef& code,
     JSGlobalData& globalData,
+    VM& vm,
     const JSCell*,
     bool makesCalls)
 …
     return static_pointer_cast<JITStubRoutine>(
         adoptRef(new GCAwareJITStubRoutine(code, globalData)));
+        adoptRef(new GCAwareJITStubRoutine(code, vm)));
+}
 PassRefPtr<JITStubRoutine> createJITStubRoutine(
     const MacroAssemblerCodeRef& code,
     JSGlobalData& globalData,
+    VM& vm,
     const JSCell* owner,
     bool makesCalls,
 …
     return static_pointer_cast<JITStubRoutine>(
         adoptRef(new MarkingGCAwareJITStubRoutineWithOneObject(code, globalData, owner, object)));
+        adoptRef(new MarkingGCAwareJITStubRoutineWithOneObject(code, vm, owner, object)));
+}

trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.h

-              r135336
+              r148696
 class GCAwareJITStubRoutine : public JITStubRoutine {
 public:
     GCAwareJITStubRoutine(const MacroAssemblerCodeRef&, JSGlobalData&, bool isClosureCall = false);
+    GCAwareJITStubRoutine(const MacroAssemblerCodeRef&, VM&, bool isClosureCall = false);
     virtual ~GCAwareJITStubRoutine();
 …
 public:
     MarkingGCAwareJITStubRoutineWithOneObject(
         const MacroAssemblerCodeRef&, JSGlobalData&, const JSCell* owner, JSCell*);
+        const MacroAssemblerCodeRef&, VM&, const JSCell* owner, JSCell*);
     virtual ~MarkingGCAwareJITStubRoutineWithOneObject();
 …
 // PassRefPtr<JITStubRoutine> createJITStubRoutine(
 //    const MacroAssemblerCodeRef& code,
 //    JSGlobalData& globalData,
+//    VM& vm,
 //    const JSCell* owner,
 //    bool makesCalls,
 …
 PassRefPtr<JITStubRoutine> createJITStubRoutine(
     const MacroAssemblerCodeRef&, JSGlobalData&, const JSCell* owner, bool makesCalls);
+    const MacroAssemblerCodeRef&, VM&, const JSCell* owner, bool makesCalls);
 PassRefPtr<JITStubRoutine> createJITStubRoutine(
     const MacroAssemblerCodeRef&, JSGlobalData&, const JSCell* owner, bool makesCalls,
+    const MacroAssemblerCodeRef&, VM&, const JSCell* owner, bool makesCalls,
     JSCell*);

trunk/Source/JavaScriptCore/jit/JIT.cpp

-              r148639
+              r148696
+}
 JIT::JIT(JSGlobalData* globalData, CodeBlock* codeBlock)
     : m_interpreter(globalData->interpreter)
     , m_globalData(globalData)
+JIT::JIT(VM* vm, CodeBlock* codeBlock)
+    : m_interpreter(vm->interpreter)
+    , m_vm(vm)
     , m_codeBlock(codeBlock)
     , m_labels(codeBlock ? codeBlock->numberOfInstructions() : 0)
 …
 void JIT::emitWatchdogTimerCheck()
+{
     if (!m_globalData->watchdog.isEnabled())
+    if (!m_vm->watchdog.isEnabled())
         return;
     Jump skipCheck = branchTest8(Zero, AbsoluteAddress(m_globalData->watchdog.timerDidFireAddress()));
+    Jump skipCheck = branchTest8(Zero, AbsoluteAddress(m_vm->watchdog.timerDidFireAddress()));
     JITStubCall stubCall(this, cti_handle_watchdog_timer);
     stubCall.call();
 …
 #endif
     if (Options::showDisassembly() || m_globalData->m_perBytecodeProfiler)
+    if (Options::showDisassembly() || m_vm->m_perBytecodeProfiler)
         m_disassembler = adoptPtr(new JITDisassembler(m_codeBlock));
     if (m_globalData->m_perBytecodeProfiler) {
         m_compilation = m_globalData->m_perBytecodeProfiler->newCompilation(m_codeBlock, Profiler::Baseline);
         m_compilation->addProfiledBytecodes(*m_globalData->m_perBytecodeProfiler, m_codeBlock);
+    if (m_vm->m_perBytecodeProfiler) {
+        m_compilation = m_vm->m_perBytecodeProfiler->newCompilation(m_codeBlock, Profiler::Baseline);
+        m_compilation->addProfiledBytecodes(*m_vm->m_perBytecodeProfiler, m_codeBlock);
+    }
 …
         addPtr(TrustedImm32(m_codeBlock->m_numCalleeRegisters * sizeof(Register)), callFrameRegister, regT1);
         stackCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT1);
+        stackCheck = branchPtr(Below, AbsoluteAddress(m_vm->interpreter->stack().addressOfEnd()), regT1);
+    }
 …
         m_disassembler->setEndOfCode(label());
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock, effort);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock, effort);
     if (patchBuffer.didFailToAllocate())
         return JITCode();
 …
     CodeRef result = patchBuffer.finalizeCodeWithoutDisassembly();
     m_globalData->machineCodeBytesPerBytecodeWordForBaselineJIT.add(
+    m_vm->machineCodeBytesPerBytecodeWordForBaselineJIT.add(
         static_cast<double>(result.size()) /
         static_cast<double>(m_codeBlock->instructions().size()));
 …
+}
 void JIT::linkFor(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, JIT::CodePtr code, CallLinkInfo* callLinkInfo, JSGlobalData* globalData, CodeSpecializationKind kind)
+void JIT::linkFor(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, JIT::CodePtr code, CallLinkInfo* callLinkInfo, VM* vm, CodeSpecializationKind kind)
+{
     RepatchBuffer repatchBuffer(callerCodeBlock);
     ASSERT(!callLinkInfo->isLinked());
     callLinkInfo->callee.set(*globalData, callLinkInfo->hotPathBegin, callerCodeBlock->ownerExecutable(), callee);
     callLinkInfo->lastSeenCallee.set(*globalData, callerCodeBlock->ownerExecutable(), callee);
+    callLinkInfo->callee.set(*vm, callLinkInfo->hotPathBegin, callerCodeBlock->ownerExecutable(), callee);
+    callLinkInfo->lastSeenCallee.set(*vm, callerCodeBlock->ownerExecutable(), callee);
     repatchBuffer.relink(callLinkInfo->hotPathOther, code);
 …
                || callLinkInfo->callType == CallLinkInfo::CallVarargs);
         if (callLinkInfo->callType == CallLinkInfo::Call) {
             repatchBuffer.relink(callLinkInfo->callReturnLocation, globalData->getCTIStub(linkClosureCallGenerator).code());
+            repatchBuffer.relink(callLinkInfo->callReturnLocation, vm->getCTIStub(linkClosureCallGenerator).code());
             return;
+        }
         repatchBuffer.relink(callLinkInfo->callReturnLocation, globalData->getCTIStub(virtualCallGenerator).code());
+        repatchBuffer.relink(callLinkInfo->callReturnLocation, vm->getCTIStub(virtualCallGenerator).code());
         return;
+    }
     ASSERT(kind == CodeForConstruct);
     repatchBuffer.relink(callLinkInfo->callReturnLocation, globalData->getCTIStub(virtualConstructGenerator).code());
+    repatchBuffer.relink(callLinkInfo->callReturnLocation, vm->getCTIStub(virtualConstructGenerator).code());
+}
 …
     RepatchBuffer repatchBuffer(callerCodeBlock);
     repatchBuffer.relink(callLinkInfo->callReturnLocation, callerCodeBlock->globalData()->getCTIStub(virtualCallGenerator).code());
+    repatchBuffer.relink(callLinkInfo->callReturnLocation, callerCodeBlock->vm()->getCTIStub(virtualCallGenerator).code());
+}

trunk/Source/JavaScriptCore/jit/JIT.h

-              r148639
+              r148696
     public:
         static JITCode compile(JSGlobalData* globalData, CodeBlock* codeBlock, JITCompilationEffort effort, CodePtr* functionEntryArityCheck = 0)
+        {
             return JIT(globalData, codeBlock).privateCompile(functionEntryArityCheck, effort);
+        }
         static void compileClosureCall(JSGlobalData* globalData, CallLinkInfo* callLinkInfo, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, Structure* expectedStructure, ExecutableBase* expectedExecutable, MacroAssemblerCodePtr codePtr)
+        {
             JIT jit(globalData, callerCodeBlock);
+        static JITCode compile(VM* vm, CodeBlock* codeBlock, JITCompilationEffort effort, CodePtr* functionEntryArityCheck = 0)
+        {
+            return JIT(vm, codeBlock).privateCompile(functionEntryArityCheck, effort);
+        }
+        static void compileClosureCall(VM* vm, CallLinkInfo* callLinkInfo, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, Structure* expectedStructure, ExecutableBase* expectedExecutable, MacroAssemblerCodePtr codePtr)
+        {
+            JIT jit(vm, callerCodeBlock);
             jit.m_bytecodeOffset = callLinkInfo->codeOrigin.bytecodeIndex;
             jit.privateCompileClosureCall(callLinkInfo, calleeCodeBlock, expectedStructure, expectedExecutable, codePtr);
+        }
         static void compileGetByIdProto(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByIdProto(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompileGetByIdProto(stubInfo, structure, prototypeStructure, ident, slot, cachedOffset, returnAddress, callFrame);
+        }
         static void compileGetByIdSelfList(JSGlobalData* globalData, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByIdSelfList(VM* vm, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompileGetByIdSelfList(stubInfo, polymorphicStructures, currentIndex, structure, ident, slot, cachedOffset);
+        }
         static void compileGetByIdProtoList(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByIdProtoList(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompileGetByIdProtoList(stubInfo, prototypeStructureList, currentIndex, structure, prototypeStructure, ident, slot, cachedOffset, callFrame);
+        }
         static void compileGetByIdChainList(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByIdChainList(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructureList, int currentIndex, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompileGetByIdChainList(stubInfo, prototypeStructureList, currentIndex, structure, chain, count, ident, slot, cachedOffset, callFrame);
+        }
         static void compileGetByIdChain(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByIdChain(VM* vm, CallFrame* callFrame, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompileGetByIdChain(stubInfo, structure, chain, count, ident, slot, cachedOffset, returnAddress, callFrame);
+        }
         static void compilePutByIdTransition(JSGlobalData* globalData, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* oldStructure, Structure* newStructure, PropertyOffset cachedOffset, StructureChain* chain, ReturnAddressPtr returnAddress, bool direct)
+        {
             JIT jit(globalData, codeBlock);
+        static void compilePutByIdTransition(VM* vm, CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* oldStructure, Structure* newStructure, PropertyOffset cachedOffset, StructureChain* chain, ReturnAddressPtr returnAddress, bool direct)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = stubInfo->bytecodeIndex;
             jit.privateCompilePutByIdTransition(stubInfo, oldStructure, newStructure, cachedOffset, chain, returnAddress, direct);
+        }
         static void compileGetByVal(JSGlobalData* globalData, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
+        {
             JIT jit(globalData, codeBlock);
+        static void compileGetByVal(VM* vm, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = byValInfo->bytecodeIndex;
             jit.privateCompileGetByVal(byValInfo, returnAddress, arrayMode);
+        }
         static void compilePutByVal(JSGlobalData* globalData, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
+        {
             JIT jit(globalData, codeBlock);
+        static void compilePutByVal(VM* vm, CodeBlock* codeBlock, ByValInfo* byValInfo, ReturnAddressPtr returnAddress, JITArrayMode arrayMode)
+        {
+            JIT jit(vm, codeBlock);
             jit.m_bytecodeOffset = byValInfo->bytecodeIndex;
             jit.privateCompilePutByVal(byValInfo, returnAddress, arrayMode);
+        }
         static CodeRef compileCTINativeCall(JSGlobalData* globalData, NativeFunction func)
+        {
             if (!globalData->canUseJIT()) {
+        static CodeRef compileCTINativeCall(VM* vm, NativeFunction func)
+        {
+            if (!vm->canUseJIT()) {
 #if ENABLE(LLINT)
                 return CodeRef::createLLIntCodeRef(llint_native_call_trampoline);
 …
 #endif
+            }
             JIT jit(globalData, 0);
             return jit.privateCompileCTINativeCall(globalData, func);
+            JIT jit(vm, 0);
+            return jit.privateCompileCTINativeCall(vm, func);
+        }
 …
         static void patchPutByIdReplace(CodeBlock*, StructureStubInfo*, Structure*, PropertyOffset cachedOffset, ReturnAddressPtr, bool direct);
         static void compilePatchGetArrayLength(JSGlobalData* globalData, CodeBlock* codeBlock, ReturnAddressPtr returnAddress)
+        {
             JIT jit(globalData, codeBlock);
+        static void compilePatchGetArrayLength(VM* vm, CodeBlock* codeBlock, ReturnAddressPtr returnAddress)
+        {
+            JIT jit(vm, codeBlock);
 #if ENABLE(DFG_JIT)
             // Force profiling to be enabled during stub generation.
 …
+        }
         static void linkFor(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, CodePtr, CallLinkInfo*, JSGlobalData*, CodeSpecializationKind);
+        static void linkFor(JSFunction* callee, CodeBlock* callerCodeBlock, CodeBlock* calleeCodeBlock, CodePtr, CallLinkInfo*, VM*, CodeSpecializationKind);
         static void linkSlowCall(CodeBlock* callerCodeBlock, CallLinkInfo*);
     private:
         JIT(JSGlobalData*, CodeBlock* = 0);
+        JIT(VM*, CodeBlock* = 0);
         void privateCompileMainPass();
 …
         void privateCompilePutByVal(ByValInfo*, ReturnAddressPtr, JITArrayMode);
         Label privateCompileCTINativeCall(JSGlobalData*, bool isConstruct = false);
         CodeRef privateCompileCTINativeCall(JSGlobalData*, NativeFunction);
+        Label privateCompileCTINativeCall(VM*, bool isConstruct = false);
+        CodeRef privateCompileCTINativeCall(VM*, NativeFunction);
         void privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress);
 …
         Interpreter* m_interpreter;
         JSGlobalData* m_globalData;
+        VM* m_vm;
         CodeBlock* m_codeBlock;
 …
         RefPtr<Profiler::Compilation> m_compilation;
         WeakRandom m_randomGenerator;
         static CodeRef stringGetByValStubGenerator(JSGlobalData*);
+        static CodeRef stringGetByValStubGenerator(VM*);
 #if ENABLE(VALUE_PROFILER)

trunk/Source/JavaScriptCore/jit/JITCall.cpp

-              r145933
+              r148696
         // regT1: newCallFrame
         slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT1));
+        slowCase.append(branchPtr(Below, AbsoluteAddress(m_vm->interpreter->stack().addressOfEnd()), regT1));
         // Initialize ArgumentCount.
 …
     emitGetFromCallFrameHeader64(JSStack::Callee, regT0);
     emitNakedCall(m_globalData->getCTIStub(virtualCallGenerator).code());
+    emitNakedCall(m_vm->getCTIStub(virtualCallGenerator).code());
     sampleCodeBlock(m_codeBlock);
 …
     linkSlowCase(iter);
     m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(opcodeID == op_construct ? m_globalData->getCTIStub(linkConstructGenerator).code() : m_globalData->getCTIStub(linkCallGenerator).code());
+    m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(opcodeID == op_construct ? m_vm->getCTIStub(linkConstructGenerator).code() : m_vm->getCTIStub(linkCallGenerator).code());
     sampleCodeBlock(m_codeBlock);
 …
     Jump slow = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(call, FunctionPtr(codePtr.executableAddress()));
     patchBuffer.link(done, callLinkInfo->hotPathOther.labelAtOffset(0));
     patchBuffer.link(slow, CodeLocationLabel(m_globalData->getCTIStub(virtualCallGenerator).code()));
+    patchBuffer.link(slow, CodeLocationLabel(m_vm->getCTIStub(virtualCallGenerator).code()));
     RefPtr<ClosureCallStubRoutine> stubRoutine = adoptRef(new ClosureCallStubRoutine(
 …
                 codePtr.executableAddress(),
                 toCString(pointerDump(calleeCodeBlock)).data())),
         *m_globalData, m_codeBlock->ownerExecutable(), expectedStructure, expectedExecutable,
+        *m_vm, m_codeBlock->ownerExecutable(), expectedStructure, expectedExecutable,
         callLinkInfo->codeOrigin));
 …
         RepatchBuffer::startOfBranchPtrWithPatchOnRegister(callLinkInfo->hotPathBegin),
         CodeLocationLabel(stubRoutine->code().code()));
     repatchBuffer.relink(callLinkInfo->callReturnLocation, m_globalData->getCTIStub(virtualCallGenerator).code());
+    repatchBuffer.relink(callLinkInfo->callReturnLocation, m_vm->getCTIStub(virtualCallGenerator).code());
     callLinkInfo->stub = stubRoutine.release();

trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp

-              r145933
+              r148696
         // regT3: newCallFrame
         slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT3));
+        slowCase.append(branchPtr(Below, AbsoluteAddress(m_vm->interpreter->stack().addressOfEnd()), regT3));
         // Initialize ArgumentCount.
 …
     emitLoad(JSStack::Callee, regT1, regT0);
     emitNakedCall(m_globalData->getCTIStub(virtualCallGenerator).code());
+    emitNakedCall(m_vm->getCTIStub(virtualCallGenerator).code());
     sampleCodeBlock(m_codeBlock);
 …
     linkSlowCase(iter);
     m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(opcodeID == op_construct ? m_globalData->getCTIStub(linkConstructGenerator).code() : m_globalData->getCTIStub(linkCallGenerator).code());
+    m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(opcodeID == op_construct ? m_vm->getCTIStub(linkConstructGenerator).code() : m_vm->getCTIStub(linkCallGenerator).code());
     sampleCodeBlock(m_codeBlock);
 …
     Jump slow = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(call, FunctionPtr(codePtr.executableAddress()));
     patchBuffer.link(done, callLinkInfo->hotPathOther.labelAtOffset(0));
     patchBuffer.link(slow, CodeLocationLabel(m_globalData->getCTIStub(virtualCallGenerator).code()));
+    patchBuffer.link(slow, CodeLocationLabel(m_vm->getCTIStub(virtualCallGenerator).code()));
     RefPtr<ClosureCallStubRoutine> stubRoutine = adoptRef(new ClosureCallStubRoutine(
 …
                 codePtr.executableAddress(),
                 toCString(pointerDump(calleeCodeBlock)).data())),
         *m_globalData, m_codeBlock->ownerExecutable(), expectedStructure, expectedExecutable,
+        *m_vm, m_codeBlock->ownerExecutable(), expectedStructure, expectedExecutable,
         callLinkInfo->codeOrigin));
 …
         RepatchBuffer::startOfBranchPtrWithPatchOnRegister(callLinkInfo->hotPathBegin),
         CodeLocationLabel(stubRoutine->code().code()));
     repatchBuffer.relink(callLinkInfo->callReturnLocation, m_globalData->getCTIStub(virtualCallGenerator).code());
+    repatchBuffer.relink(callLinkInfo->callReturnLocation, m_vm->getCTIStub(virtualCallGenerator).code());
     callLinkInfo->stub = stubRoutine.release();

trunk/Source/JavaScriptCore/jit/JITCode.h

-              r140718
+              r148696
 #if ENABLE(JIT)
     class JSGlobalData;
+    class VM;
     class JSStack;
 #endif
 …
 #if ENABLE(JIT)
         // Execute the code!
         inline JSValue execute(JSStack* stack, CallFrame* callFrame, JSGlobalData* globalData)
+        {
             JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), stack, callFrame, 0, 0, globalData));
             return globalData->exception ? jsNull() : result;
+        inline JSValue execute(JSStack* stack, CallFrame* callFrame, VM* vm)
+        {
+            JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), stack, callFrame, 0, 0, vm));
+            return vm->exception ? jsNull() : result;
+        }
 #endif

trunk/Source/JavaScriptCore/jit/JITDriver.h

-              r133688
+              r148696
 inline bool jitCompileIfAppropriate(ExecState* exec, OwnPtr<CodeBlockType>& codeBlock, JITCode& jitCode, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
+{
     JSGlobalData& globalData = exec->globalData();
+    VM& vm = exec->vm();
     if (jitType == codeBlock->getJITType())
         return true;
     if (!globalData.canUseJIT())
+    if (!vm.canUseJIT())
         return true;
 …
             return false;
+        }
         jitCode = JIT::compile(&globalData, codeBlock.get(), effort);
+        jitCode = JIT::compile(&vm, codeBlock.get(), effort);
         if (!jitCode) {
             jitCode = oldJITCode;
 …
 inline bool jitCompileFunctionIfAppropriate(ExecState* exec, OwnPtr<FunctionCodeBlock>& codeBlock, JITCode& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, JITCode::JITType jitType, unsigned bytecodeIndex, JITCompilationEffort effort)
+{
     JSGlobalData& globalData = exec->globalData();
+    VM& vm = exec->vm();
     if (jitType == codeBlock->getJITType())
         return true;
     if (!globalData.canUseJIT())
+    if (!vm.canUseJIT())
         return true;
 …
             return false;
+        }
         jitCode = JIT::compile(&globalData, codeBlock.get(), effort, &jitCodeWithArityCheck);
+        jitCode = JIT::compile(&vm, codeBlock.get(), effort, &jitCodeWithArityCheck);
         if (!jitCode) {
             jitCode = oldJITCode;

trunk/Source/JavaScriptCore/jit/JITExceptions.cpp

-              r140718
+              r148696
 #include "Interpreter.h"
 #include "JSCJSValue.h"
 #include "JSGlobalData.h"
+#include "VM.h"
 #include "Operations.h"
 …
 namespace JSC {
 ExceptionHandler genericThrow(JSGlobalData* globalData, ExecState* callFrame, JSValue exceptionValue, unsigned vPCIndex)
+ExceptionHandler genericThrow(VM* vm, ExecState* callFrame, JSValue exceptionValue, unsigned vPCIndex)
+{
     RELEASE_ASSERT(exceptionValue);
     globalData->exception = JSValue();
     HandlerInfo* handler = globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex); // This may update callFrame & exceptionValue!
     globalData->exception = exceptionValue;
+    vm->exception = JSValue();
+    HandlerInfo* handler = vm->interpreter->throwException(callFrame, exceptionValue, vPCIndex); // This may update callFrame & exceptionValue!
+    vm->exception = exceptionValue;
     void* catchRoutine;
 …
         catchRoutine = FunctionPtr(LLInt::getCodePtr(ctiOpThrowNotCaught)).value();
     globalData->callFrameForThrow = callFrame;
     globalData->targetMachinePCForThrow = catchRoutine;
     globalData->targetInterpreterPCForThrow = catchPCForInterpreter;
+    vm->callFrameForThrow = callFrame;
+    vm->targetMachinePCForThrow = catchRoutine;
+    vm->targetInterpreterPCForThrow = catchPCForInterpreter;
     RELEASE_ASSERT(catchRoutine);
 …
+}
 ExceptionHandler jitThrow(JSGlobalData* globalData, ExecState* callFrame, JSValue exceptionValue, ReturnAddressPtr faultLocation)
+ExceptionHandler jitThrow(VM* vm, ExecState* callFrame, JSValue exceptionValue, ReturnAddressPtr faultLocation)
+{
     return genericThrow(globalData, callFrame, exceptionValue, callFrame->codeBlock()->bytecodeOffset(callFrame, faultLocation));
+    return genericThrow(vm, callFrame, exceptionValue, callFrame->codeBlock()->bytecodeOffset(callFrame, faultLocation));
+}

trunk/Source/JavaScriptCore/jit/JITExceptions.h

-              r140718
+              r148696
 class ExecState;
 class JSGlobalData;
+class VM;
 // This header gives other parts of the system access to the JIT's prototocol
 …
 };
 ExceptionHandler genericThrow(JSGlobalData*, ExecState*, JSValue exceptionValue, unsigned vPCIndex);
+ExceptionHandler genericThrow(VM*, ExecState*, JSValue exceptionValue, unsigned vPCIndex);
 ExceptionHandler jitThrow(JSGlobalData*, ExecState*, JSValue exceptionValue, ReturnAddressPtr faultLocation);
+ExceptionHandler jitThrow(VM*, ExecState*, JSValue exceptionValue, ReturnAddressPtr faultLocation);
 } // namespace JSC

trunk/Source/JavaScriptCore/jit/JITInlines.h

r146869	r148696
79	79	ALWAYS_INLINE void JIT::emitLoadCharacterString(RegisterID src, RegisterID dst, JumpList& failures)
80	80	{
81		failures.append(branchPtr(NotEqual, Address(src, JSCell::structureOffset()), TrustedImmPtr(m_~~globalData~~->stringStructure.get())));
	81	failures.append(branchPtr(NotEqual, Address(src, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
82	82	failures.append(branch32(NotEqual, MacroAssembler::Address(src, ThunkHelpers::jsStringLengthOffset()), TrustedImm32(1)));
83	83	loadPtr(MacroAssembler::Address(src, ThunkHelpers::jsStringValueOffset()), dst);
…	…
187	187	#endif
188	188	}
189		storePtr(callFrameRegister, &m_~~globalData~~->topCallFrame);
	189	storePtr(callFrameRegister, &m_vm->topCallFrame);
190	190	}
191	191

trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

-              r147184
+              r148696
 #if USE(JSVALUE64)
 JIT::CodeRef JIT::privateCompileCTINativeCall(JSGlobalData* globalData, NativeFunction)
+{
     return globalData->getCTIStub(nativeCallGenerator);
+JIT::CodeRef JIT::privateCompileCTINativeCall(VM* vm, NativeFunction)
+{
+    return vm->getCTIStub(nativeCallGenerator);
+}
 …
     Structure* structure = currentInstruction[3].u.objectAllocationProfile->structure();
     size_t allocationSize = JSObject::allocationSize(structure->inlineCapacity());
     MarkedAllocator* allocator = &m_globalData->heap.allocatorForObjectWithoutDestructor(allocationSize);
+    MarkedAllocator* allocator = &m_vm->heap.allocatorForObjectWithoutDestructor(allocationSize);
     RegisterID resultReg = regT0;
 …
     Jump isImm = emitJumpIfNotJSCell(regT0);
     addSlowCase(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    addSlowCase(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     isImm.link(this);
 …
     killLastResultRegister(); // FIXME: Implicitly treat op_catch as a labeled statement, and remove this line of code.
     move(regT0, callFrameRegister);
     peek(regT3, OBJECT_OFFSETOF(struct JITStackFrame, globalData) / sizeof(void*));
     load64(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception)), regT0);
     store64(TrustedImm64(JSValue::encode(JSValue())), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception)));
+    peek(regT3, OBJECT_OFFSETOF(struct JITStackFrame, vm) / sizeof(void*));
+    load64(Address(regT3, OBJECT_OFFSETOF(VM, exception)), regT0);
+    store64(TrustedImm64(JSValue::encode(JSValue())), Address(regT3, OBJECT_OFFSETOF(VM, exception)));
     emitPutVirtualRegister(currentInstruction[1].u.operand);
+}
 …
         emitValueProfilingSite();
+    }
     addSlowCase(branchPtr(Equal, Address(regT1, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    addSlowCase(branchPtr(Equal, Address(regT1, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+}
 …
     linkSlowCase(iter);
     if (shouldEmitProfiling())
         move(TrustedImm64(JSValue::encode(m_globalData->stringStructure.get())), regT0);
+        move(TrustedImm64(JSValue::encode(m_vm->stringStructure.get())), regT0);
     isNotUndefined.link(this);
     emitValueProfilingSite();

trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

-              r147184
+              r148696
 namespace JSC {
 JIT::CodeRef JIT::privateCompileCTINativeCall(JSGlobalData* globalData, NativeFunction func)
+JIT::CodeRef JIT::privateCompileCTINativeCall(VM* vm, NativeFunction func)
+{
     Call nativeCall;
     emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
     storePtr(callFrameRegister, &m_globalData->topCallFrame);
+    storePtr(callFrameRegister, &m_vm->topCallFrame);
 #if CPU(X86)
 …
     // Check for an exception
     Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
+    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&vm->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
     // Return.
 …
     preserveReturnAddressAfterCall(regT1);
     move(TrustedImmPtr(&globalData->exceptionLocation), regT2);
+    move(TrustedImmPtr(&vm->exceptionLocation), regT2);
     storePtr(regT1, regT2);
     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
     storePtr(callFrameRegister, &m_globalData->topCallFrame);
+    storePtr(callFrameRegister, &m_vm->topCallFrame);
     // Set the return address.
     move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
 …
     // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.
     LinkBuffer patchBuffer(*m_globalData, this, GLOBAL_THUNK_ID);
+    LinkBuffer patchBuffer(*m_vm, this, GLOBAL_THUNK_ID);
     patchBuffer.link(nativeCall, FunctionPtr(func));
 …
     Structure* structure = currentInstruction[3].u.objectAllocationProfile->structure();
     size_t allocationSize = JSObject::allocationSize(structure->inlineCapacity());
     MarkedAllocator* allocator = &m_globalData->heap.allocatorForObjectWithoutDestructor(allocationSize);
+    MarkedAllocator* allocator = &m_vm->heap.allocatorForObjectWithoutDestructor(allocationSize);
     RegisterID resultReg = regT0;
 …
     Jump isImm = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
     addSlowCase(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    addSlowCase(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     isImm.link(this);
 …
     linkSlowCase(iter); // tags equal and JSCell
     genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
     genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+    genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     // String case.
 …
     linkSlowCase(iter); // tags equal and JSCell
     genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
     genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+    genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     // String case.
 …
     // Jump to a slow case if both are strings.
     Jump notCell = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
     Jump firstNotString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get()));
     addSlowCase(branchPtr(Equal, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    Jump firstNotString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get()));
+    addSlowCase(branchPtr(Equal, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
     notCell.link(this);
     firstNotString.link(this);
 …
     // Now store the exception returned by cti_op_throw.
     loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(struct JITStackFrame, globalData)), regT3);
     load32(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
     load32(Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
     store32(TrustedImm32(JSValue().payload()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
     store32(TrustedImm32(JSValue().tag()), Address(regT3, OBJECT_OFFSETOF(JSGlobalData, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
+    loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(struct JITStackFrame, vm)), regT3);
+    load32(Address(regT3, OBJECT_OFFSETOF(VM, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
+    load32(Address(regT3, OBJECT_OFFSETOF(VM, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
+    store32(TrustedImm32(JSValue().payload()), Address(regT3, OBJECT_OFFSETOF(VM, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
+    store32(TrustedImm32(JSValue().tag()), Address(regT3, OBJECT_OFFSETOF(VM, exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
     unsigned exception = currentInstruction[1].u.operand;
 …
         emitValueProfilingSite();
+    }
     addSlowCase(branchPtr(Equal, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get())));
+    addSlowCase(branchPtr(Equal, Address(regT2, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+}
 …
     if (shouldEmitProfiling()) {
         move(TrustedImm32(JSValue::CellTag), regT1);
         move(TrustedImmPtr(m_globalData->stringStructure.get()), regT0);
+        move(TrustedImmPtr(m_vm->stringStructure.get()), regT0);
+    }
     isNotUndefined.link(this);

trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

-              r147047
+              r148696
 #if USE(JSVALUE64)
 JIT::CodeRef JIT::stringGetByValStubGenerator(JSGlobalData* globalData)
+JIT::CodeRef JIT::stringGetByValStubGenerator(VM* vm)
+{
     JSInterfaceJIT jit;
     JumpList failures;
     failures.append(jit.branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(globalData->stringStructure.get())));
+    failures.append(jit.branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(vm->stringStructure.get())));
     // Load string length to regT2, and start the process of loading the data pointer into regT0
 …
     failures.append(jit.branch32(AboveOrEqual, regT0, TrustedImm32(0x100)));
     jit.move(TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
+    jit.move(TrustedImmPtr(vm->smallStrings.singleCharacterStrings()), regT1);
     jit.loadPtr(BaseIndex(regT1, regT0, ScalePtr, 0), regT0);
     jit.ret();
 …
     jit.ret();
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     return FINALIZE_CODE(patchBuffer, ("String get_by_val stub"));
+}
 …
     Jump nonCell = jump();
     linkSlowCase(iter); // base array check
     Jump notString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get()));
     emitNakedCall(CodeLocationLabel(m_globalData->getCTIStub(stringGetByValStubGenerator).code()));
+    Jump notString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get()));
+    emitNakedCall(CodeLocationLabel(m_vm->getCTIStub(stringGetByValStubGenerator).code()));
     Jump failed = branchTest64(Zero, regT0);
     emitPutVirtualRegister(dst, regT0);
 …
     emitJumpSlowCaseIfNotJSCell(regT0, baseVReg);
     if (*ident == m_globalData->propertyNames->length && shouldEmitProfiling()) {
+    if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
         loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
         emitArrayProfilingSiteForBytecodeIndex(regT1, regT2, m_bytecodeOffset);
 …
     Call failureCall = tailRecursiveCall();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(failureCall, FunctionPtr(direct ? cti_op_put_by_id_direct_fail : cti_op_put_by_id_fail));
 …
             ("Baseline put_by_id transition for %s, return point %p",
                 toCString(*m_codeBlock).data(), returnAddress.value())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         willNeedStorageRealloc,
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     // Use the patch information to link the failure cases back to the original slow case routine.
 …
         compileGetDirectOffset(protoObject, regT0, cachedOffset);
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     // Use the patch information to link the failure cases back to the original slow case routine.
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     polymorphicStructures->list[currentIndex].set(*m_globalData, m_codeBlock->ownerExecutable(), stubCode, structure, isDirect);
+    polymorphicStructures->list[currentIndex].set(*m_vm, m_codeBlock->ownerExecutable(), stubCode, structure, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     prototypeStructures->list[currentIndex].set(*m_globalData, m_codeBlock->ownerExecutable(), stubCode, structure, prototypeStructure, isDirect);
+    prototypeStructures->list[currentIndex].set(*m_vm, m_codeBlock->ownerExecutable(), stubCode, structure, prototypeStructure, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     // Track the stub we have created so that it will be deleted later.
     prototypeStructures->list[currentIndex].set(callFrame->globalData(), m_codeBlock->ownerExecutable(), stubRoutine, structure, chain, isDirect);
+    prototypeStructures->list[currentIndex].set(callFrame->vm(), m_codeBlock->ownerExecutable(), stubRoutine, structure, chain, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
 …
         break;
     case JITInt8Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->int8ArrayDescriptor(), 1, SignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->int8ArrayDescriptor(), 1, SignedTypedArray);
         break;
     case JITInt16Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->int16ArrayDescriptor(), 2, SignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->int16ArrayDescriptor(), 2, SignedTypedArray);
         break;
     case JITInt32Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->int32ArrayDescriptor(), 4, SignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->int32ArrayDescriptor(), 4, SignedTypedArray);
         break;
     case JITUint8Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->uint8ArrayDescriptor(), 1, UnsignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->uint8ArrayDescriptor(), 1, UnsignedTypedArray);
         break;
     case JITUint8ClampedArray:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->uint8ClampedArrayDescriptor(), 1, UnsignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->uint8ClampedArrayDescriptor(), 1, UnsignedTypedArray);
         break;
     case JITUint16Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->uint16ArrayDescriptor(), 2, UnsignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->uint16ArrayDescriptor(), 2, UnsignedTypedArray);
         break;
     case JITUint32Array:
         slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_globalData->uint32ArrayDescriptor(), 4, UnsignedTypedArray);
+        slowCases = emitIntTypedArrayGetByVal(currentInstruction, badType, m_vm->uint32ArrayDescriptor(), 4, UnsignedTypedArray);
         break;
     case JITFloat32Array:
         slowCases = emitFloatTypedArrayGetByVal(currentInstruction, badType, m_globalData->float32ArrayDescriptor(), 4);
+        slowCases = emitFloatTypedArrayGetByVal(currentInstruction, badType, m_vm->float32ArrayDescriptor(), 4);
         break;
     case JITFloat64Array:
         slowCases = emitFloatTypedArrayGetByVal(currentInstruction, badType, m_globalData->float64ArrayDescriptor(), 8);
+        slowCases = emitFloatTypedArrayGetByVal(currentInstruction, badType, m_vm->float64ArrayDescriptor(), 8);
         break;
     default:
 …
     Jump done = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(badType, CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(returnAddress.value())).labelAtOffset(byValInfo->returnAddressToSlowPath));
 …
         break;
     case JITInt8Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->int8ArrayDescriptor(), 1, SignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->int8ArrayDescriptor(), 1, SignedTypedArray, TruncateRounding);
         break;
     case JITInt16Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->int16ArrayDescriptor(), 2, SignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->int16ArrayDescriptor(), 2, SignedTypedArray, TruncateRounding);
         break;
     case JITInt32Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->int32ArrayDescriptor(), 4, SignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->int32ArrayDescriptor(), 4, SignedTypedArray, TruncateRounding);
         break;
     case JITUint8Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->uint8ArrayDescriptor(), 1, UnsignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->uint8ArrayDescriptor(), 1, UnsignedTypedArray, TruncateRounding);
         break;
     case JITUint8ClampedArray:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->uint8ClampedArrayDescriptor(), 1, UnsignedTypedArray, ClampRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->uint8ClampedArrayDescriptor(), 1, UnsignedTypedArray, ClampRounding);
         break;
     case JITUint16Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->uint16ArrayDescriptor(), 2, UnsignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->uint16ArrayDescriptor(), 2, UnsignedTypedArray, TruncateRounding);
         break;
     case JITUint32Array:
         slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_globalData->uint32ArrayDescriptor(), 4, UnsignedTypedArray, TruncateRounding);
+        slowCases = emitIntTypedArrayPutByVal(currentInstruction, badType, m_vm->uint32ArrayDescriptor(), 4, UnsignedTypedArray, TruncateRounding);
         break;
     case JITFloat32Array:
         slowCases = emitFloatTypedArrayPutByVal(currentInstruction, badType, m_globalData->float32ArrayDescriptor(), 4);
+        slowCases = emitFloatTypedArrayPutByVal(currentInstruction, badType, m_vm->float32ArrayDescriptor(), 4);
         break;
     case JITFloat64Array:
         slowCases = emitFloatTypedArrayPutByVal(currentInstruction, badType, m_globalData->float64ArrayDescriptor(), 8);
+        slowCases = emitFloatTypedArrayPutByVal(currentInstruction, badType, m_vm->float64ArrayDescriptor(), 8);
         break;
     default:
 …
     Jump done = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(badType, CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(returnAddress.value())).labelAtOffset(byValInfo->returnAddressToSlowPath));

trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp

-              r145000
+              r148696
+}
 JIT::CodeRef JIT::stringGetByValStubGenerator(JSGlobalData* globalData)
+JIT::CodeRef JIT::stringGetByValStubGenerator(VM* vm)
+{
     JSInterfaceJIT jit;
     JumpList failures;
     failures.append(jit.branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(globalData->stringStructure.get())));
+    failures.append(jit.branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(vm->stringStructure.get())));
     // Load string length to regT1, and start the process of loading the data pointer into regT0
 …
     failures.append(jit.branch32(AboveOrEqual, regT0, TrustedImm32(0x100)));
     jit.move(TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), regT1);
+    jit.move(TrustedImmPtr(vm->smallStrings.singleCharacterStrings()), regT1);
     jit.loadPtr(BaseIndex(regT1, regT0, ScalePtr, 0), regT0);
     jit.move(TrustedImm32(JSValue::CellTag), regT1); // We null check regT0 on return so this is safe
 …
     jit.ret();
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     return FINALIZE_CODE(patchBuffer, ("String get_by_val stub"));
+}
 …
     Jump nonCell = jump();
     linkSlowCase(iter); // base array check
     Jump notString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_globalData->stringStructure.get()));
     emitNakedCall(m_globalData->getCTIStub(stringGetByValStubGenerator).code());
+    Jump notString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get()));
+    emitNakedCall(m_vm->getCTIStub(stringGetByValStubGenerator).code());
     Jump failed = branchTestPtr(Zero, regT0);
     emitStore(dst, regT1, regT0);
 …
     // to jump back to if one of these trampolies finds a match.
     if (*ident == m_globalData->propertyNames->length && shouldEmitProfiling()) {
+    if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
         loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
         emitArrayProfilingSiteForBytecodeIndex(regT2, regT3, m_bytecodeOffset);
 …
     Call failureCall = tailRecursiveCall();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     patchBuffer.link(failureCall, FunctionPtr(direct ? cti_op_put_by_id_direct_fail : cti_op_put_by_id_fail));
 …
             ("Baseline put_by_id transition stub for %s, return point %p",
                 toCString(*m_codeBlock).data(), returnAddress.value())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         willNeedStorageRealloc,
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     // Use the patch information to link the failure cases back to the original slow case routine.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     // Use the patch information to link the failure cases back to the original slow case routine.
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
         for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     polymorphicStructures->list[currentIndex].set(*m_globalData, m_codeBlock->ownerExecutable(), stubRoutine, structure, isDirect);
+    polymorphicStructures->list[currentIndex].set(*m_vm, m_codeBlock->ownerExecutable(), stubRoutine, structure, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
         for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     prototypeStructures->list[currentIndex].set(callFrame->globalData(), m_codeBlock->ownerExecutable(), stubRoutine, structure, prototypeStructure, isDirect);
+    prototypeStructures->list[currentIndex].set(callFrame->vm(), m_codeBlock->ownerExecutable(), stubRoutine, structure, prototypeStructure, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
         for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);
     // Track the stub we have created so that it will be deleted later.
     prototypeStructures->list[currentIndex].set(callFrame->globalData(), m_codeBlock->ownerExecutable(), stubRoutine, structure, chain, isDirect);
+    prototypeStructures->list[currentIndex].set(callFrame->vm(), m_codeBlock->ownerExecutable(), stubRoutine, structure, chain, isDirect);
     // Finally patch the jump to slow case back in the hot path to jump here instead.
 …
     Jump success = jump();
     LinkBuffer patchBuffer(*m_globalData, this, m_codeBlock);
+    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
     if (needsStubLink) {
         for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
 …
                 toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                     stubInfo->patch.baseline.u.get.putResult).executableAddress())),
         *m_globalData,
+        *m_vm,
         m_codeBlock->ownerExecutable(),
         needsStubLink);

trunk/Source/JavaScriptCore/jit/JITStubs.cpp

-              r148663
+              r148696
 extern "C" {
     __declspec(naked) EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
+    __declspec(naked) EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
+    {
         __asm {
 …
 #elif CPU(SH4)
 #define SYMBOL_STRING(name) #name
 /* code (r4), JSStack* (r5), CallFrame* (r6), void* unused1 (r7), void* unused2(sp), JSGlobalData (sp)*/
+/* code (r4), JSStack* (r5), CallFrame* (r6), void* unused1 (r7), void* unused2(sp), VM (sp)*/
 asm volatile (
 …
     "move  $25,$4       # move executableAddress to t9" "\n"
     "sw    $5," STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "($29) # store JSStack to current stack" "\n"
     "lw    $9," STRINGIZE_VALUE_OF(STACK_LENGTH + 20) "($29)    # load globalData from previous stack" "\n"
+    "lw    $9," STRINGIZE_VALUE_OF(STACK_LENGTH + 20) "($29)    # load vm from previous stack" "\n"
     "jalr  $25" "\n"
     "sw    $9," STRINGIZE_VALUE_OF(GLOBAL_DATA_OFFSET) "($29)   # store globalData to current stack" "\n"
+    "sw    $9," STRINGIZE_VALUE_OF(GLOBAL_DATA_OFFSET) "($29)   # store vm to current stack" "\n"
     "lw    $16," STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) "($29)" "\n"
     "lw    $17," STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) "($29)" "\n"
 …
 #elif COMPILER(RVCT) && CPU(ARM_THUMB2)
 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
+__asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
+{
     PRESERVE8
 …
 #elif COMPILER(RVCT) && CPU(ARM_TRADITIONAL)
 __asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
+__asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*)
+{
     ARM
 …
 #if ENABLE(OPCODE_SAMPLING)
     #define CTI_SAMPLER stackFrame.globalData->interpreter->sampler()
+    #define CTI_SAMPLER stackFrame.vm->interpreter->sampler()
 #else
     #define CTI_SAMPLER 0
 #endif
 void performPlatformSpecificJITAssertions(JSGlobalData* globalData)
+{
     if (!globalData->canUseJIT())
+void performPlatformSpecificJITAssertions(VM* vm)
+{
+    if (!vm->canUseJIT())
         return;
 …
     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET);
     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, stack) == REGISTER_FILE_OFFSET);
     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, globalData) == GLOBAL_DATA_OFFSET);
+    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, vm) == GLOBAL_DATA_OFFSET);
 #endif
 …
         StructureChain* prototypeChain = structure->prototypeChain(callFrame);
         ASSERT(structure->previousID()->transitionWatchpointSetHasBeenInvalidated());
         stubInfo->initPutByIdTransition(callFrame->globalData(), codeBlock->ownerExecutable(), structure->previousID(), structure, prototypeChain, direct);
         JIT::compilePutByIdTransition(callFrame->scope()->globalData(), codeBlock, stubInfo, structure->previousID(), structure, slot.cachedOffset(), prototypeChain, returnAddress, direct);
+        stubInfo->initPutByIdTransition(callFrame->vm(), codeBlock->ownerExecutable(), structure->previousID(), structure, prototypeChain, direct);
+        JIT::compilePutByIdTransition(callFrame->scope()->vm(), codeBlock, stubInfo, structure->previousID(), structure, slot.cachedOffset(), prototypeChain, returnAddress, direct);
         return;
+    }
     stubInfo->initPutByIdReplace(callFrame->globalData(), codeBlock->ownerExecutable(), structure);
+    stubInfo->initPutByIdReplace(callFrame->vm(), codeBlock->ownerExecutable(), structure);
     JIT::patchPutByIdReplace(codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress, direct);
 …
+    }
     JSGlobalData* globalData = &callFrame->globalData();
+    VM* vm = &callFrame->vm();
     if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
         JIT::compilePatchGetArrayLength(callFrame->scope()->globalData(), codeBlock, returnAddress);
+        JIT::compilePatchGetArrayLength(callFrame->scope()->vm(), codeBlock, returnAddress);
         return;
+    }
 …
         // The tradeoff of compiling an patched inline string length access routine does not seem
         // to pay off, so we currently only do this for arrays.
         ctiPatchCallByReturnAddress(codeBlock, returnAddress, globalData->getCTIStub(stringLengthTrampolineGenerator).code());
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, vm->getCTIStub(stringLengthTrampolineGenerator).code());
         return;
+    }
 …
         else {
             JIT::patchGetByIdSelf(codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress);
             stubInfo->initGetByIdSelf(callFrame->globalData(), codeBlock->ownerExecutable(), structure);
+            stubInfo->initGetByIdSelf(callFrame->vm(), codeBlock->ownerExecutable(), structure);
+        }
         return;
 …
         // should not be treated as a dictionary.
         if (slotBaseObject->structure()->isDictionary()) {
             slotBaseObject->flattenDictionaryObject(callFrame->globalData());
             offset = slotBaseObject->structure()->get(callFrame->globalData(), propertyName);
+            slotBaseObject->flattenDictionaryObject(callFrame->vm());
+            offset = slotBaseObject->structure()->get(callFrame->vm(), propertyName);
+        }
         stubInfo->initGetByIdProto(callFrame->globalData(), codeBlock->ownerExecutable(), structure, slotBaseObject->structure(), slot.cachedPropertyType() == PropertySlot::Value);
+        stubInfo->initGetByIdProto(callFrame->vm(), codeBlock->ownerExecutable(), structure, slotBaseObject->structure(), slot.cachedPropertyType() == PropertySlot::Value);
         ASSERT(!structure->isDictionary());
         ASSERT(!slotBaseObject->structure()->isDictionary());
         JIT::compileGetByIdProto(callFrame->scope()->globalData(), callFrame, codeBlock, stubInfo, structure, slotBaseObject->structure(), propertyName, slot, offset, returnAddress);
+        JIT::compileGetByIdProto(callFrame->scope()->vm(), callFrame, codeBlock, stubInfo, structure, slotBaseObject->structure(), propertyName, slot, offset, returnAddress);
         return;
+    }
 …
     StructureChain* prototypeChain = structure->prototypeChain(callFrame);
     stubInfo->initGetByIdChain(callFrame->globalData(), codeBlock->ownerExecutable(), structure, prototypeChain, count, slot.cachedPropertyType() == PropertySlot::Value);
     JIT::compileGetByIdChain(callFrame->scope()->globalData(), callFrame, codeBlock, stubInfo, structure, prototypeChain, count, propertyName, slot, offset, returnAddress);
+    stubInfo->initGetByIdChain(callFrame->vm(), codeBlock->ownerExecutable(), structure, prototypeChain, count, slot.cachedPropertyType() == PropertySlot::Value);
+    JIT::compileGetByIdChain(callFrame->scope()->vm(), callFrame, codeBlock, stubInfo, structure, prototypeChain, count, propertyName, slot, offset, returnAddress);
+}
 …
 // good to keep the code size down by leaving as much of the exception
 // handling code out of line as possible.
 static NEVER_INLINE void returnToThrowTrampoline(JSGlobalData* globalData, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
+{
     RELEASE_ASSERT(globalData->exception);
     globalData->exceptionLocation = exceptionLocation;
+static NEVER_INLINE void returnToThrowTrampoline(VM* vm, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
+{
+    RELEASE_ASSERT(vm->exception);
+    vm->exceptionLocation = exceptionLocation;
     returnAddressSlot = ReturnAddressPtr(FunctionPtr(ctiVMThrowTrampoline));
+}
 …
 #define VM_THROW_EXCEPTION_AT_END() \
     do {\
         returnToThrowTrampoline(stackFrame.globalData, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS);\
+        returnToThrowTrampoline(stackFrame.vm, STUB_RETURN_ADDRESS, STUB_RETURN_ADDRESS);\
     } while (0)
 #define CHECK_FOR_EXCEPTION() \
     do { \
         if (UNLIKELY(stackFrame.globalData->exception)) \
+        if (UNLIKELY(stackFrame.vm->exception)) \
             VM_THROW_EXCEPTION(); \
     } while (0)
 #define CHECK_FOR_EXCEPTION_AT_END() \
     do { \
         if (UNLIKELY(stackFrame.globalData->exception)) \
+        if (UNLIKELY(stackFrame.vm->exception)) \
             VM_THROW_EXCEPTION_AT_END(); \
     } while (0)
 #define CHECK_FOR_EXCEPTION_VOID() \
     do { \
         if (UNLIKELY(stackFrame.globalData->exception)) { \
+        if (UNLIKELY(stackFrame.vm->exception)) { \
             VM_THROW_EXCEPTION_AT_END(); \
             return; \
 …
+{
     CallFrame* callFrame = newCallFrame->callerFrame();
     ASSERT(callFrame->globalData().exception);
+    ASSERT(callFrame->vm().exception);
     jitStackFrame.callFrame = callFrame;
     callFrame->globalData().topCallFrame = callFrame;
     returnToThrowTrampoline(&callFrame->globalData(), ReturnAddressPtr(newCallFrame->returnPC()), returnAddressSlot);
+    callFrame->vm().topCallFrame = callFrame;
+    returnToThrowTrampoline(&callFrame->vm(), ReturnAddressPtr(newCallFrame->returnPC()), returnAddressSlot);
     return T();
+}
 …
 template<typename T> static T throwExceptionFromOpCall(JITStackFrame& jitStackFrame, CallFrame* newCallFrame, ReturnAddressPtr& returnAddressSlot, JSValue exception)
+{
     newCallFrame->callerFrame()->globalData().exception = exception;
+    newCallFrame->callerFrame()->vm().exception = exception;
     return throwExceptionFromOpCall<T>(jitStackFrame, newCallFrame, returnAddressSlot);
+}
 …
     STUB_INIT_STACK_FRAME(stackFrame);
     CallFrame* callFrame = stackFrame.callFrame;
     JSGlobalData* globalData = stackFrame.globalData;
     if (UNLIKELY(globalData->watchdog.didFire(callFrame))) {
         globalData->exception = createTerminatedExecutionException(globalData);
+    VM* vm = stackFrame.vm;
+    if (UNLIKELY(vm->watchdog.didFire(callFrame))) {
+        vm->exception = createTerminatedExecutionException(vm);
         VM_THROW_EXCEPTION_AT_END();
         return;
 …
     JSValue baseValue = stackFrame.args[0].jsValue();
     ASSERT(baseValue.isObject());
     asObject(baseValue)->putDirect(stackFrame.callFrame->globalData(), stackFrame.args[1].identifier(), stackFrame.args[2].jsValue(), slot);
+    asObject(baseValue)->putDirect(stackFrame.callFrame->vm(), stackFrame.args[1].identifier(), stackFrame.args[2].jsValue(), slot);
     CHECK_FOR_EXCEPTION_AT_END();
+}
 …
     ASSERT(baseValue.isObject());
     asObject(baseValue)->putDirect(callFrame->globalData(), ident, stackFrame.args[2].jsValue(), slot);
+    asObject(baseValue)->putDirect(callFrame->vm(), ident, stackFrame.args[2].jsValue(), slot);
     if (accessType == static_cast<AccessType>(stubInfo->accessType)) {
 …
     JSValue baseValue = stackFrame.args[0].jsValue();
     ASSERT(baseValue.isObject());
     asObject(baseValue)->putDirect(callFrame->globalData(), ident, stackFrame.args[2].jsValue(), slot);
+    asObject(baseValue)->putDirect(callFrame->vm(), ident, stackFrame.args[2].jsValue(), slot);
     CHECK_FOR_EXCEPTION_AT_END();
 …
     ASSERT(baseValue.isObject());
     JSObject* base = asObject(baseValue);
     JSGlobalData& globalData = *stackFrame.globalData;
     Butterfly* butterfly = base->growOutOfLineStorage(globalData, oldSize, newSize);
     base->setButterfly(globalData, butterfly, newStructure);
+    VM& vm = *stackFrame.vm;
+    Butterfly* butterfly = base->growOutOfLineStorage(vm, oldSize, newSize);
+    base->setButterfly(vm, butterfly, newStructure);
     return base;
 …
         if (stubInfo->accessType == access_unset)
             stubInfo->initGetByIdSelf(callFrame->globalData(), codeBlock->ownerExecutable(), baseValue.asCell()->structure());
+            stubInfo->initGetByIdSelf(callFrame->vm(), codeBlock->ownerExecutable(), baseValue.asCell()->structure());
         if (stubInfo->accessType == access_get_by_id_self) {
             ASSERT(!stubInfo->stubRoutine);
             polymorphicStructureList = new PolymorphicAccessStructureList(callFrame->globalData(), codeBlock->ownerExecutable(), 0, stubInfo->u.getByIdSelf.baseObjectStructure.get(), true);
+            polymorphicStructureList = new PolymorphicAccessStructureList(callFrame->vm(), codeBlock->ownerExecutable(), 0, stubInfo->u.getByIdSelf.baseObjectStructure.get(), true);
             stubInfo->initGetByIdSelfList(polymorphicStructureList, 1);
         } else {
 …
         if (listIndex < POLYMORPHIC_LIST_CACHE_SIZE) {
             stubInfo->u.getByIdSelfList.listSize++;
             JIT::compileGetByIdSelfList(callFrame->scope()->globalData(), codeBlock, stubInfo, polymorphicStructureList, listIndex, baseValue.asCell()->structure(), ident, slot, slot.cachedOffset());
+            JIT::compileGetByIdSelfList(callFrame->scope()->vm(), codeBlock, stubInfo, polymorphicStructureList, listIndex, baseValue.asCell()->structure(), ident, slot, slot.cachedOffset());
             if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
 …
+}
 static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(JSGlobalData& globalData, ScriptExecutable* owner, StructureStubInfo* stubInfo, int& listIndex)
+static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(VM& vm, ScriptExecutable* owner, StructureStubInfo* stubInfo, int& listIndex)
+{
     PolymorphicAccessStructureList* prototypeStructureList = 0;
 …
     switch (stubInfo->accessType) {
     case access_get_by_id_proto:
         prototypeStructureList = new PolymorphicAccessStructureList(globalData, owner, stubInfo->stubRoutine, stubInfo->u.getByIdProto.baseObjectStructure.get(), stubInfo->u.getByIdProto.prototypeStructure.get(), true);
+        prototypeStructureList = new PolymorphicAccessStructureList(vm, owner, stubInfo->stubRoutine, stubInfo->u.getByIdProto.baseObjectStructure.get(), stubInfo->u.getByIdProto.prototypeStructure.get(), true);
         stubInfo->stubRoutine.clear();
         stubInfo->initGetByIdProtoList(prototypeStructureList, 2);
         break;
     case access_get_by_id_chain:
         prototypeStructureList = new PolymorphicAccessStructureList(globalData, owner, stubInfo->stubRoutine, stubInfo->u.getByIdChain.baseObjectStructure.get(), stubInfo->u.getByIdChain.chain.get(), true);
+        prototypeStructureList = new PolymorphicAccessStructureList(vm, owner, stubInfo->stubRoutine, stubInfo->u.getByIdChain.baseObjectStructure.get(), stubInfo->u.getByIdChain.chain.get(), true);
         stubInfo->stubRoutine.clear();
         stubInfo->initGetByIdProtoList(prototypeStructureList, 2);
 …
     JSValue result = call(callFrame, getter, callType, callData, stackFrame.args[1].jsObject(), ArgList());
     if (callFrame->hadException())
         returnToThrowTrampoline(&callFrame->globalData(), stackFrame.args[2].returnAddress(), STUB_RETURN_ADDRESS);
+        returnToThrowTrampoline(&callFrame->vm(), stackFrame.args[2].returnAddress(), STUB_RETURN_ADDRESS);
     return JSValue::encode(result);
 …
     JSValue result = getter(callFrame, slotBase, ident);
     if (callFrame->hadException())
         returnToThrowTrampoline(&callFrame->globalData(), stackFrame.args[3].returnAddress(), STUB_RETURN_ADDRESS);
+        returnToThrowTrampoline(&callFrame->vm(), stackFrame.args[3].returnAddress(), STUB_RETURN_ADDRESS);
     return JSValue::encode(result);
 …
         // should not be treated as a dictionary.
         if (slotBaseObject->structure()->isDictionary()) {
             slotBaseObject->flattenDictionaryObject(callFrame->globalData());
             offset = slotBaseObject->structure()->get(callFrame->globalData(), propertyName);
+            slotBaseObject->flattenDictionaryObject(callFrame->vm());
+            offset = slotBaseObject->structure()->get(callFrame->vm(), propertyName);
+        }
         int listIndex;
         PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(callFrame->globalData(), codeBlock->ownerExecutable(), stubInfo, listIndex);
+        PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(callFrame->vm(), codeBlock->ownerExecutable(), stubInfo, listIndex);
         if (listIndex < POLYMORPHIC_LIST_CACHE_SIZE) {
             JIT::compileGetByIdProtoList(callFrame->scope()->globalData(), callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, slotBaseObject->structure(), propertyName, slot, offset);
+            JIT::compileGetByIdProtoList(callFrame->scope()->vm(), callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, slotBaseObject->structure(), propertyName, slot, offset);
             if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
 …
         ASSERT(!baseValue.asCell()->structure()->isDictionary());
         int listIndex;
         PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(callFrame->globalData(), codeBlock->ownerExecutable(), stubInfo, listIndex);
+        PolymorphicAccessStructureList* prototypeStructureList = getPolymorphicAccessStructureListSlot(callFrame->vm(), codeBlock->ownerExecutable(), stubInfo, listIndex);
         if (listIndex < POLYMORPHIC_LIST_CACHE_SIZE) {
             StructureChain* protoChain = structure->prototypeChain(callFrame);
             JIT::compileGetByIdChainList(callFrame->scope()->globalData(), callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, protoChain, count, propertyName, slot, offset);
+            JIT::compileGetByIdChainList(callFrame->scope()->vm(), callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, protoChain, count, propertyName, slot, offset);
             if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
 …
+    }
     stackFrame.globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal);
+    stackFrame.vm->exception = createInvalidParamError(callFrame, "instanceof", baseVal);
     VM_THROW_EXCEPTION_AT_END();
     return JSValue::encode(JSValue());
 …
     JSValue result = jsBoolean(couldDelete);
     if (!couldDelete && callFrame->codeBlock()->isStrictMode())
         stackFrame.globalData->exception = createTypeError(stackFrame.callFrame, "Unable to delete property.");
+        stackFrame.vm->exception = createTypeError(stackFrame.callFrame, "Unable to delete property.");
     CHECK_FOR_EXCEPTION_AT_END();
 …
     if (!error)
         return function;
     callFrame->globalData().exception = error;
+    callFrame->vm().exception = error;
     return 0;
+}
 …
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
         if (JSObject* error = functionExecutable->compileFor(callFrame, callee->scope(), kind)) {
             callFrame->globalData().exception = error;
+            callFrame->vm().exception = error;
             return 0;
+        }
 …
         callLinkInfo->setSeen();
     else
         JIT::linkFor(callee, callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, &callFrame->globalData(), kind);
+        JIT::linkFor(callee, callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, &callFrame->vm(), kind);
     return codePtr.executableAddress();
 …
     CodeBlock* callerCodeBlock = callFrame->callerFrame()->codeBlock();
     JSGlobalData* globalData = callerCodeBlock->globalData();
+    VM* vm = callerCodeBlock->vm();
     CallLinkInfo* callLinkInfo = &callerCodeBlock->getCallLinkInfo(callFrame->returnPC());
     JSFunction* callee = jsCast<JSFunction*>(callFrame->callee());
 …
         JSObject* error = functionExecutable->compileFor(callFrame, scopeChain, CodeForCall);
         if (error) {
             callFrame->globalData().exception = error;
+            callFrame->vm().exception = error;
             return 0;
+        }
 …
     if (shouldLink) {
         ASSERT(codePtr);
         JIT::compileClosureCall(globalData, callLinkInfo, callerCodeBlock, calleeCodeBlock, structure, executable, codePtr);
+        JIT::compileClosureCall(vm, callLinkInfo, callerCodeBlock, calleeCodeBlock, structure, executable, codePtr);
         callLinkInfo->hasSeenClosure = true;
     } else
 …
     STUB_INIT_STACK_FRAME(stackFrame);
     JSActivation* activation = JSActivation::create(stackFrame.callFrame->globalData(), stackFrame.callFrame, stackFrame.callFrame->codeBlock());
+    JSActivation* activation = JSActivation::create(stackFrame.callFrame->vm(), stackFrame.callFrame, stackFrame.callFrame->codeBlock());
     stackFrame.callFrame->setScope(activation);
     return activation;
 …
+    }
     if (stackFrame.globalData->exception)
+    if (stackFrame.vm->exception)
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 …
     STUB_INIT_STACK_FRAME(stackFrame);
     Arguments* arguments = Arguments::create(*stackFrame.globalData, stackFrame.callFrame);
+    Arguments* arguments = Arguments::create(*stackFrame.vm, stackFrame.callFrame);
     return JSValue::encode(JSValue(arguments));
+}
 …
     ASSERT(stackFrame.callFrame->codeBlock()->needsFullScopeChain());
     jsCast<JSActivation*>(stackFrame.args[0].jsValue())->tearOff(*stackFrame.globalData);
+    jsCast<JSActivation*>(stackFrame.args[0].jsValue())->tearOff(*stackFrame.vm);
+}
 …
     STUB_INIT_STACK_FRAME(stackFrame);
     if (LegacyProfiler* profiler = stackFrame.globalData->enabledProfiler())
+    if (LegacyProfiler* profiler = stackFrame.vm->enabledProfiler())
         profiler->willExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
+}
 …
     STUB_INIT_STACK_FRAME(stackFrame);
     if (LegacyProfiler* profiler = stackFrame.globalData->enabledProfiler())
+    if (LegacyProfiler* profiler = stackFrame.vm->enabledProfiler())
         profiler->didExecute(stackFrame.callFrame, stackFrame.args[0].jsValue());
+}
 …
+    }
     if (stackFrame.globalData->exception)
+    if (stackFrame.vm->exception)
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 …
             JITArrayMode arrayMode = jitArrayModeForStructure(object->structure());
             if (arrayMode != byValInfo.arrayMode) {
                 JIT::compileGetByVal(&callFrame->globalData(), callFrame->codeBlock(), &byValInfo, STUB_RETURN_ADDRESS, arrayMode);
+                JIT::compileGetByVal(&callFrame->vm(), callFrame->codeBlock(), &byValInfo, STUB_RETURN_ADDRESS, arrayMode);
                 didOptimize = true;
+            }
 …
             JSObject* object = asObject(baseValue);
             if (object->canSetIndexQuickly(i))
                 object->setIndexQuickly(callFrame->globalData(), i, value);
+                object->setIndexQuickly(callFrame->vm(), i, value);
             else
                 object->methodTable()->putByIndex(object, callFrame, i, value, callFrame->codeBlock()->isStrictMode());
 …
     } else {
         Identifier property(callFrame, subscript.toString(callFrame)->value(callFrame));
         if (!callFrame->globalData().exception) { // Don't put to an object if toString threw an exception.
+        if (!callFrame->vm().exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot(callFrame->codeBlock()->isStrictMode());
             baseValue.put(callFrame, property, value, slot);
 …
             JITArrayMode arrayMode = jitArrayModeForStructure(object->structure());
             if (arrayMode != byValInfo.arrayMode) {
                 JIT::compilePutByVal(&callFrame->globalData(), callFrame->codeBlock(), &byValInfo, STUB_RETURN_ADDRESS, arrayMode);
+                JIT::compilePutByVal(&callFrame->vm(), callFrame->codeBlock(), &byValInfo, STUB_RETURN_ADDRESS, arrayMode);
                 didOptimize = true;
+            }
 …
     ASSERT(stackFrame.callFrame->codeBlock()->isStrictMode());
     if (!object->getPropertySlot(stackFrame.callFrame, stackFrame.args[1].identifier(), slot)) {
         stackFrame.globalData->exception = createErrorForInvalidGlobalAssignment(stackFrame.callFrame, stackFrame.args[1].identifier().string());
+        stackFrame.vm->exception = createErrorForInvalidGlobalAssignment(stackFrame.callFrame, stackFrame.args[1].identifier().string());
         VM_THROW_EXCEPTION();
+    }
 …
     RegExp* regExp = stackFrame.args[0].regExp();
     if (!regExp->isValid()) {
         stackFrame.globalData->exception = createSyntaxError(callFrame, "Invalid flags supplied to RegExp constructor.");
+        stackFrame.vm->exception = createSyntaxError(callFrame, "Invalid flags supplied to RegExp constructor.");
         VM_THROW_EXCEPTION();
+    }
     return RegExpObject::create(*stackFrame.globalData, stackFrame.callFrame->lexicalGlobalObject(), stackFrame.callFrame->lexicalGlobalObject()->regExpStructure(), regExp);
+    return RegExpObject::create(*stackFrame.vm, stackFrame.callFrame->lexicalGlobalObject(), stackFrame.callFrame->lexicalGlobalObject()->regExpStructure(), regExp);
+}
 …
     JSValue result = eval(callFrame);
     if (stackFrame.globalData->exception)
+    if (stackFrame.vm->exception)
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 …
+{
     STUB_INIT_STACK_FRAME(stackFrame);
     ExceptionHandler handler = jitThrow(stackFrame.globalData, stackFrame.callFrame, stackFrame.args[0].jsValue(), STUB_RETURN_ADDRESS);
+    ExceptionHandler handler = jitThrow(stackFrame.vm, stackFrame.callFrame, stackFrame.args[0].jsValue(), STUB_RETURN_ADDRESS);
     STUB_SET_RETURN_ADDRESS(handler.catchRoutine);
     return handler.callFrame;
 …
     if (!baseVal.isObject()) {
         stackFrame.globalData->exception = createInvalidParamError(stackFrame.callFrame, "in", baseVal);
+        stackFrame.vm->exception = createInvalidParamError(stackFrame.callFrame, "in", baseVal);
         VM_THROW_EXCEPTION();
+    }
 …
     if (!result && callFrame->codeBlock()->isStrictMode())
         stackFrame.globalData->exception = createTypeError(stackFrame.callFrame, "Unable to delete property.");
+        stackFrame.vm->exception = createTypeError(stackFrame.callFrame, "Unable to delete property.");
     CHECK_FOR_EXCEPTION_AT_END();
 …
     if (!getter.isUndefined())
         accessor->setGetter(callFrame->globalData(), asObject(getter));
+        accessor->setGetter(callFrame->vm(), asObject(getter));
     if (!setter.isUndefined())
         accessor->setSetter(callFrame->globalData(), asObject(setter));
+        accessor->setSetter(callFrame->vm(), asObject(setter));
     baseObj->putDirectAccessor(callFrame, stackFrame.args[1].identifier(), accessor, Accessor);
+}
 …
     String message = stackFrame.args[0].jsValue().toString(callFrame)->value(callFrame);
     if (stackFrame.args[1].asInt32)
         stackFrame.globalData->exception = createReferenceError(callFrame, message);
+        stackFrame.vm->exception = createReferenceError(callFrame, message);
     else
         stackFrame.globalData->exception = createTypeError(callFrame, message);
+        stackFrame.vm->exception = createTypeError(callFrame, message);
     VM_THROW_EXCEPTION_AT_END();
+}
 …
     int column = stackFrame.args[3].int32();
     stackFrame.globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
+    stackFrame.vm->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine, column);
+}
 …
+{
     STUB_INIT_STACK_FRAME(stackFrame);
     JSGlobalData* globalData = stackFrame.globalData;
     ExceptionHandler handler = jitThrow(globalData, stackFrame.callFrame, globalData->exception, globalData->exceptionLocation);
+    VM* vm = stackFrame.vm;
+    ExceptionHandler handler = jitThrow(vm, stackFrame.callFrame, vm->exception, vm->exceptionLocation);
     STUB_SET_RETURN_ADDRESS(handler.catchRoutine);
     return handler.callFrame;

trunk/Source/JavaScriptCore/jit/JITStubs.h

-              r148639
+              r148696
 class FunctionExecutable;
 class Identifier;
 class JSGlobalData;
+class VM;
 class JSGlobalObject;
 class JSObject;
 …
     void* unused1;
     void* unused2;
     JSGlobalData* globalData;
+    VM* vm;
     void* savedRBX;
 …
     // Passed on the stack
     void* unused2;
     JSGlobalData* globalData;
+    VM* vm;
     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
 …
     void* unused1;
     void* unused2;
     JSGlobalData* globalData;
+    VM* vm;
     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
 …
     // These arguments passed on the stack.
     void* unused1;
     JSGlobalData* globalData;
+    VM* vm;
     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
 …
     // These arguments passed on the stack.
     void* unused2;
     JSGlobalData* globalData;
+    VM* vm;
     // When JIT code makes a call, it pushes its return address just below the rest of the stack.
 …
     // These arguments passed on the stack.
     void* unused2;
     JSGlobalData* globalData;
+    VM* vm;
     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
 …
     JSValue* exception;
     void* unused1;
     JSGlobalData* globalData;
+    VM* vm;
     ReturnAddressPtr* returnAddressSlot() { return &thunkReturnAddress; }
 …
 extern "C" void ctiVMThrowTrampoline();
 extern "C" void ctiOpThrowNotCaught();
 extern "C" EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*);
+extern "C" EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*);
 #if ENABLE(DFG_JIT)
 extern "C" void ctiTrampolineEnd();
 …
 #endif
 void performPlatformSpecificJITAssertions(JSGlobalData*);
+void performPlatformSpecificJITAssertions(VM*);
 extern "C" {
 …
 struct JITStackFrame {
     JSGlobalData* globalData;
+    VM* vm;
 };

trunk/Source/JavaScriptCore/jit/JITThunks.cpp

-              r139004
+              r148696
 #include "Executable.h"
 #include "JIT.h"
 #include "JSGlobalData.h"
+#include "VM.h"
 #include "Operations.h"
 …
+}
 MacroAssemblerCodePtr JITThunks::ctiNativeCall(JSGlobalData* globalData)
+MacroAssemblerCodePtr JITThunks::ctiNativeCall(VM* vm)
+{
 #if ENABLE(LLINT)
     if (!globalData->canUseJIT())
+    if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_call_trampoline);
 #endif
     return ctiStub(globalData, nativeCallGenerator).code();
+    return ctiStub(vm, nativeCallGenerator).code();
+}
 MacroAssemblerCodePtr JITThunks::ctiNativeConstruct(JSGlobalData* globalData)
+MacroAssemblerCodePtr JITThunks::ctiNativeConstruct(VM* vm)
+{
 #if ENABLE(LLINT)
     if (!globalData->canUseJIT())
+    if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_construct_trampoline);
 #endif
     return ctiStub(globalData, nativeConstructGenerator).code();
+    return ctiStub(vm, nativeConstructGenerator).code();
+}
 MacroAssemblerCodeRef JITThunks::ctiStub(JSGlobalData* globalData, ThunkGenerator generator)
+MacroAssemblerCodeRef JITThunks::ctiStub(VM* vm, ThunkGenerator generator)
+{
     CTIStubMap::AddResult entry = m_ctiStubMap.add(generator, MacroAssemblerCodeRef());
     if (entry.isNewEntry)
         entry.iterator->value = generator(globalData);
+        entry.iterator->value = generator(vm);
     return entry.iterator->value;
+}
 NativeExecutable* JITThunks::hostFunctionStub(JSGlobalData* globalData, NativeFunction function, NativeFunction constructor)
+NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, NativeFunction constructor)
+{
     if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(function))
         return nativeExecutable;
     NativeExecutable* nativeExecutable = NativeExecutable::create(*globalData, JIT::compileCTINativeCall(globalData, function), function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(globalData)), constructor, NoIntrinsic);
+    NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, JIT::compileCTINativeCall(vm, function), function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), constructor, NoIntrinsic);
     weakAdd(*m_hostFunctionStubMap, function, PassWeak<NativeExecutable>(nativeExecutable));
     return nativeExecutable;
+}
 NativeExecutable* JITThunks::hostFunctionStub(JSGlobalData* globalData, NativeFunction function, ThunkGenerator generator, Intrinsic intrinsic)
+NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, ThunkGenerator generator, Intrinsic intrinsic)
+{
     if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(function))
 …
     MacroAssemblerCodeRef code;
     if (generator) {
         if (globalData->canUseJIT())
             code = generator(globalData);
+        if (vm->canUseJIT())
+            code = generator(vm);
         else
             code = MacroAssemblerCodeRef();
     } else
         code = JIT::compileCTINativeCall(globalData, function);
+        code = JIT::compileCTINativeCall(vm, function);
     NativeExecutable* nativeExecutable = NativeExecutable::create(*globalData, code, function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(globalData)), callHostFunctionAsConstructor, intrinsic);
+    NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, code, function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), callHostFunctionAsConstructor, intrinsic);
     weakAdd(*m_hostFunctionStubMap, function, PassWeak<NativeExecutable>(nativeExecutable));
     return nativeExecutable;

trunk/Source/JavaScriptCore/jit/JITThunks.h

-              r147962
+              r148696
 namespace JSC {
 class JSGlobalData;
+class VM;
 class NativeExecutable;
 …
     ~JITThunks();
     MacroAssemblerCodePtr ctiNativeCall(JSGlobalData*);
     MacroAssemblerCodePtr ctiNativeConstruct(JSGlobalData*);
+    MacroAssemblerCodePtr ctiNativeCall(VM*);
+    MacroAssemblerCodePtr ctiNativeConstruct(VM*);
     MacroAssemblerCodeRef ctiStub(JSGlobalData*, ThunkGenerator);
+    MacroAssemblerCodeRef ctiStub(VM*, ThunkGenerator);
     NativeExecutable* hostFunctionStub(JSGlobalData*, NativeFunction, NativeFunction constructor);
     NativeExecutable* hostFunctionStub(JSGlobalData*, NativeFunction, ThunkGenerator, Intrinsic);
+    NativeExecutable* hostFunctionStub(VM*, NativeFunction, NativeFunction constructor);
+    NativeExecutable* hostFunctionStub(VM*, NativeFunction, ThunkGenerator, Intrinsic);
     void clearHostFunctionStubs();

trunk/Source/JavaScriptCore/jit/JITWriteBarrier.h

r143147	r148696
37	37
38	38	class JSCell;
39		class ~~JSGlobalData~~;
	39	class VM;
40	40
41	41	// Needs to be even to appease some of the backends.
…	…
78	78	}
79	79
80		void set(~~JSGlobalData~~&, CodeLocationDataLabelPtr location, JSCell* owner, JSCell* value)
	80	void set(VM&, CodeLocationDataLabelPtr location, JSCell* owner, JSCell* value)
81	81	{
82	82	Heap::writeBarrier(owner, value);
…	…
117	117	}
118	118
119		void set(~~JSGlobalData& globalData~~, CodeLocationDataLabelPtr location, JSCell* owner, T* value)
	119	void set(VM& vm, CodeLocationDataLabelPtr location, JSCell* owner, T* value)
120	120	{
121	121	validateCell(owner);
122	122	validateCell(value);
123		JITWriteBarrierBase::set(~~globalData~~, location, owner, value);
	123	JITWriteBarrierBase::set(vm, location, owner, value);
124	124	}
125		void set(~~JSGlobalData& globalData~~, JSCell* owner, T* value)
	125	void set(VM& vm, JSCell* owner, T* value)
126	126	{
127		set(~~globalData~~, location(), owner, value);
	127	set(vm, location(), owner, value);
128	128	}
129	129	T* get() const

trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

r131858	r148696
56	56	}
57	57
58		void loadJSStringArgument(~~JSGlobalData& globalData~~, int argument, RegisterID dst)
	58	void loadJSStringArgument(VM& vm, int argument, RegisterID dst)
59	59	{
60	60	loadCellArgument(argument, dst);
61		m_failures.append(branchPtr(NotEqual, Address(dst, JSCell::structureOffset()), TrustedImmPtr(~~globalData~~.stringStructure.get())));
	61	m_failures.append(branchPtr(NotEqual, Address(dst, JSCell::structureOffset()), TrustedImmPtr(vm.stringStructure.get())));
62	62	}
63	63
…	…
131	131	}
132	132
133		MacroAssemblerCodeRef finalize(~~JSGlobalData& globalData~~, MacroAssemblerCodePtr fallback, const char* thunkKind)
	133	MacroAssemblerCodeRef finalize(VM& vm, MacroAssemblerCodePtr fallback, const char* thunkKind)
134	134	{
135		LinkBuffer patchBuffer(~~globalData~~, this, GLOBAL_THUNK_ID);
	135	LinkBuffer patchBuffer(vm, this, GLOBAL_THUNK_ID);
136	136	patchBuffer.link(m_failures, CodeLocationLabel(fallback));
137	137	for (unsigned i = 0; i < m_calls.size(); i++)

trunk/Source/JavaScriptCore/jit/ThunkGenerator.h

-              r138465
+              r148696
 namespace JSC {
 class JSGlobalData;
+class VM;
 class MacroAssemblerCodeRef;
 typedef MacroAssemblerCodeRef (*ThunkGenerator)(JSGlobalData*);
+typedef MacroAssemblerCodeRef (*ThunkGenerator)(VM*);
 } // namespace JSC

trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

-              r144043
+              r148696
 namespace JSC {
 static JSInterfaceJIT::Call generateSlowCaseFor(JSGlobalData* globalData, JSInterfaceJIT& jit)
+static JSInterfaceJIT::Call generateSlowCaseFor(VM* vm, JSInterfaceJIT& jit)
+{
     jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, JSInterfaceJIT::regT2);
 …
     jit.emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
     jit.storePtr(JSInterfaceJIT::callFrameRegister, &globalData->topCallFrame);
+    jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
     jit.restoreArgumentReference();
     JSInterfaceJIT::Call callNotJSFunction = jit.call();
 …
+}
 static MacroAssemblerCodeRef linkForGenerator(JSGlobalData* globalData, FunctionPtr lazyLink, FunctionPtr notJSFunction, const char* name)
+static MacroAssemblerCodeRef linkForGenerator(VM* vm, FunctionPtr lazyLink, FunctionPtr notJSFunction, const char* name)
+{
     JSInterfaceJIT jit;
 …
     jit.emitPutToCallFrameHeader(JSInterfaceJIT::regT3, JSStack::ReturnPC);
     jit.storePtr(JSInterfaceJIT::callFrameRegister, &globalData->topCallFrame);
+    jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
     jit.restoreArgumentReference();
     JSInterfaceJIT::Call callLazyLink = jit.call();
 …
     slowCase.link(&jit);
     JSInterfaceJIT::Call callNotJSFunction = generateSlowCaseFor(globalData, jit);
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    JSInterfaceJIT::Call callNotJSFunction = generateSlowCaseFor(vm, jit);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     patchBuffer.link(callLazyLink, lazyLink);
     patchBuffer.link(callNotJSFunction, notJSFunction);
 …
+}
 MacroAssemblerCodeRef linkCallGenerator(JSGlobalData* globalData)
+{
     return linkForGenerator(globalData, FunctionPtr(cti_vm_lazyLinkCall), FunctionPtr(cti_op_call_NotJSFunction), "call");
+}
 MacroAssemblerCodeRef linkConstructGenerator(JSGlobalData* globalData)
+{
     return linkForGenerator(globalData, FunctionPtr(cti_vm_lazyLinkConstruct), FunctionPtr(cti_op_construct_NotJSConstruct), "construct");
+}
 MacroAssemblerCodeRef linkClosureCallGenerator(JSGlobalData* globalData)
+{
     return linkForGenerator(globalData, FunctionPtr(cti_vm_lazyLinkClosureCall), FunctionPtr(cti_op_call_NotJSFunction), "closure call");
+}
 static MacroAssemblerCodeRef virtualForGenerator(JSGlobalData* globalData, FunctionPtr compile, FunctionPtr notJSFunction, const char* name, CodeSpecializationKind kind)
+MacroAssemblerCodeRef linkCallGenerator(VM* vm)
+{
+    return linkForGenerator(vm, FunctionPtr(cti_vm_lazyLinkCall), FunctionPtr(cti_op_call_NotJSFunction), "call");
+}
+MacroAssemblerCodeRef linkConstructGenerator(VM* vm)
+{
+    return linkForGenerator(vm, FunctionPtr(cti_vm_lazyLinkConstruct), FunctionPtr(cti_op_construct_NotJSConstruct), "construct");
+}
+MacroAssemblerCodeRef linkClosureCallGenerator(VM* vm)
+{
+    return linkForGenerator(vm, FunctionPtr(cti_vm_lazyLinkClosureCall), FunctionPtr(cti_op_call_NotJSFunction), "closure call");
+}
+static MacroAssemblerCodeRef virtualForGenerator(VM* vm, FunctionPtr compile, FunctionPtr notJSFunction, const char* name, CodeSpecializationKind kind)
+{
     JSInterfaceJIT jit;
 …
     JSInterfaceJIT::Jump hasCodeBlock1 = jit.branch32(JSInterfaceJIT::GreaterThanOrEqual, JSInterfaceJIT::Address(JSInterfaceJIT::regT2, FunctionExecutable::offsetOfNumParametersFor(kind)), JSInterfaceJIT::TrustedImm32(0));
     jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3);
     jit.storePtr(JSInterfaceJIT::callFrameRegister, &globalData->topCallFrame);
+    jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
     jit.restoreArgumentReference();
     JSInterfaceJIT::Call callCompile = jit.call();
 …
     slowCase.link(&jit);
     JSInterfaceJIT::Call callNotJSFunction = generateSlowCaseFor(globalData, jit);
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    JSInterfaceJIT::Call callNotJSFunction = generateSlowCaseFor(vm, jit);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     patchBuffer.link(callCompile, compile);
     patchBuffer.link(callNotJSFunction, notJSFunction);
 …
+}
 MacroAssemblerCodeRef virtualCallGenerator(JSGlobalData* globalData)
+{
     return virtualForGenerator(globalData, FunctionPtr(cti_op_call_jitCompile), FunctionPtr(cti_op_call_NotJSFunction), "call", CodeForCall);
+}
 MacroAssemblerCodeRef virtualConstructGenerator(JSGlobalData* globalData)
+{
     return virtualForGenerator(globalData, FunctionPtr(cti_op_construct_jitCompile), FunctionPtr(cti_op_construct_NotJSConstruct), "construct", CodeForConstruct);
+}
 MacroAssemblerCodeRef stringLengthTrampolineGenerator(JSGlobalData* globalData)
+MacroAssemblerCodeRef virtualCallGenerator(VM* vm)
+{
+    return virtualForGenerator(vm, FunctionPtr(cti_op_call_jitCompile), FunctionPtr(cti_op_call_NotJSFunction), "call", CodeForCall);
+}
+MacroAssemblerCodeRef virtualConstructGenerator(VM* vm)
+{
+    return virtualForGenerator(vm, FunctionPtr(cti_op_construct_jitCompile), FunctionPtr(cti_op_construct_NotJSConstruct), "construct", CodeForConstruct);
+}
+MacroAssemblerCodeRef stringLengthTrampolineGenerator(VM* vm)
+{
     JSInterfaceJIT jit;
 …
         JSInterfaceJIT::NotEqual, JSInterfaceJIT::Address(
             JSInterfaceJIT::regT0, JSCell::structureOffset()),
         JSInterfaceJIT::TrustedImmPtr(globalData->stringStructure.get()));
+        JSInterfaceJIT::TrustedImmPtr(vm->stringStructure.get()));
     // Checks out okay! - get the length from the Ustring.
 …
         JSInterfaceJIT::NotEqual,
         JSInterfaceJIT::Address(JSInterfaceJIT::regT0, JSCell::structureOffset()),
         JSInterfaceJIT::TrustedImmPtr(globalData->stringStructure.get()));
+        JSInterfaceJIT::TrustedImmPtr(vm->stringStructure.get()));
     // Checks out okay! - get the length from the Ustring.
 …
     JSInterfaceJIT::Call failureCases3Call = jit.makeTailRecursiveCall(failureCases3);
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     patchBuffer.link(failureCases1Call, FunctionPtr(cti_op_get_by_id_string_fail));
 …
+}
 static MacroAssemblerCodeRef nativeForGenerator(JSGlobalData* globalData, CodeSpecializationKind kind)
+static MacroAssemblerCodeRef nativeForGenerator(VM* vm, CodeSpecializationKind kind)
+{
     int executableOffsetToFunction = NativeExecutable::offsetOfNativeFunctionFor(kind);
 …
     jit.emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
     jit.storePtr(JSInterfaceJIT::callFrameRegister, &globalData->topCallFrame);
+    jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
 #if CPU(X86)
 …
     // Check for an exception
 #if USE(JSVALUE64)
     jit.load64(&(globalData->exception), JSInterfaceJIT::regT2);
+    jit.load64(&(vm->exception), JSInterfaceJIT::regT2);
     JSInterfaceJIT::Jump exceptionHandler = jit.branchTest64(JSInterfaceJIT::NonZero, JSInterfaceJIT::regT2);
 #else
     JSInterfaceJIT::Jump exceptionHandler = jit.branch32(
         JSInterfaceJIT::NotEqual,
         JSInterfaceJIT::AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)),
+        JSInterfaceJIT::AbsoluteAddress(reinterpret_cast<char*>(&vm->exception) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)),
         JSInterfaceJIT::TrustedImm32(JSValue::EmptyValueTag));
 #endif
 …
     jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT1);
     jit.move(JSInterfaceJIT::TrustedImmPtr(&globalData->exceptionLocation), JSInterfaceJIT::regT2);
+    jit.move(JSInterfaceJIT::TrustedImmPtr(&vm->exceptionLocation), JSInterfaceJIT::regT2);
     jit.storePtr(JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
     jit.poke(JSInterfaceJIT::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
     jit.storePtr(JSInterfaceJIT::callFrameRegister, &globalData->topCallFrame);
+    jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
     // Set the return address.
     jit.move(JSInterfaceJIT::TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), JSInterfaceJIT::regT1);
 …
     jit.ret();
     LinkBuffer patchBuffer(*globalData, &jit, GLOBAL_THUNK_ID);
+    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
     return FINALIZE_CODE(patchBuffer, ("native %s trampoline", toCString(kind).data()));
+}
 MacroAssemblerCodeRef nativeCallGenerator(JSGlobalData* globalData)
+{
     return nativeForGenerator(globalData, CodeForCall);
+}
 MacroAssemblerCodeRef nativeConstructGenerator(JSGlobalData* globalData)
+{
     return nativeForGenerator(globalData, CodeForConstruct);
+}
 static void stringCharLoad(SpecializedThunkJIT& jit, JSGlobalData* globalData)
+MacroAssemblerCodeRef nativeCallGenerator(VM* vm)
+{
+    return nativeForGenerator(vm, CodeForCall);
+}
+MacroAssemblerCodeRef nativeConstructGenerator(VM* vm)
+{
+    return nativeForGenerator(vm, CodeForConstruct);
+}
+static void stringCharLoad(SpecializedThunkJIT& jit, VM* vm)
+{
     // load string
     jit.loadJSStringArgument(*globalData, SpecializedThunkJIT::ThisArgument, SpecializedThunkJIT::regT0);
+    jit.loadJSStringArgument(*vm, SpecializedThunkJIT::ThisArgument, SpecializedThunkJIT::regT0);
     // Load string length to regT2, and start the process of loading the data pointer into regT0
 …
+}
 static void charToString(SpecializedThunkJIT& jit, JSGlobalData* globalData, MacroAssembler::RegisterID src, MacroAssembler::RegisterID dst, MacroAssembler::RegisterID scratch)
+static void charToString(SpecializedThunkJIT& jit, VM* vm, MacroAssembler::RegisterID src, MacroAssembler::RegisterID dst, MacroAssembler::RegisterID scratch)
+{
     jit.appendFailure(jit.branch32(MacroAssembler::AboveOrEqual, src, MacroAssembler::TrustedImm32(0x100)));
     jit.move(MacroAssembler::TrustedImmPtr(globalData->smallStrings.singleCharacterStrings()), scratch);
+    jit.move(MacroAssembler::TrustedImmPtr(vm->smallStrings.singleCharacterStrings()), scratch);
     jit.loadPtr(MacroAssembler::BaseIndex(scratch, src, MacroAssembler::ScalePtr, 0), dst);
     jit.appendFailure(jit.branchTestPtr(MacroAssembler::Zero, dst));
+}
 MacroAssemblerCodeRef charCodeAtThunkGenerator(JSGlobalData* globalData)
+{
     SpecializedThunkJIT jit(1);
     stringCharLoad(jit, globalData);
+MacroAssemblerCodeRef charCodeAtThunkGenerator(VM* vm)
+{
+    SpecializedThunkJIT jit(1);
+    stringCharLoad(jit, vm);
     jit.returnInt32(SpecializedThunkJIT::regT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "charCodeAt");
+}
 MacroAssemblerCodeRef charAtThunkGenerator(JSGlobalData* globalData)
+{
     SpecializedThunkJIT jit(1);
     stringCharLoad(jit, globalData);
     charToString(jit, globalData, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT1);
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "charCodeAt");
+}
+MacroAssemblerCodeRef charAtThunkGenerator(VM* vm)
+{
+    SpecializedThunkJIT jit(1);
+    stringCharLoad(jit, vm);
+    charToString(jit, vm, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT1);
     jit.returnJSCell(SpecializedThunkJIT::regT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "charAt");
+}
 MacroAssemblerCodeRef fromCharCodeThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "charAt");
+}
+MacroAssemblerCodeRef fromCharCodeThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     // load char code
     jit.loadInt32Argument(0, SpecializedThunkJIT::regT0);
     charToString(jit, globalData, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT1);
+    charToString(jit, vm, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT0, SpecializedThunkJIT::regT1);
     jit.returnJSCell(SpecializedThunkJIT::regT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "fromCharCode");
+}
 MacroAssemblerCodeRef sqrtThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "fromCharCode");
+}
+MacroAssemblerCodeRef sqrtThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     if (!jit.supportsFloatingPointSqrt())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     jit.loadDoubleArgument(0, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0);
     jit.sqrtDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT0);
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "sqrt");
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "sqrt");
+}
 …
 static const double halfConstant = 0.5;
 MacroAssemblerCodeRef floorThunkGenerator(JSGlobalData* globalData)
+MacroAssemblerCodeRef floorThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     MacroAssembler::Jump nonIntJump;
     if (!UnaryDoubleOpWrapper(floor) || !jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     jit.loadInt32Argument(0, SpecializedThunkJIT::regT0, nonIntJump);
     jit.returnInt32(SpecializedThunkJIT::regT0);
 …
     doubleResult.link(&jit);
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "floor");
+}
 MacroAssemblerCodeRef ceilThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "floor");
+}
+MacroAssemblerCodeRef ceilThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     if (!UnaryDoubleOpWrapper(ceil) || !jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     MacroAssembler::Jump nonIntJump;
     jit.loadInt32Argument(0, SpecializedThunkJIT::regT0, nonIntJump);
 …
     doubleResult.link(&jit);
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "ceil");
+}
 MacroAssemblerCodeRef roundThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "ceil");
+}
+MacroAssemblerCodeRef roundThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     if (!UnaryDoubleOpWrapper(jsRound) || !jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     MacroAssembler::Jump nonIntJump;
     jit.loadInt32Argument(0, SpecializedThunkJIT::regT0, nonIntJump);
 …
     doubleResult.link(&jit);
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "round");
+}
 MacroAssemblerCodeRef expThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "round");
+}
+MacroAssemblerCodeRef expThunkGenerator(VM* vm)
+{
     if (!UnaryDoubleOpWrapper(exp))
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     SpecializedThunkJIT jit(1);
     if (!jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     jit.loadDoubleArgument(0, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0);
     jit.callDoubleToDouble(UnaryDoubleOpWrapper(exp));
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "exp");
+}
 MacroAssemblerCodeRef logThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "exp");
+}
+MacroAssemblerCodeRef logThunkGenerator(VM* vm)
+{
     if (!UnaryDoubleOpWrapper(log))
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     SpecializedThunkJIT jit(1);
     if (!jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     jit.loadDoubleArgument(0, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0);
     jit.callDoubleToDouble(UnaryDoubleOpWrapper(log));
     jit.returnDouble(SpecializedThunkJIT::fpRegT0);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "log");
+}
 MacroAssemblerCodeRef absThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "log");
+}
+MacroAssemblerCodeRef absThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(1);
     if (!jit.supportsFloatingPointAbs())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     MacroAssembler::Jump nonIntJump;
     jit.loadInt32Argument(0, SpecializedThunkJIT::regT0, nonIntJump);
 …
     jit.absDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1);
     jit.returnDouble(SpecializedThunkJIT::fpRegT1);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "abs");
+}
 MacroAssemblerCodeRef powThunkGenerator(JSGlobalData* globalData)
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "abs");
+}
+MacroAssemblerCodeRef powThunkGenerator(VM* vm)
+{
     SpecializedThunkJIT jit(2);
     if (!jit.supportsFloatingPoint())
         return MacroAssemblerCodeRef::createSelfManagedCodeRef(globalData->jitStubs->ctiNativeCall(globalData));
+        return MacroAssemblerCodeRef::createSelfManagedCodeRef(vm->jitStubs->ctiNativeCall(vm));
     jit.loadDouble(&oneConstant, SpecializedThunkJIT::fpRegT1);
 …
         jit.appendFailure(nonIntExponent);
     return jit.finalize(*globalData, globalData->jitStubs->ctiNativeCall(globalData), "pow");
+    return jit.finalize(*vm, vm->jitStubs->ctiNativeCall(vm), "pow");
+}

trunk/Source/JavaScriptCore/jit/ThunkGenerators.h

-              r138609
+              r148696
 namespace JSC {
 MacroAssemblerCodeRef linkCallGenerator(JSGlobalData*);
 MacroAssemblerCodeRef linkConstructGenerator(JSGlobalData*);
 MacroAssemblerCodeRef linkClosureCallGenerator(JSGlobalData*);
 MacroAssemblerCodeRef virtualCallGenerator(JSGlobalData*);
 MacroAssemblerCodeRef virtualConstructGenerator(JSGlobalData*);
 MacroAssemblerCodeRef stringLengthTrampolineGenerator(JSGlobalData*);
 MacroAssemblerCodeRef nativeCallGenerator(JSGlobalData*);
 MacroAssemblerCodeRef nativeConstructGenerator(JSGlobalData*);
+MacroAssemblerCodeRef linkCallGenerator(VM*);
+MacroAssemblerCodeRef linkConstructGenerator(VM*);
+MacroAssemblerCodeRef linkClosureCallGenerator(VM*);
+MacroAssemblerCodeRef virtualCallGenerator(VM*);
+MacroAssemblerCodeRef virtualConstructGenerator(VM*);
+MacroAssemblerCodeRef stringLengthTrampolineGenerator(VM*);
+MacroAssemblerCodeRef nativeCallGenerator(VM*);
+MacroAssemblerCodeRef nativeConstructGenerator(VM*);
 MacroAssemblerCodeRef charCodeAtThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef charAtThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef fromCharCodeThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef absThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef ceilThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef expThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef floorThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef logThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef roundThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef sqrtThunkGenerator(JSGlobalData*);
 MacroAssemblerCodeRef powThunkGenerator(JSGlobalData*);
+MacroAssemblerCodeRef charCodeAtThunkGenerator(VM*);
+MacroAssemblerCodeRef charAtThunkGenerator(VM*);
+MacroAssemblerCodeRef fromCharCodeThunkGenerator(VM*);
+MacroAssemblerCodeRef absThunkGenerator(VM*);
+MacroAssemblerCodeRef ceilThunkGenerator(VM*);
+MacroAssemblerCodeRef expThunkGenerator(VM*);
+MacroAssemblerCodeRef floorThunkGenerator(VM*);
+MacroAssemblerCodeRef logThunkGenerator(VM*);
+MacroAssemblerCodeRef roundThunkGenerator(VM*);
+MacroAssemblerCodeRef sqrtThunkGenerator(VM*);
+MacroAssemblerCodeRef powThunkGenerator(VM*);
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 148696 in webkit for trunk/Source/JavaScriptCore/jit

Legend:

Download in other formats: