Rename CONCURRENT_JIT/ConcurrentJIT to CONCURRENT_JS/ConcurrentJS
https://bugs.webkit.org/show_bug.cgi?id=164791
Reviewed by Geoffrey Garen.
Source/JavaScriptCore:
Just renaming.
* JavaScriptCore.xcodeproj/project.pbxproj:
* bytecode/ArrayProfile.cpp:
(JSC::ArrayProfile::computeUpdatedPrediction):
(JSC::ArrayProfile::briefDescription):
(JSC::ArrayProfile::briefDescriptionWithoutUpdating):
* bytecode/ArrayProfile.h:
(JSC::ArrayProfile::observedArrayModes):
(JSC::ArrayProfile::mayInterceptIndexedAccesses):
(JSC::ArrayProfile::mayStoreToHole):
(JSC::ArrayProfile::outOfBounds):
(JSC::ArrayProfile::usesOriginalArrayStructures):
* bytecode/CallLinkStatus.cpp:
(JSC::CallLinkStatus::computeFromLLInt):
(JSC::CallLinkStatus::computeFor):
(JSC::CallLinkStatus::computeExitSiteData):
(JSC::CallLinkStatus::computeFromCallLinkInfo):
(JSC::CallLinkStatus::computeDFGStatuses):
* bytecode/CallLinkStatus.h:
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::dumpValueProfiling):
(JSC::CodeBlock::dumpArrayProfiling):
(JSC::CodeBlock::finishCreation):
(JSC::CodeBlock::setConstantRegisters):
(JSC::CodeBlock::getStubInfoMap):
(JSC::CodeBlock::getCallLinkInfoMap):
(JSC::CodeBlock::getByValInfoMap):
(JSC::CodeBlock::addStubInfo):
(JSC::CodeBlock::addByValInfo):
(JSC::CodeBlock::addCallLinkInfo):
(JSC::CodeBlock::resetJITData):
(JSC::CodeBlock::shrinkToFit):
(JSC::CodeBlock::getArrayProfile):
(JSC::CodeBlock::addArrayProfile):
(JSC::CodeBlock::getOrAddArrayProfile):
(JSC::CodeBlock::updateAllPredictionsAndCountLiveness):
(JSC::CodeBlock::updateAllArrayPredictions):
(JSC::CodeBlock::nameForRegister):
(JSC::CodeBlock::livenessAnalysisSlow):
* bytecode/CodeBlock.h:
(JSC::CodeBlock::setJITCode):
(JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):
(JSC::CodeBlock::addFrequentExitSite):
(JSC::CodeBlock::hasExitSite):
(JSC::CodeBlock::livenessAnalysis):
* bytecode/DFGExitProfile.cpp:
(JSC::DFG::ExitProfile::add):
(JSC::DFG::ExitProfile::hasExitSite):
(JSC::DFG::QueryableExitProfile::initialize):
* bytecode/DFGExitProfile.h:
(JSC::DFG::ExitProfile::hasExitSite):
* bytecode/GetByIdStatus.cpp:
(JSC::GetByIdStatus::hasExitSite):
(JSC::GetByIdStatus::computeFor):
(JSC::GetByIdStatus::computeForStubInfo):
(JSC::GetByIdStatus::computeForStubInfoWithoutExitSiteFeedback):
* bytecode/GetByIdStatus.h:
* bytecode/LazyOperandValueProfile.cpp:
(JSC::CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions):
(JSC::CompressedLazyOperandValueProfileHolder::add):
(JSC::LazyOperandValueProfileParser::initialize):
(JSC::LazyOperandValueProfileParser::prediction):
* bytecode/LazyOperandValueProfile.h:
* bytecode/MethodOfGettingAValueProfile.cpp:
(JSC::MethodOfGettingAValueProfile::emitReportValue):
* bytecode/PutByIdStatus.cpp:
(JSC::PutByIdStatus::hasExitSite):
(JSC::PutByIdStatus::computeFor):
(JSC::PutByIdStatus::computeForStubInfo):
* bytecode/PutByIdStatus.h:
* bytecode/StructureStubClearingWatchpoint.cpp:
(JSC::StructureStubClearingWatchpoint::fireInternal):
* bytecode/ValueProfile.h:
(JSC::ValueProfileBase::briefDescription):
(JSC::ValueProfileBase::computeUpdatedPrediction):
* dfg/DFGArrayMode.cpp:
(JSC::DFG::ArrayMode::fromObserved):
* dfg/DFGArrayMode.h:
(JSC::DFG::ArrayMode::withSpeculationFromProfile):
(JSC::DFG::ArrayMode::withProfile):
* dfg/DFGByteCodeParser.cpp:
(JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
(JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
(JSC::DFG::ByteCodeParser::getArrayMode):
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
* dfg/DFGDriver.cpp:
(JSC::DFG::compileImpl):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::attemptToMakeGetArrayLength):
* dfg/DFGGraph.cpp:
(JSC::DFG::Graph::tryGetConstantClosureVar):
* dfg/DFGObjectAllocationSinkingPhase.cpp:
* dfg/DFGPredictionInjectionPhase.cpp:
(JSC::DFG::PredictionInjectionPhase::run):
* ftl/FTLLowerDFGToB3.cpp:
(JSC::FTL::DFG::LowerDFGToB3::compileMaterializeCreateActivation):
* ftl/FTLOperations.cpp:
(JSC::FTL::operationMaterializeObjectInOSR):
* heap/Heap.cpp:
(JSC::Heap::addToRememberedSet):
* jit/JIT.cpp:
(JSC::JIT::compileWithoutLinking):
* jit/JITInlines.h:
(JSC::JIT::chooseArrayMode):
* jit/JITOperations.cpp:
(JSC::tryGetByValOptimize):
* jit/JITPropertyAccess.cpp:
(JSC::JIT::privateCompileGetByValWithCachedId):
(JSC::JIT::privateCompilePutByValWithCachedId):
* jit/JITWorklist.cpp:
(JSC::JITWorklist::compileLater):
(JSC::JITWorklist::compileNow):
* jit/Repatch.cpp:
(JSC::repatchGetByID):
(JSC::repatchPutByID):
* llint/LLIntSlowPaths.cpp:
(JSC::LLInt::setupGetByIdPrototypeCache):
(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::setUpCall):
* profiler/ProfilerBytecodeSequence.cpp:
(JSC::Profiler::BytecodeSequence::BytecodeSequence):
* runtime/CommonSlowPaths.cpp:
(JSC::SLOW_PATH_DECL):
* runtime/CommonSlowPaths.h:
(JSC::CommonSlowPaths::tryCachePutToScopeGlobal):
(JSC::CommonSlowPaths::tryCacheGetFromScopeGlobal):
* runtime/ConcurrentJITLock.h: Removed.
* runtime/ConcurrentJSLock.h: Copied from Source/JavaScriptCore/runtime/ConcurrentJITLock.h.
(JSC::ConcurrentJSLockerBase::ConcurrentJSLockerBase):
(JSC::ConcurrentJSLockerBase::~ConcurrentJSLockerBase):
(JSC::GCSafeConcurrentJSLocker::GCSafeConcurrentJSLocker):
(JSC::GCSafeConcurrentJSLocker::~GCSafeConcurrentJSLocker):
(JSC::ConcurrentJSLocker::ConcurrentJSLocker):
(JSC::ConcurrentJITLockerBase::ConcurrentJITLockerBase): Deleted.
(JSC::ConcurrentJITLockerBase::~ConcurrentJITLockerBase): Deleted.
(JSC::ConcurrentJITLockerBase::unlockEarly): Deleted.
(JSC::GCSafeConcurrentJITLocker::GCSafeConcurrentJITLocker): Deleted.
(JSC::GCSafeConcurrentJITLocker::~GCSafeConcurrentJITLocker): Deleted.
(JSC::ConcurrentJITLocker::ConcurrentJITLocker): Deleted.
* runtime/InferredType.cpp:
(JSC::InferredType::canWatch):
(JSC::InferredType::addWatchpoint):
(JSC::InferredType::willStoreValueSlow):
(JSC::InferredType::makeTopSlow):
(JSC::InferredType::set):
(JSC::InferredType::removeStructure):
* runtime/InferredType.h:
* runtime/InferredTypeTable.cpp:
(JSC::InferredTypeTable::visitChildren):
(JSC::InferredTypeTable::get):
(JSC::InferredTypeTable::willStoreValue):
(JSC::InferredTypeTable::makeTop):
* runtime/InferredTypeTable.h:
* runtime/JSEnvironmentRecord.cpp:
(JSC::JSEnvironmentRecord::heapSnapshot):
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::addGlobalVar):
(JSC::JSGlobalObject::addStaticGlobals):
* runtime/JSLexicalEnvironment.cpp:
(JSC::JSLexicalEnvironment::getOwnNonIndexPropertyNames):
* runtime/JSObject.cpp:
(JSC::JSObject::deleteProperty):
(JSC::JSObject::shiftButterflyAfterFlattening):
* runtime/JSObject.h:
* runtime/JSObjectInlines.h:
(JSC::JSObject::putDirectWithoutTransition):
(JSC::JSObject::putDirectInternal):
* runtime/JSScope.cpp:
(JSC::abstractAccess):
(JSC::JSScope::collectClosureVariablesUnderTDZ):
* runtime/JSSegmentedVariableObject.cpp:
(JSC::JSSegmentedVariableObject::findVariableIndex):
(JSC::JSSegmentedVariableObject::addVariables):
(JSC::JSSegmentedVariableObject::heapSnapshot):
* runtime/JSSegmentedVariableObject.h:
* runtime/JSSymbolTableObject.cpp:
(JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
* runtime/JSSymbolTableObject.h:
(JSC::symbolTableGet):
(JSC::symbolTablePut):
* runtime/Options.cpp:
(JSC::recomputeDependentOptions):
* runtime/Options.h:
* runtime/ProgramExecutable.cpp:
(JSC::ProgramExecutable::initializeGlobalProperties):
* runtime/RegExp.cpp:
(JSC::RegExp::compile):
(JSC::RegExp::matchConcurrently):
(JSC::RegExp::compileMatchOnly):
(JSC::RegExp::deleteCode):
* runtime/RegExp.h:
* runtime/Structure.cpp:
(JSC::Structure::materializePropertyTable):
(JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
(JSC::Structure::addNewPropertyTransition):
(JSC::Structure::takePropertyTableOrCloneIfPinned):
(JSC::Structure::nonPropertyTransition):
(JSC::Structure::flattenDictionaryStructure):
(JSC::Structure::ensurePropertyReplacementWatchpointSet):
(JSC::Structure::add):
(JSC::Structure::remove):
(JSC::Structure::visitChildren):
* runtime/Structure.h:
* runtime/StructureInlines.h:
(JSC::Structure::propertyReplacementWatchpointSet):
(JSC::Structure::add):
(JSC::Structure::remove):
* runtime/SymbolTable.cpp:
(JSC::SymbolTable::visitChildren):
(JSC::SymbolTable::localToEntry):
(JSC::SymbolTable::entryFor):
(JSC::SymbolTable::prepareForTypeProfiling):
(JSC::SymbolTable::uniqueIDForVariable):
(JSC::SymbolTable::uniqueIDForOffset):
(JSC::SymbolTable::globalTypeSetForOffset):
(JSC::SymbolTable::globalTypeSetForVariable):
* runtime/SymbolTable.h:
* runtime/TypeSet.cpp:
(JSC::TypeSet::addTypeInformation):
(JSC::TypeSet::invalidateCache):
* runtime/TypeSet.h:
(JSC::TypeSet::structureSet):
* runtime/VM.h:
* runtime/WriteBarrierInlines.h:
(JSC::WriteBarrierBase<T>::set):
(JSC::WriteBarrierBase<Unknown>::set):
* yarr/YarrInterpreter.cpp:
(JSC::Yarr::ByteCompiler::compile):
(JSC::Yarr::byteCompile):
* yarr/YarrInterpreter.h:
(JSC::Yarr::BytecodePattern::BytecodePattern):
Source/WTF:
Both the concurrent GC and the concurrent JIT rely on concurrency support in fundamental
JSC runtime components like JSValue. So, the thing that guards it should be a "feature"
called CONCURRENT_JS not CONCURRENT_JIT.
* wtf/Platform.h:
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@208761 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
index 77c1d86..a50a2ba 100644
--- a/Source/JavaScriptCore/ChangeLog
+++ b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,246 @@
+2016-11-15 Filip Pizlo <fpizlo@apple.com>
+
+ Rename CONCURRENT_JIT/ConcurrentJIT to CONCURRENT_JS/ConcurrentJS
+ https://bugs.webkit.org/show_bug.cgi?id=164791
+
+ Reviewed by Geoffrey Garen.
+
+ Just renaming.
+
+ * JavaScriptCore.xcodeproj/project.pbxproj:
+ * bytecode/ArrayProfile.cpp:
+ (JSC::ArrayProfile::computeUpdatedPrediction):
+ (JSC::ArrayProfile::briefDescription):
+ (JSC::ArrayProfile::briefDescriptionWithoutUpdating):
+ * bytecode/ArrayProfile.h:
+ (JSC::ArrayProfile::observedArrayModes):
+ (JSC::ArrayProfile::mayInterceptIndexedAccesses):
+ (JSC::ArrayProfile::mayStoreToHole):
+ (JSC::ArrayProfile::outOfBounds):
+ (JSC::ArrayProfile::usesOriginalArrayStructures):
+ * bytecode/CallLinkStatus.cpp:
+ (JSC::CallLinkStatus::computeFromLLInt):
+ (JSC::CallLinkStatus::computeFor):
+ (JSC::CallLinkStatus::computeExitSiteData):
+ (JSC::CallLinkStatus::computeFromCallLinkInfo):
+ (JSC::CallLinkStatus::computeDFGStatuses):
+ * bytecode/CallLinkStatus.h:
+ * bytecode/CodeBlock.cpp:
+ (JSC::CodeBlock::dumpValueProfiling):
+ (JSC::CodeBlock::dumpArrayProfiling):
+ (JSC::CodeBlock::finishCreation):
+ (JSC::CodeBlock::setConstantRegisters):
+ (JSC::CodeBlock::getStubInfoMap):
+ (JSC::CodeBlock::getCallLinkInfoMap):
+ (JSC::CodeBlock::getByValInfoMap):
+ (JSC::CodeBlock::addStubInfo):
+ (JSC::CodeBlock::addByValInfo):
+ (JSC::CodeBlock::addCallLinkInfo):
+ (JSC::CodeBlock::resetJITData):
+ (JSC::CodeBlock::shrinkToFit):
+ (JSC::CodeBlock::getArrayProfile):
+ (JSC::CodeBlock::addArrayProfile):
+ (JSC::CodeBlock::getOrAddArrayProfile):
+ (JSC::CodeBlock::updateAllPredictionsAndCountLiveness):
+ (JSC::CodeBlock::updateAllArrayPredictions):
+ (JSC::CodeBlock::nameForRegister):
+ (JSC::CodeBlock::livenessAnalysisSlow):
+ * bytecode/CodeBlock.h:
+ (JSC::CodeBlock::setJITCode):
+ (JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):
+ (JSC::CodeBlock::addFrequentExitSite):
+ (JSC::CodeBlock::hasExitSite):
+ (JSC::CodeBlock::livenessAnalysis):
+ * bytecode/DFGExitProfile.cpp:
+ (JSC::DFG::ExitProfile::add):
+ (JSC::DFG::ExitProfile::hasExitSite):
+ (JSC::DFG::QueryableExitProfile::initialize):
+ * bytecode/DFGExitProfile.h:
+ (JSC::DFG::ExitProfile::hasExitSite):
+ * bytecode/GetByIdStatus.cpp:
+ (JSC::GetByIdStatus::hasExitSite):
+ (JSC::GetByIdStatus::computeFor):
+ (JSC::GetByIdStatus::computeForStubInfo):
+ (JSC::GetByIdStatus::computeForStubInfoWithoutExitSiteFeedback):
+ * bytecode/GetByIdStatus.h:
+ * bytecode/LazyOperandValueProfile.cpp:
+ (JSC::CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions):
+ (JSC::CompressedLazyOperandValueProfileHolder::add):
+ (JSC::LazyOperandValueProfileParser::initialize):
+ (JSC::LazyOperandValueProfileParser::prediction):
+ * bytecode/LazyOperandValueProfile.h:
+ * bytecode/MethodOfGettingAValueProfile.cpp:
+ (JSC::MethodOfGettingAValueProfile::emitReportValue):
+ * bytecode/PutByIdStatus.cpp:
+ (JSC::PutByIdStatus::hasExitSite):
+ (JSC::PutByIdStatus::computeFor):
+ (JSC::PutByIdStatus::computeForStubInfo):
+ * bytecode/PutByIdStatus.h:
+ * bytecode/StructureStubClearingWatchpoint.cpp:
+ (JSC::StructureStubClearingWatchpoint::fireInternal):
+ * bytecode/ValueProfile.h:
+ (JSC::ValueProfileBase::briefDescription):
+ (JSC::ValueProfileBase::computeUpdatedPrediction):
+ * dfg/DFGArrayMode.cpp:
+ (JSC::DFG::ArrayMode::fromObserved):
+ * dfg/DFGArrayMode.h:
+ (JSC::DFG::ArrayMode::withSpeculationFromProfile):
+ (JSC::DFG::ArrayMode::withProfile):
+ * dfg/DFGByteCodeParser.cpp:
+ (JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
+ (JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
+ (JSC::DFG::ByteCodeParser::getArrayMode):
+ (JSC::DFG::ByteCodeParser::handleInlining):
+ (JSC::DFG::ByteCodeParser::parseBlock):
+ (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
+ * dfg/DFGDriver.cpp:
+ (JSC::DFG::compileImpl):
+ * dfg/DFGFixupPhase.cpp:
+ (JSC::DFG::FixupPhase::fixupNode):
+ (JSC::DFG::FixupPhase::attemptToMakeGetArrayLength):
+ * dfg/DFGGraph.cpp:
+ (JSC::DFG::Graph::tryGetConstantClosureVar):
+ * dfg/DFGObjectAllocationSinkingPhase.cpp:
+ * dfg/DFGPredictionInjectionPhase.cpp:
+ (JSC::DFG::PredictionInjectionPhase::run):
+ * ftl/FTLLowerDFGToB3.cpp:
+ (JSC::FTL::DFG::LowerDFGToB3::compileMaterializeCreateActivation):
+ * ftl/FTLOperations.cpp:
+ (JSC::FTL::operationMaterializeObjectInOSR):
+ * heap/Heap.cpp:
+ (JSC::Heap::addToRememberedSet):
+ * jit/JIT.cpp:
+ (JSC::JIT::compileWithoutLinking):
+ * jit/JITInlines.h:
+ (JSC::JIT::chooseArrayMode):
+ * jit/JITOperations.cpp:
+ (JSC::tryGetByValOptimize):
+ * jit/JITPropertyAccess.cpp:
+ (JSC::JIT::privateCompileGetByValWithCachedId):
+ (JSC::JIT::privateCompilePutByValWithCachedId):
+ * jit/JITWorklist.cpp:
+ (JSC::JITWorklist::compileLater):
+ (JSC::JITWorklist::compileNow):
+ * jit/Repatch.cpp:
+ (JSC::repatchGetByID):
+ (JSC::repatchPutByID):
+ * llint/LLIntSlowPaths.cpp:
+ (JSC::LLInt::setupGetByIdPrototypeCache):
+ (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+ (JSC::LLInt::setUpCall):
+ * profiler/ProfilerBytecodeSequence.cpp:
+ (JSC::Profiler::BytecodeSequence::BytecodeSequence):
+ * runtime/CommonSlowPaths.cpp:
+ (JSC::SLOW_PATH_DECL):
+ * runtime/CommonSlowPaths.h:
+ (JSC::CommonSlowPaths::tryCachePutToScopeGlobal):
+ (JSC::CommonSlowPaths::tryCacheGetFromScopeGlobal):
+ * runtime/ConcurrentJITLock.h: Removed.
+ * runtime/ConcurrentJSLock.h: Copied from Source/JavaScriptCore/runtime/ConcurrentJITLock.h.
+ (JSC::ConcurrentJSLockerBase::ConcurrentJSLockerBase):
+ (JSC::ConcurrentJSLockerBase::~ConcurrentJSLockerBase):
+ (JSC::GCSafeConcurrentJSLocker::GCSafeConcurrentJSLocker):
+ (JSC::GCSafeConcurrentJSLocker::~GCSafeConcurrentJSLocker):
+ (JSC::ConcurrentJSLocker::ConcurrentJSLocker):
+ (JSC::ConcurrentJITLockerBase::ConcurrentJITLockerBase): Deleted.
+ (JSC::ConcurrentJITLockerBase::~ConcurrentJITLockerBase): Deleted.
+ (JSC::ConcurrentJITLockerBase::unlockEarly): Deleted.
+ (JSC::GCSafeConcurrentJITLocker::GCSafeConcurrentJITLocker): Deleted.
+ (JSC::GCSafeConcurrentJITLocker::~GCSafeConcurrentJITLocker): Deleted.
+ (JSC::ConcurrentJITLocker::ConcurrentJITLocker): Deleted.
+ * runtime/InferredType.cpp:
+ (JSC::InferredType::canWatch):
+ (JSC::InferredType::addWatchpoint):
+ (JSC::InferredType::willStoreValueSlow):
+ (JSC::InferredType::makeTopSlow):
+ (JSC::InferredType::set):
+ (JSC::InferredType::removeStructure):
+ * runtime/InferredType.h:
+ * runtime/InferredTypeTable.cpp:
+ (JSC::InferredTypeTable::visitChildren):
+ (JSC::InferredTypeTable::get):
+ (JSC::InferredTypeTable::willStoreValue):
+ (JSC::InferredTypeTable::makeTop):
+ * runtime/InferredTypeTable.h:
+ * runtime/JSEnvironmentRecord.cpp:
+ (JSC::JSEnvironmentRecord::heapSnapshot):
+ * runtime/JSGlobalObject.cpp:
+ (JSC::JSGlobalObject::addGlobalVar):
+ (JSC::JSGlobalObject::addStaticGlobals):
+ * runtime/JSLexicalEnvironment.cpp:
+ (JSC::JSLexicalEnvironment::getOwnNonIndexPropertyNames):
+ * runtime/JSObject.cpp:
+ (JSC::JSObject::deleteProperty):
+ (JSC::JSObject::shiftButterflyAfterFlattening):
+ * runtime/JSObject.h:
+ * runtime/JSObjectInlines.h:
+ (JSC::JSObject::putDirectWithoutTransition):
+ (JSC::JSObject::putDirectInternal):
+ * runtime/JSScope.cpp:
+ (JSC::abstractAccess):
+ (JSC::JSScope::collectClosureVariablesUnderTDZ):
+ * runtime/JSSegmentedVariableObject.cpp:
+ (JSC::JSSegmentedVariableObject::findVariableIndex):
+ (JSC::JSSegmentedVariableObject::addVariables):
+ (JSC::JSSegmentedVariableObject::heapSnapshot):
+ * runtime/JSSegmentedVariableObject.h:
+ * runtime/JSSymbolTableObject.cpp:
+ (JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
+ * runtime/JSSymbolTableObject.h:
+ (JSC::symbolTableGet):
+ (JSC::symbolTablePut):
+ * runtime/Options.cpp:
+ (JSC::recomputeDependentOptions):
+ * runtime/Options.h:
+ * runtime/ProgramExecutable.cpp:
+ (JSC::ProgramExecutable::initializeGlobalProperties):
+ * runtime/RegExp.cpp:
+ (JSC::RegExp::compile):
+ (JSC::RegExp::matchConcurrently):
+ (JSC::RegExp::compileMatchOnly):
+ (JSC::RegExp::deleteCode):
+ * runtime/RegExp.h:
+ * runtime/Structure.cpp:
+ (JSC::Structure::materializePropertyTable):
+ (JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
+ (JSC::Structure::addNewPropertyTransition):
+ (JSC::Structure::takePropertyTableOrCloneIfPinned):
+ (JSC::Structure::nonPropertyTransition):
+ (JSC::Structure::flattenDictionaryStructure):
+ (JSC::Structure::ensurePropertyReplacementWatchpointSet):
+ (JSC::Structure::add):
+ (JSC::Structure::remove):
+ (JSC::Structure::visitChildren):
+ * runtime/Structure.h:
+ * runtime/StructureInlines.h:
+ (JSC::Structure::propertyReplacementWatchpointSet):
+ (JSC::Structure::add):
+ (JSC::Structure::remove):
+ * runtime/SymbolTable.cpp:
+ (JSC::SymbolTable::visitChildren):
+ (JSC::SymbolTable::localToEntry):
+ (JSC::SymbolTable::entryFor):
+ (JSC::SymbolTable::prepareForTypeProfiling):
+ (JSC::SymbolTable::uniqueIDForVariable):
+ (JSC::SymbolTable::uniqueIDForOffset):
+ (JSC::SymbolTable::globalTypeSetForOffset):
+ (JSC::SymbolTable::globalTypeSetForVariable):
+ * runtime/SymbolTable.h:
+ * runtime/TypeSet.cpp:
+ (JSC::TypeSet::addTypeInformation):
+ (JSC::TypeSet::invalidateCache):
+ * runtime/TypeSet.h:
+ (JSC::TypeSet::structureSet):
+ * runtime/VM.h:
+ * runtime/WriteBarrierInlines.h:
+ (JSC::WriteBarrierBase<T>::set):
+ (JSC::WriteBarrierBase<Unknown>::set):
+ * yarr/YarrInterpreter.cpp:
+ (JSC::Yarr::ByteCompiler::compile):
+ (JSC::Yarr::byteCompile):
+ * yarr/YarrInterpreter.h:
+ (JSC::Yarr::BytecodePattern::BytecodePattern):
+
2016-11-15 Joseph Pecoraro <pecoraro@apple.com>
Web Inspector: Remove unused and untested Page.setTouchEmulationEnabled command
diff --git a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
index cb8339e..8308c7d 100644
--- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
+++ b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
@@ -743,7 +743,7 @@
0FDB2CCA173DA523007B3C1B /* FTLValueFromBlock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDB2CC8173DA51E007B3C1B /* FTLValueFromBlock.h */; settings = {ATTRIBUTES = (Private, ); }; };
0FDB2CE7174830A2007B3C1B /* DFGWorklist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FDB2CE5174830A2007B3C1B /* DFGWorklist.cpp */; };
0FDB2CE8174830A2007B3C1B /* DFGWorklist.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDB2CE6174830A2007B3C1B /* DFGWorklist.h */; };
- 0FDB2CEA174896C7007B3C1B /* ConcurrentJITLock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDB2CE9174896C7007B3C1B /* ConcurrentJITLock.h */; settings = {ATTRIBUTES = (Private, ); }; };
+ 0FDB2CEA174896C7007B3C1B /* ConcurrentJSLock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDB2CE9174896C7007B3C1B /* ConcurrentJSLock.h */; settings = {ATTRIBUTES = (Private, ); }; };
0FDDBFB51666EED800C55FEF /* DFGVariableAccessDataDump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FDDBFB21666EED500C55FEF /* DFGVariableAccessDataDump.cpp */; };
0FDDBFB61666EEDA00C55FEF /* DFGVariableAccessDataDump.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDDBFB31666EED500C55FEF /* DFGVariableAccessDataDump.h */; };
0FDF67D21D9C6D27001B9825 /* B3Kind.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FDF67D11D9C6086001B9825 /* B3Kind.h */; };
@@ -3157,7 +3157,7 @@
0FDB2CC8173DA51E007B3C1B /* FTLValueFromBlock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FTLValueFromBlock.h; path = ftl/FTLValueFromBlock.h; sourceTree = "<group>"; };
0FDB2CE5174830A2007B3C1B /* DFGWorklist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGWorklist.cpp; path = dfg/DFGWorklist.cpp; sourceTree = "<group>"; };
0FDB2CE6174830A2007B3C1B /* DFGWorklist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGWorklist.h; path = dfg/DFGWorklist.h; sourceTree = "<group>"; };
- 0FDB2CE9174896C7007B3C1B /* ConcurrentJITLock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConcurrentJITLock.h; sourceTree = "<group>"; };
+ 0FDB2CE9174896C7007B3C1B /* ConcurrentJSLock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConcurrentJSLock.h; sourceTree = "<group>"; };
0FDDBFB21666EED500C55FEF /* DFGVariableAccessDataDump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGVariableAccessDataDump.cpp; path = dfg/DFGVariableAccessDataDump.cpp; sourceTree = "<group>"; };
0FDDBFB31666EED500C55FEF /* DFGVariableAccessDataDump.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGVariableAccessDataDump.h; path = dfg/DFGVariableAccessDataDump.h; sourceTree = "<group>"; };
0FDF67D01D9C6086001B9825 /* B3Kind.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = B3Kind.cpp; path = b3/B3Kind.cpp; sourceTree = "<group>"; };
@@ -6113,7 +6113,7 @@
A7E5A3A61797432D00E893C0 /* CompilationResult.h */,
969A09220ED1E09C00F1F681 /* Completion.cpp */,
F5BB2BC5030F772101FCFE1D /* Completion.h */,
- 0FDB2CE9174896C7007B3C1B /* ConcurrentJITLock.h */,
+ 0FDB2CE9174896C7007B3C1B /* ConcurrentJSLock.h */,
A5B6A74C18C6DBA600F11E91 /* ConsoleClient.cpp */,
A53CE08918BC21C300BEDF76 /* ConsoleClient.h */,
A55714BC1CD8048E0004D2C6 /* ConsoleObject.cpp */,
@@ -7875,7 +7875,7 @@
A7E5A3A81797432D00E893C0 /* CompilationResult.h in Headers */,
BC18C3F40E16F5CD00B34460 /* Completion.h in Headers */,
0F6FC751196110A800E1D02D /* ComplexGetStatus.h in Headers */,
- 0FDB2CEA174896C7007B3C1B /* ConcurrentJITLock.h in Headers */,
+ 0FDB2CEA174896C7007B3C1B /* ConcurrentJSLock.h in Headers */,
BC18C3F50E16F5CD00B34460 /* config.h in Headers */,
144836E7132DA7BE005BE785 /* ConservativeRoots.h in Headers */,
A53CE08A18BC21C300BEDF76 /* ConsoleClient.h in Headers */,
diff --git a/Source/JavaScriptCore/bytecode/ArrayProfile.cpp b/Source/JavaScriptCore/bytecode/ArrayProfile.cpp
index b8ade22..3146b18 100644
--- a/Source/JavaScriptCore/bytecode/ArrayProfile.cpp
+++ b/Source/JavaScriptCore/bytecode/ArrayProfile.cpp
@@ -94,7 +94,7 @@
out.print(comma, "Float64ArrayMode");
}
-void ArrayProfile::computeUpdatedPrediction(const ConcurrentJITLocker& locker, CodeBlock* codeBlock)
+void ArrayProfile::computeUpdatedPrediction(const ConcurrentJSLocker& locker, CodeBlock* codeBlock)
{
if (!m_lastSeenStructureID)
return;
@@ -104,7 +104,7 @@
m_lastSeenStructureID = 0;
}
-void ArrayProfile::computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock* codeBlock, Structure* lastSeenStructure)
+void ArrayProfile::computeUpdatedPrediction(const ConcurrentJSLocker&, CodeBlock* codeBlock, Structure* lastSeenStructure)
{
m_observedArrayModes |= arrayModeFromStructure(lastSeenStructure);
@@ -122,13 +122,13 @@
m_usesOriginalArrayStructures = false;
}
-CString ArrayProfile::briefDescription(const ConcurrentJITLocker& locker, CodeBlock* codeBlock)
+CString ArrayProfile::briefDescription(const ConcurrentJSLocker& locker, CodeBlock* codeBlock)
{
computeUpdatedPrediction(locker, codeBlock);
return briefDescriptionWithoutUpdating(locker);
}
-CString ArrayProfile::briefDescriptionWithoutUpdating(const ConcurrentJITLocker&)
+CString ArrayProfile::briefDescriptionWithoutUpdating(const ConcurrentJSLocker&)
{
StringPrintStream out;
diff --git a/Source/JavaScriptCore/bytecode/ArrayProfile.h b/Source/JavaScriptCore/bytecode/ArrayProfile.h
index 2f2ac59..279906d 100644
--- a/Source/JavaScriptCore/bytecode/ArrayProfile.h
+++ b/Source/JavaScriptCore/bytecode/ArrayProfile.h
@@ -25,7 +25,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "JSArray.h"
#include "Structure.h"
#include <wtf/SegmentedVector.h>
@@ -216,19 +216,19 @@
m_lastSeenStructureID = structure->id();
}
- void computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock*);
- void computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock*, Structure* lastSeenStructure);
+ void computeUpdatedPrediction(const ConcurrentJSLocker&, CodeBlock*);
+ void computeUpdatedPrediction(const ConcurrentJSLocker&, CodeBlock*, Structure* lastSeenStructure);
- ArrayModes observedArrayModes(const ConcurrentJITLocker&) const { return m_observedArrayModes; }
- bool mayInterceptIndexedAccesses(const ConcurrentJITLocker&) const { return m_mayInterceptIndexedAccesses; }
+ ArrayModes observedArrayModes(const ConcurrentJSLocker&) const { return m_observedArrayModes; }
+ bool mayInterceptIndexedAccesses(const ConcurrentJSLocker&) const { return m_mayInterceptIndexedAccesses; }
- bool mayStoreToHole(const ConcurrentJITLocker&) const { return m_mayStoreToHole; }
- bool outOfBounds(const ConcurrentJITLocker&) const { return m_outOfBounds; }
+ bool mayStoreToHole(const ConcurrentJSLocker&) const { return m_mayStoreToHole; }
+ bool outOfBounds(const ConcurrentJSLocker&) const { return m_outOfBounds; }
- bool usesOriginalArrayStructures(const ConcurrentJITLocker&) const { return m_usesOriginalArrayStructures; }
+ bool usesOriginalArrayStructures(const ConcurrentJSLocker&) const { return m_usesOriginalArrayStructures; }
- CString briefDescription(const ConcurrentJITLocker&, CodeBlock*);
- CString briefDescriptionWithoutUpdating(const ConcurrentJITLocker&);
+ CString briefDescription(const ConcurrentJSLocker&, CodeBlock*);
+ CString briefDescriptionWithoutUpdating(const ConcurrentJSLocker&);
private:
friend class LLIntOffsetsExtractor;
diff --git a/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp b/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
index faaf711..cbc555d 100644
--- a/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
+++ b/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
@@ -52,7 +52,7 @@
m_variants.append(CallVariant(value.asCell()));
}
-CallLinkStatus CallLinkStatus::computeFromLLInt(const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
+CallLinkStatus CallLinkStatus::computeFromLLInt(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
{
UNUSED_PARAM(profiledBlock);
UNUSED_PARAM(bytecodeIndex);
@@ -81,7 +81,7 @@
CallLinkStatus CallLinkStatus::computeFor(
CodeBlock* profiledBlock, unsigned bytecodeIndex, const CallLinkInfoMap& map)
{
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
UNUSED_PARAM(profiledBlock);
UNUSED_PARAM(bytecodeIndex);
@@ -103,7 +103,7 @@
}
CallLinkStatus::ExitSiteData CallLinkStatus::computeExitSiteData(
- const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
+ const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
{
ExitSiteData exitSiteData;
@@ -124,7 +124,7 @@
#if ENABLE(JIT)
CallLinkStatus CallLinkStatus::computeFor(
- const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo)
+ const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo)
{
// We don't really need this, but anytime we have to debug this code, it becomes indispensable.
UNUSED_PARAM(profiledBlock);
@@ -135,7 +135,7 @@
}
CallLinkStatus CallLinkStatus::computeFromCallLinkInfo(
- const ConcurrentJITLocker&, CallLinkInfo& callLinkInfo)
+ const ConcurrentJSLocker&, CallLinkInfo& callLinkInfo)
{
if (callLinkInfo.clearedByGC())
return takesSlowPath();
@@ -228,7 +228,7 @@
}
CallLinkStatus CallLinkStatus::computeFor(
- const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo,
+ const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, CallLinkInfo& callLinkInfo,
ExitSiteData exitSiteData)
{
CallLinkStatus result = computeFor(locker, profiledBlock, callLinkInfo);
@@ -277,13 +277,13 @@
baselineCodeBlockForOriginAndBaselineCodeBlock(codeOrigin, baselineCodeBlock);
ExitSiteData exitSiteData;
{
- ConcurrentJITLocker locker(currentBaseline->m_lock);
+ ConcurrentJSLocker locker(currentBaseline->m_lock);
exitSiteData = computeExitSiteData(
locker, currentBaseline, codeOrigin.bytecodeIndex);
}
{
- ConcurrentJITLocker locker(dfgCodeBlock->m_lock);
+ ConcurrentJSLocker locker(dfgCodeBlock->m_lock);
map.add(info.codeOrigin(), computeFor(locker, dfgCodeBlock, info, exitSiteData));
}
}
diff --git a/Source/JavaScriptCore/bytecode/CallLinkStatus.h b/Source/JavaScriptCore/bytecode/CallLinkStatus.h
index fe471594..353deaa 100644
--- a/Source/JavaScriptCore/bytecode/CallLinkStatus.h
+++ b/Source/JavaScriptCore/bytecode/CallLinkStatus.h
@@ -29,7 +29,7 @@
#include "CallVariant.h"
#include "CodeOrigin.h"
#include "CodeSpecializationKind.h"
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ExitingJITType.h"
#include "Intrinsic.h"
#include "JSCJSValue.h"
@@ -70,14 +70,14 @@
bool takesSlowPath { false };
bool badFunction { false };
};
- static ExitSiteData computeExitSiteData(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
+ static ExitSiteData computeExitSiteData(const ConcurrentJSLocker&, CodeBlock*, unsigned bytecodeIndex);
#if ENABLE(JIT)
// Computes the status assuming that we never took slow path and never previously
// exited.
- static CallLinkStatus computeFor(const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&);
+ static CallLinkStatus computeFor(const ConcurrentJSLocker&, CodeBlock*, CallLinkInfo&);
static CallLinkStatus computeFor(
- const ConcurrentJITLocker&, CodeBlock*, CallLinkInfo&, ExitSiteData);
+ const ConcurrentJSLocker&, CodeBlock*, CallLinkInfo&, ExitSiteData);
#endif
typedef HashMap<CodeOrigin, CallLinkStatus, CodeOriginApproximateHash> ContextMap;
@@ -118,10 +118,10 @@
private:
void makeClosureCall();
- static CallLinkStatus computeFromLLInt(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
+ static CallLinkStatus computeFromLLInt(const ConcurrentJSLocker&, CodeBlock*, unsigned bytecodeIndex);
#if ENABLE(JIT)
static CallLinkStatus computeFromCallLinkInfo(
- const ConcurrentJITLocker&, CallLinkInfo&);
+ const ConcurrentJSLocker&, CallLinkInfo&);
#endif
CallVariantList m_variants;
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
index 30ab028..fbd8549 100644
--- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -679,7 +679,7 @@
void CodeBlock::dumpValueProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
++it;
CString description = it->u.profile->briefDescription(locker);
@@ -691,7 +691,7 @@
void CodeBlock::dumpArrayProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
++it;
if (!it->u.arrayProfile)
@@ -1964,7 +1964,7 @@
if (UnlinkedModuleProgramCodeBlock* unlinkedModuleProgramCodeBlock = jsDynamicCast<UnlinkedModuleProgramCodeBlock*>(unlinkedCodeBlock)) {
SymbolTable* clonedSymbolTable = jsCast<ModuleProgramExecutable*>(ownerExecutable)->moduleEnvironmentSymbolTable();
if (m_vm->typeProfiler()) {
- ConcurrentJITLocker locker(clonedSymbolTable->m_lock);
+ ConcurrentJSLocker locker(clonedSymbolTable->m_lock);
clonedSymbolTable->prepareForTypeProfiling(locker);
}
replaceConstant(unlinkedModuleProgramCodeBlock->moduleEnvironmentSymbolTableConstantRegisterOffset(), clonedSymbolTable);
@@ -2219,7 +2219,7 @@
int symbolTableIndex = pc[5].u.operand;
SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex));
const Identifier& ident = identifier(pc[2].u.operand);
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto iter = symbolTable->find(locker, ident.impl());
ASSERT(iter != symbolTable->end(locker));
iter->value.prepareToWatch();
@@ -2275,7 +2275,7 @@
UniquedStringImpl* impl = (op.type == ModuleVar) ? op.importedName.get() : ident.impl();
if (symbolTable) {
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
// If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet.
symbolTable->prepareForTypeProfiling(locker);
globalVariableID = symbolTable->uniqueIDForVariable(locker, impl, vm);
@@ -2289,7 +2289,7 @@
int symbolTableIndex = pc[2].u.operand;
SymbolTable* symbolTable = jsCast<SymbolTable*>(getConstant(symbolTableIndex));
const Identifier& ident = identifier(pc[4].u.operand);
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
// If our parent scope was created while profiling was disabled, it will not have prepared for profiling yet.
globalVariableID = symbolTable->uniqueIDForVariable(locker, ident.impl(), vm);
globalTypeSet = symbolTable->globalTypeSetForVariable(locker, ident.impl(), vm);
@@ -2457,7 +2457,7 @@
if (!constant.isEmpty()) {
if (SymbolTable* symbolTable = jsDynamicCast<SymbolTable*>(constant)) {
if (hasTypeProfiler) {
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
symbolTable->prepareForTypeProfiling(locker);
}
@@ -2973,7 +2973,7 @@
#endif
}
-void CodeBlock::getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result)
+void CodeBlock::getStubInfoMap(const ConcurrentJSLocker&, StubInfoMap& result)
{
#if ENABLE(JIT)
if (JITCode::isJIT(jitType()))
@@ -2985,11 +2985,11 @@
void CodeBlock::getStubInfoMap(StubInfoMap& result)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
getStubInfoMap(locker, result);
}
-void CodeBlock::getCallLinkInfoMap(const ConcurrentJITLocker&, CallLinkInfoMap& result)
+void CodeBlock::getCallLinkInfoMap(const ConcurrentJSLocker&, CallLinkInfoMap& result)
{
#if ENABLE(JIT)
if (JITCode::isJIT(jitType()))
@@ -3001,11 +3001,11 @@
void CodeBlock::getCallLinkInfoMap(CallLinkInfoMap& result)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
getCallLinkInfoMap(locker, result);
}
-void CodeBlock::getByValInfoMap(const ConcurrentJITLocker&, ByValInfoMap& result)
+void CodeBlock::getByValInfoMap(const ConcurrentJSLocker&, ByValInfoMap& result)
{
#if ENABLE(JIT)
if (JITCode::isJIT(jitType())) {
@@ -3019,14 +3019,14 @@
void CodeBlock::getByValInfoMap(ByValInfoMap& result)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
getByValInfoMap(locker, result);
}
#if ENABLE(JIT)
StructureStubInfo* CodeBlock::addStubInfo(AccessType accessType)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return m_stubInfos.add(accessType);
}
@@ -3061,13 +3061,13 @@
ByValInfo* CodeBlock::addByValInfo()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return m_byValInfos.add();
}
CallLinkInfo* CodeBlock::addCallLinkInfo()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return m_callLinkInfos.add();
}
@@ -3083,7 +3083,7 @@
void CodeBlock::resetJITData()
{
RELEASE_ASSERT(!JITCode::isJIT(jitType()));
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
// We can clear these because no other thread will have references to any stub infos, call
// link infos, or by val infos if we don't have JIT code. Attempts to query these data
@@ -3313,7 +3313,7 @@
void CodeBlock::shrinkToFit(ShrinkMode shrinkMode)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
m_rareCaseProfiles.shrinkToFit();
@@ -3975,7 +3975,7 @@
}
#endif
-ArrayProfile* CodeBlock::getArrayProfile(const ConcurrentJITLocker&, unsigned bytecodeOffset)
+ArrayProfile* CodeBlock::getArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset)
{
for (unsigned i = 0; i < m_arrayProfiles.size(); ++i) {
if (m_arrayProfiles[i].bytecodeOffset() == bytecodeOffset)
@@ -3986,11 +3986,11 @@
ArrayProfile* CodeBlock::getArrayProfile(unsigned bytecodeOffset)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return getArrayProfile(locker, bytecodeOffset);
}
-ArrayProfile* CodeBlock::addArrayProfile(const ConcurrentJITLocker&, unsigned bytecodeOffset)
+ArrayProfile* CodeBlock::addArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset)
{
m_arrayProfiles.append(ArrayProfile(bytecodeOffset));
return &m_arrayProfiles.last();
@@ -3998,11 +3998,11 @@
ArrayProfile* CodeBlock::addArrayProfile(unsigned bytecodeOffset)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return addArrayProfile(locker, bytecodeOffset);
}
-ArrayProfile* CodeBlock::getOrAddArrayProfile(const ConcurrentJITLocker& locker, unsigned bytecodeOffset)
+ArrayProfile* CodeBlock::getOrAddArrayProfile(const ConcurrentJSLocker& locker, unsigned bytecodeOffset)
{
ArrayProfile* result = getArrayProfile(locker, bytecodeOffset);
if (result)
@@ -4012,7 +4012,7 @@
ArrayProfile* CodeBlock::getOrAddArrayProfile(unsigned bytecodeOffset)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return getOrAddArrayProfile(locker, bytecodeOffset);
}
@@ -4042,7 +4042,7 @@
void CodeBlock::updateAllPredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
numberOfLiveNonArgumentValueProfiles = 0;
numberOfSamplesInProfiles = 0; // If this divided by ValueProfile::numberOfBuckets equals numberOfValueProfiles() then value profiles are full.
@@ -4074,7 +4074,7 @@
void CodeBlock::updateAllArrayPredictions()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
for (unsigned i = m_arrayProfiles.size(); i--;)
m_arrayProfiles[i].computeUpdatedPrediction(locker, this);
@@ -4284,7 +4284,7 @@
if (m_constantRegisters[i].get().isEmpty())
continue;
if (SymbolTable* symbolTable = jsDynamicCast<SymbolTable*>(m_constantRegisters[i].get())) {
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto end = symbolTable->end(locker);
for (auto ptr = symbolTable->begin(locker); ptr != end; ++ptr) {
if (ptr->value.varOffset() == VarOffset(virtualRegister)) {
@@ -4636,7 +4636,7 @@
{
std::unique_ptr<BytecodeLivenessAnalysis> analysis = std::make_unique<BytecodeLivenessAnalysis>(this);
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!m_livenessAnalysis)
m_livenessAnalysis = WTFMove(analysis);
return *m_livenessAnalysis;
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.h b/Source/JavaScriptCore/bytecode/CodeBlock.h
index c180f56..819834b 100644
--- a/Source/JavaScriptCore/bytecode/CodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.h
@@ -38,7 +38,7 @@
#include "CodeOrigin.h"
#include "CodeType.h"
#include "CompactJITCodeMap.h"
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "DFGCommon.h"
#include "DFGExitProfile.h"
#include "DeferredCompilationCallback.h"
@@ -235,13 +235,13 @@
Optional<unsigned> bytecodeOffsetFromCallSiteIndex(CallSiteIndex);
- void getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result);
+ void getStubInfoMap(const ConcurrentJSLocker&, StubInfoMap& result);
void getStubInfoMap(StubInfoMap& result);
- void getCallLinkInfoMap(const ConcurrentJITLocker&, CallLinkInfoMap& result);
+ void getCallLinkInfoMap(const ConcurrentJSLocker&, CallLinkInfoMap& result);
void getCallLinkInfoMap(CallLinkInfoMap& result);
- void getByValInfoMap(const ConcurrentJITLocker&, ByValInfoMap& result);
+ void getByValInfoMap(const ConcurrentJSLocker&, ByValInfoMap& result);
void getByValInfoMap(ByValInfoMap& result);
#if ENABLE(JIT)
@@ -322,7 +322,7 @@
{
ASSERT(heap()->isDeferred());
heap()->reportExtraMemoryAllocated(code->size());
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
WTF::storeStoreFence(); // This is probably not needed because the lock will also do something similar, but it's good to be paranoid.
m_jitCode = code;
}
@@ -413,7 +413,7 @@
unsigned numberOfValueProfiles() { return m_valueProfiles.size(); }
ValueProfile* valueProfile(int index) { return &m_valueProfiles[index]; }
ValueProfile* valueProfileForBytecodeOffset(int bytecodeOffset);
- SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJITLocker& locker, int bytecodeOffset)
+ SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJSLocker& locker, int bytecodeOffset)
{
if (ValueProfile* valueProfile = valueProfileForBytecodeOffset(bytecodeOffset))
return valueProfile->computeUpdatedPrediction(locker);
@@ -459,11 +459,11 @@
unsigned numberOfArrayProfiles() const { return m_arrayProfiles.size(); }
const ArrayProfileVector& arrayProfiles() { return m_arrayProfiles; }
- ArrayProfile* addArrayProfile(const ConcurrentJITLocker&, unsigned bytecodeOffset);
+ ArrayProfile* addArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
ArrayProfile* addArrayProfile(unsigned bytecodeOffset);
- ArrayProfile* getArrayProfile(const ConcurrentJITLocker&, unsigned bytecodeOffset);
+ ArrayProfile* getArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
ArrayProfile* getArrayProfile(unsigned bytecodeOffset);
- ArrayProfile* getOrAddArrayProfile(const ConcurrentJITLocker&, unsigned bytecodeOffset);
+ ArrayProfile* getOrAddArrayProfile(const ConcurrentJSLocker&, unsigned bytecodeOffset);
ArrayProfile* getOrAddArrayProfile(unsigned bytecodeOffset);
// Exception handling support
@@ -497,17 +497,17 @@
bool addFrequentExitSite(const DFG::FrequentExitSite& site)
{
ASSERT(JITCode::isBaselineCode(jitType()));
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return m_exitProfile.add(locker, this, site);
}
- bool hasExitSite(const ConcurrentJITLocker& locker, const DFG::FrequentExitSite& site) const
+ bool hasExitSite(const ConcurrentJSLocker& locker, const DFG::FrequentExitSite& site) const
{
return m_exitProfile.hasExitSite(locker, site);
}
bool hasExitSite(const DFG::FrequentExitSite& site) const
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return hasExitSite(locker, site);
}
@@ -591,7 +591,7 @@
BytecodeLivenessAnalysis& livenessAnalysis()
{
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!!m_livenessAnalysis)
return *m_livenessAnalysis;
}
@@ -834,7 +834,7 @@
// Another exception to the rules is that the GC can do whatever it wants
// without holding any locks, because the GC is guaranteed to wait until any
// concurrent compilation threads finish what they're doing.
- mutable ConcurrentJITLock m_lock;
+ mutable ConcurrentJSLock m_lock;
Atomic<bool> m_visitWeaklyHasBeenCalled;
diff --git a/Source/JavaScriptCore/bytecode/DFGExitProfile.cpp b/Source/JavaScriptCore/bytecode/DFGExitProfile.cpp
index 67b9852..64fe9a3 100644
--- a/Source/JavaScriptCore/bytecode/DFGExitProfile.cpp
+++ b/Source/JavaScriptCore/bytecode/DFGExitProfile.cpp
@@ -41,7 +41,7 @@
ExitProfile::ExitProfile() { }
ExitProfile::~ExitProfile() { }
-bool ExitProfile::add(const ConcurrentJITLocker&, CodeBlock* owner, const FrequentExitSite& site)
+bool ExitProfile::add(const ConcurrentJSLocker&, CodeBlock* owner, const FrequentExitSite& site)
{
ASSERT(site.jitType() != ExitFromAnything);
@@ -85,7 +85,7 @@
return result;
}
-bool ExitProfile::hasExitSite(const ConcurrentJITLocker&, const FrequentExitSite& site) const
+bool ExitProfile::hasExitSite(const ConcurrentJSLocker&, const FrequentExitSite& site) const
{
if (!m_frequentExitSites)
return false;
@@ -100,7 +100,7 @@
QueryableExitProfile::QueryableExitProfile() { }
QueryableExitProfile::~QueryableExitProfile() { }
-void QueryableExitProfile::initialize(const ConcurrentJITLocker&, const ExitProfile& profile)
+void QueryableExitProfile::initialize(const ConcurrentJSLocker&, const ExitProfile& profile)
{
if (!profile.m_frequentExitSites)
return;
diff --git a/Source/JavaScriptCore/bytecode/DFGExitProfile.h b/Source/JavaScriptCore/bytecode/DFGExitProfile.h
index 8f37276..337e3ec 100644
--- a/Source/JavaScriptCore/bytecode/DFGExitProfile.h
+++ b/Source/JavaScriptCore/bytecode/DFGExitProfile.h
@@ -27,7 +27,7 @@
#if ENABLE(DFG_JIT)
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ExitKind.h"
#include "ExitingJITType.h"
#include <wtf/HashSet.h>
@@ -160,7 +160,7 @@
// be called a fixed number of times per recompilation. Recompilation is
// rare to begin with, and implies doing O(n) operations on the CodeBlock
// anyway.
- bool add(const ConcurrentJITLocker&, CodeBlock* owner, const FrequentExitSite&);
+ bool add(const ConcurrentJSLocker&, CodeBlock* owner, const FrequentExitSite&);
// Get the frequent exit sites for a bytecode index. This is O(n), and is
// meant to only be used from debugging/profiling code.
@@ -170,12 +170,12 @@
// in the compiler. It should be strictly cheaper than building a
// QueryableExitProfile, if you really expect this to be called infrequently
// and you believe that there are few exit sites.
- bool hasExitSite(const ConcurrentJITLocker&, const FrequentExitSite&) const;
- bool hasExitSite(const ConcurrentJITLocker& locker, ExitKind kind) const
+ bool hasExitSite(const ConcurrentJSLocker&, const FrequentExitSite&) const;
+ bool hasExitSite(const ConcurrentJSLocker& locker, ExitKind kind) const
{
return hasExitSite(locker, FrequentExitSite(kind));
}
- bool hasExitSite(const ConcurrentJITLocker& locker, unsigned bytecodeIndex, ExitKind kind) const
+ bool hasExitSite(const ConcurrentJSLocker& locker, unsigned bytecodeIndex, ExitKind kind) const
{
return hasExitSite(locker, FrequentExitSite(bytecodeIndex, kind));
}
@@ -191,7 +191,7 @@
QueryableExitProfile();
~QueryableExitProfile();
- void initialize(const ConcurrentJITLocker&, const ExitProfile&);
+ void initialize(const ConcurrentJSLocker&, const ExitProfile&);
bool hasExitSite(const FrequentExitSite& site) const
{
diff --git a/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp b/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
index 18c1c7e..a6c458c 100644
--- a/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
+++ b/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
@@ -62,7 +62,7 @@
}
#if ENABLE(DFG_JIT)
-bool GetByIdStatus::hasExitSite(const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
+bool GetByIdStatus::hasExitSite(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
{
return profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadCache))
|| profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadConstantCache));
@@ -109,7 +109,7 @@
GetByIdStatus GetByIdStatus::computeFor(CodeBlock* profiledBlock, StubInfoMap& map, unsigned bytecodeIndex, UniquedStringImpl* uid)
{
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
GetByIdStatus result;
@@ -132,7 +132,7 @@
}
#if ENABLE(DFG_JIT)
-GetByIdStatus GetByIdStatus::computeForStubInfo(const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
+GetByIdStatus GetByIdStatus::computeForStubInfo(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
{
GetByIdStatus result = GetByIdStatus::computeForStubInfoWithoutExitSiteFeedback(
locker, profiledBlock, stubInfo, uid,
@@ -146,7 +146,7 @@
#if ENABLE(JIT)
GetByIdStatus GetByIdStatus::computeForStubInfoWithoutExitSiteFeedback(
- const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, UniquedStringImpl* uid,
+ const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, UniquedStringImpl* uid,
CallLinkStatus::ExitSiteData callExitSiteData)
{
if (!stubInfo || !stubInfo->everConsidered)
@@ -298,14 +298,14 @@
if (dfgBlock) {
CallLinkStatus::ExitSiteData exitSiteData;
{
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
exitSiteData = CallLinkStatus::computeExitSiteData(
locker, profiledBlock, codeOrigin.bytecodeIndex);
}
GetByIdStatus result;
{
- ConcurrentJITLocker locker(dfgBlock->m_lock);
+ ConcurrentJSLocker locker(dfgBlock->m_lock);
result = computeForStubInfoWithoutExitSiteFeedback(
locker, dfgBlock, dfgMap.get(codeOrigin), uid, exitSiteData);
}
@@ -314,7 +314,7 @@
return result;
{
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
if (hasExitSite(locker, profiledBlock, codeOrigin.bytecodeIndex))
return GetByIdStatus(TakesSlowPath, true);
}
diff --git a/Source/JavaScriptCore/bytecode/GetByIdStatus.h b/Source/JavaScriptCore/bytecode/GetByIdStatus.h
index 02b0d26..e8aad89 100644
--- a/Source/JavaScriptCore/bytecode/GetByIdStatus.h
+++ b/Source/JavaScriptCore/bytecode/GetByIdStatus.h
@@ -27,7 +27,7 @@
#include "CallLinkStatus.h"
#include "CodeOrigin.h"
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ExitingJITType.h"
#include "GetByIdVariant.h"
@@ -75,7 +75,7 @@
static GetByIdStatus computeFor(CodeBlock* baselineBlock, CodeBlock* dfgBlock, StubInfoMap& baselineMap, StubInfoMap& dfgMap, CodeOrigin, UniquedStringImpl* uid);
#if ENABLE(DFG_JIT)
- static GetByIdStatus computeForStubInfo(const ConcurrentJITLocker&, CodeBlock* baselineBlock, StructureStubInfo*, CodeOrigin, UniquedStringImpl* uid);
+ static GetByIdStatus computeForStubInfo(const ConcurrentJSLocker&, CodeBlock* baselineBlock, StructureStubInfo*, CodeOrigin, UniquedStringImpl* uid);
#endif
State state() const { return m_state; }
@@ -102,11 +102,11 @@
private:
#if ENABLE(DFG_JIT)
- static bool hasExitSite(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
+ static bool hasExitSite(const ConcurrentJSLocker&, CodeBlock*, unsigned bytecodeIndex);
#endif
#if ENABLE(JIT)
static GetByIdStatus computeForStubInfoWithoutExitSiteFeedback(
- const ConcurrentJITLocker&, CodeBlock* profiledBlock, StructureStubInfo*,
+ const ConcurrentJSLocker&, CodeBlock* profiledBlock, StructureStubInfo*,
UniquedStringImpl* uid, CallLinkStatus::ExitSiteData);
#endif
static GetByIdStatus computeFromLLInt(CodeBlock*, unsigned bytecodeIndex, UniquedStringImpl* uid);
diff --git a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp b/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp
index de654db..0929d6f 100644
--- a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp
+++ b/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp
@@ -33,7 +33,7 @@
CompressedLazyOperandValueProfileHolder::CompressedLazyOperandValueProfileHolder() { }
CompressedLazyOperandValueProfileHolder::~CompressedLazyOperandValueProfileHolder() { }
-void CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions(const ConcurrentJITLocker& locker)
+void CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions(const ConcurrentJSLocker& locker)
{
if (!m_data)
return;
@@ -43,7 +43,7 @@
}
LazyOperandValueProfile* CompressedLazyOperandValueProfileHolder::add(
- const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key)
+ const ConcurrentJSLocker&, const LazyOperandValueProfileKey& key)
{
if (!m_data)
m_data = std::make_unique<LazyOperandValueProfile::List>();
@@ -62,7 +62,7 @@
LazyOperandValueProfileParser::~LazyOperandValueProfileParser() { }
void LazyOperandValueProfileParser::initialize(
- const ConcurrentJITLocker&, CompressedLazyOperandValueProfileHolder& holder)
+ const ConcurrentJSLocker&, CompressedLazyOperandValueProfileHolder& holder)
{
ASSERT(m_map.isEmpty());
@@ -87,7 +87,7 @@
}
SpeculatedType LazyOperandValueProfileParser::prediction(
- const ConcurrentJITLocker& locker, const LazyOperandValueProfileKey& key) const
+ const ConcurrentJSLocker& locker, const LazyOperandValueProfileKey& key) const
{
LazyOperandValueProfile* profile = getIfPresent(key);
if (!profile)
diff --git a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.h b/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.h
index 05e6a88..9c3b068 100644
--- a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.h
+++ b/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.h
@@ -25,7 +25,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ValueProfile.h"
#include "VirtualRegister.h"
#include <wtf/HashMap.h>
@@ -152,10 +152,10 @@
CompressedLazyOperandValueProfileHolder();
~CompressedLazyOperandValueProfileHolder();
- void computeUpdatedPredictions(const ConcurrentJITLocker&);
+ void computeUpdatedPredictions(const ConcurrentJSLocker&);
LazyOperandValueProfile* add(
- const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key);
+ const ConcurrentJSLocker&, const LazyOperandValueProfileKey& key);
private:
friend class LazyOperandValueProfileParser;
@@ -169,13 +169,13 @@
~LazyOperandValueProfileParser();
void initialize(
- const ConcurrentJITLocker&, CompressedLazyOperandValueProfileHolder& holder);
+ const ConcurrentJSLocker&, CompressedLazyOperandValueProfileHolder& holder);
LazyOperandValueProfile* getIfPresent(
const LazyOperandValueProfileKey& key) const;
SpeculatedType prediction(
- const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key) const;
+ const ConcurrentJSLocker&, const LazyOperandValueProfileKey& key) const;
private:
HashMap<LazyOperandValueProfileKey, LazyOperandValueProfile*> m_map;
};
diff --git a/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp b/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp
index 0795009..f479e5f 100644
--- a/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp
+++ b/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp
@@ -59,7 +59,7 @@
case LazyOperand: {
LazyOperandValueProfileKey key(u.lazyOperand.bytecodeOffset, VirtualRegister(u.lazyOperand.operand));
- ConcurrentJITLocker locker(u.lazyOperand.codeBlock->m_lock);
+ ConcurrentJSLocker locker(u.lazyOperand.codeBlock->m_lock);
LazyOperandValueProfile* profile =
u.lazyOperand.codeBlock->lazyOperandValueProfiles().add(locker, key);
jit.storeValue(regs, profile->specFailBucket(0));
diff --git a/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp b/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
index 43feef5..fc0a472 100644
--- a/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
+++ b/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
@@ -54,7 +54,7 @@
}
#if ENABLE(DFG_JIT)
-bool PutByIdStatus::hasExitSite(const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
+bool PutByIdStatus::hasExitSite(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, unsigned bytecodeIndex)
{
return profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadCache))
|| profiledBlock->hasExitSite(locker, DFG::FrequentExitSite(bytecodeIndex, BadConstantCache));
@@ -110,7 +110,7 @@
PutByIdStatus PutByIdStatus::computeFor(CodeBlock* profiledBlock, StubInfoMap& map, unsigned bytecodeIndex, UniquedStringImpl* uid)
{
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
UNUSED_PARAM(profiledBlock);
UNUSED_PARAM(bytecodeIndex);
@@ -134,7 +134,7 @@
}
#if ENABLE(JIT)
-PutByIdStatus PutByIdStatus::computeForStubInfo(const ConcurrentJITLocker& locker, CodeBlock* baselineBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
+PutByIdStatus PutByIdStatus::computeForStubInfo(const ConcurrentJSLocker& locker, CodeBlock* baselineBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
{
return computeForStubInfo(
locker, baselineBlock, stubInfo, uid,
@@ -142,7 +142,7 @@
}
PutByIdStatus PutByIdStatus::computeForStubInfo(
- const ConcurrentJITLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo,
+ const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo,
UniquedStringImpl* uid, CallLinkStatus::ExitSiteData callExitSiteData)
{
if (!stubInfo || !stubInfo->everConsidered)
@@ -266,7 +266,7 @@
if (dfgBlock) {
CallLinkStatus::ExitSiteData exitSiteData;
{
- ConcurrentJITLocker locker(baselineBlock->m_lock);
+ ConcurrentJSLocker locker(baselineBlock->m_lock);
if (hasExitSite(locker, baselineBlock, codeOrigin.bytecodeIndex))
return PutByIdStatus(TakesSlowPath);
exitSiteData = CallLinkStatus::computeExitSiteData(
@@ -275,7 +275,7 @@
PutByIdStatus result;
{
- ConcurrentJITLocker locker(dfgBlock->m_lock);
+ ConcurrentJSLocker locker(dfgBlock->m_lock);
result = computeForStubInfo(
locker, dfgBlock, dfgMap.get(codeOrigin), uid, exitSiteData);
}
diff --git a/Source/JavaScriptCore/bytecode/PutByIdStatus.h b/Source/JavaScriptCore/bytecode/PutByIdStatus.h
index 89d28e9..1dd95cd 100644
--- a/Source/JavaScriptCore/bytecode/PutByIdStatus.h
+++ b/Source/JavaScriptCore/bytecode/PutByIdStatus.h
@@ -77,7 +77,7 @@
static PutByIdStatus computeFor(CodeBlock* baselineBlock, CodeBlock* dfgBlock, StubInfoMap& baselineMap, StubInfoMap& dfgMap, CodeOrigin, UniquedStringImpl* uid);
#if ENABLE(JIT)
- static PutByIdStatus computeForStubInfo(const ConcurrentJITLocker&, CodeBlock* baselineBlock, StructureStubInfo*, CodeOrigin, UniquedStringImpl* uid);
+ static PutByIdStatus computeForStubInfo(const ConcurrentJSLocker&, CodeBlock* baselineBlock, StructureStubInfo*, CodeOrigin, UniquedStringImpl* uid);
#endif
State state() const { return m_state; }
@@ -97,11 +97,11 @@
private:
#if ENABLE(DFG_JIT)
- static bool hasExitSite(const ConcurrentJITLocker&, CodeBlock*, unsigned bytecodeIndex);
+ static bool hasExitSite(const ConcurrentJSLocker&, CodeBlock*, unsigned bytecodeIndex);
#endif
#if ENABLE(JIT)
static PutByIdStatus computeForStubInfo(
- const ConcurrentJITLocker&, CodeBlock*, StructureStubInfo*, UniquedStringImpl* uid,
+ const ConcurrentJSLocker&, CodeBlock*, StructureStubInfo*, UniquedStringImpl* uid,
CallLinkStatus::ExitSiteData);
#endif
static PutByIdStatus computeFromLLInt(CodeBlock*, unsigned bytecodeIndex, UniquedStringImpl* uid);
diff --git a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
index a8ad6c9..f27e507 100644
--- a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
+++ b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
@@ -54,7 +54,7 @@
// This will implicitly cause my own demise: stub reset removes all watchpoints.
// That works, because deleting a watchpoint removes it from the set's list, and
// the set's list traversal for firing is robust against the set changing.
- ConcurrentJITLocker locker(m_holder.codeBlock()->m_lock);
+ ConcurrentJSLocker locker(m_holder.codeBlock()->m_lock);
m_holder.stubInfo()->reset(m_holder.codeBlock());
return;
}
diff --git a/Source/JavaScriptCore/bytecode/ValueProfile.h b/Source/JavaScriptCore/bytecode/ValueProfile.h
index d5a6f74..8724eb4 100644
--- a/Source/JavaScriptCore/bytecode/ValueProfile.h
+++ b/Source/JavaScriptCore/bytecode/ValueProfile.h
@@ -28,7 +28,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "Heap.h"
#include "JSArray.h"
#include "SpeculatedType.h"
@@ -106,7 +106,7 @@
return false;
}
- CString briefDescription(const ConcurrentJITLocker& locker)
+ CString briefDescription(const ConcurrentJSLocker& locker)
{
computeUpdatedPrediction(locker);
@@ -134,7 +134,7 @@
// Updates the prediction and returns the new one. Never call this from any thread
// that isn't executing the code.
- SpeculatedType computeUpdatedPrediction(const ConcurrentJITLocker&)
+ SpeculatedType computeUpdatedPrediction(const ConcurrentJSLocker&)
{
for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
JSValue value = JSValue::decode(m_buckets[i]);
diff --git a/Source/JavaScriptCore/dfg/DFGArrayMode.cpp b/Source/JavaScriptCore/dfg/DFGArrayMode.cpp
index 92c97f2..7778bb3 100644
--- a/Source/JavaScriptCore/dfg/DFGArrayMode.cpp
+++ b/Source/JavaScriptCore/dfg/DFGArrayMode.cpp
@@ -35,7 +35,7 @@
namespace JSC { namespace DFG {
-ArrayMode ArrayMode::fromObserved(const ConcurrentJITLocker& locker, ArrayProfile* profile, Array::Action action, bool makeSafe)
+ArrayMode ArrayMode::fromObserved(const ConcurrentJSLocker& locker, ArrayProfile* profile, Array::Action action, bool makeSafe)
{
Array::Class nonArray;
if (profile->usesOriginalArrayStructures(locker))
diff --git a/Source/JavaScriptCore/dfg/DFGArrayMode.h b/Source/JavaScriptCore/dfg/DFGArrayMode.h
index 3d9efd5..45e1d5a 100644
--- a/Source/JavaScriptCore/dfg/DFGArrayMode.h
+++ b/Source/JavaScriptCore/dfg/DFGArrayMode.h
@@ -168,7 +168,7 @@
return ArrayMode(word);
}
- static ArrayMode fromObserved(const ConcurrentJITLocker&, ArrayProfile*, Array::Action, bool makeSafe);
+ static ArrayMode fromObserved(const ConcurrentJSLocker&, ArrayProfile*, Array::Action, bool makeSafe);
ArrayMode withSpeculation(Array::Speculation speculation) const
{
@@ -180,7 +180,7 @@
return ArrayMode(type(), arrayClass, speculation(), conversion());
}
- ArrayMode withSpeculationFromProfile(const ConcurrentJITLocker& locker, ArrayProfile* profile, bool makeSafe) const
+ ArrayMode withSpeculationFromProfile(const ConcurrentJSLocker& locker, ArrayProfile* profile, bool makeSafe) const
{
Array::Speculation mySpeculation;
@@ -194,7 +194,7 @@
return withSpeculation(mySpeculation);
}
- ArrayMode withProfile(const ConcurrentJITLocker& locker, ArrayProfile* profile, bool makeSafe) const
+ ArrayMode withProfile(const ConcurrentJSLocker& locker, ArrayProfile* profile, bool makeSafe) const
{
Array::Class myArrayClass;
diff --git a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
index e7a8314..2de6db0 100644
--- a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
+++ b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
@@ -407,7 +407,7 @@
{
ASSERT(node->op() == GetLocal);
ASSERT(node->origin.semantic.bytecodeIndex == m_currentIndex);
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
LazyOperandValueProfileKey key(m_currentIndex, node->local());
SpeculatedType prediction = m_inlineStackTop->m_lazyOperands.prediction(locker, key);
node->variableAccessData()->predict(prediction);
@@ -852,7 +852,7 @@
{
SpeculatedType prediction;
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
prediction = m_inlineStackTop->m_profiledBlock->valueProfilePredictionForBytecodeOffset(locker, bytecodeIndex);
}
@@ -891,7 +891,7 @@
bytecodeIndex = codeOrigin->bytecodeIndex;
CodeBlock* profiledBlock = stack->m_profiledBlock;
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
return profiledBlock->valueProfilePredictionForBytecodeOffset(locker, bytecodeIndex);
}
@@ -928,7 +928,7 @@
ArrayMode getArrayMode(ArrayProfile* profile, Array::Action action)
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
profile->computeUpdatedPrediction(locker, m_inlineStackTop->m_profiledBlock);
bool makeSafe = profile->outOfBounds(locker);
return ArrayMode::fromObserved(locker, profile, action, makeSafe);
@@ -1883,7 +1883,7 @@
// arguments received inside the callee. But that probably won't matter for most
// calls.
if (codeBlock && argument < static_cast<unsigned>(codeBlock->numParameters())) {
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
if (ValueProfile* profile = codeBlock->valueProfileForArgument(argument))
variable->predict(profile->computeUpdatedPrediction(locker));
}
@@ -4261,7 +4261,7 @@
GetByIdStatus getByIdStatus;
unsigned identifierNumber = 0;
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
ByValInfo* byValInfo = m_inlineStackTop->m_byValInfos.get(CodeOrigin(currentCodeOrigin().bytecodeIndex));
// FIXME: When the bytecode is not compiled in the baseline JIT, byValInfo becomes null.
// At that time, there is no information.
@@ -4319,7 +4319,7 @@
unsigned identifierNumber = std::numeric_limits<unsigned>::max();
PutByIdStatus putByIdStatus;
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
ByValInfo* byValInfo = m_inlineStackTop->m_byValInfos.get(CodeOrigin(currentCodeOrigin().bytecodeIndex));
// FIXME: When the bytecode is not compiled in the baseline JIT, byValInfo becomes null.
// At that time, there is no information.
@@ -4945,7 +4945,7 @@
WatchpointSet* watchpoints = 0;
uintptr_t operand;
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
watchpoints = currentInstruction[5].u.watchpointSet;
else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
@@ -4991,7 +4991,7 @@
ScopeOffset offset;
JSSegmentedVariableObject* scopeObject = jsCast<JSSegmentedVariableObject*>(JSScope::constantScopeForCodeBlock(resolveType, m_inlineStackTop->m_codeBlock));
{
- ConcurrentJITLocker locker(scopeObject->symbolTable()->m_lock);
+ ConcurrentJSLocker locker(scopeObject->symbolTable()->m_lock);
SymbolTableEntry entry = scopeObject->symbolTable()->get(locker, uid);
watchpointSet = entry.watchpointSet();
offset = entry.scopeOffset();
@@ -5114,7 +5114,7 @@
WatchpointSet* watchpoints = nullptr;
uintptr_t operand;
{
- ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
if (resolveType == GlobalVar || resolveType == GlobalVarWithVarInjectionChecks || resolveType == LocalClosureVar || resolveType == GlobalLexicalVar || resolveType == GlobalLexicalVarWithVarInjectionChecks)
watchpoints = currentInstruction[5].u.watchpointSet;
else if (resolveType != UnresolvedProperty && resolveType != UnresolvedPropertyWithVarInjectionChecks)
@@ -5552,7 +5552,7 @@
, m_caller(byteCodeParser->m_inlineStackTop)
{
{
- ConcurrentJITLocker locker(m_profiledBlock->m_lock);
+ ConcurrentJSLocker locker(m_profiledBlock->m_lock);
m_lazyOperands.initialize(locker, m_profiledBlock->lazyOperandValueProfiles());
m_exitProfile.initialize(locker, profiledBlock->exitProfile());
diff --git a/Source/JavaScriptCore/dfg/DFGDriver.cpp b/Source/JavaScriptCore/dfg/DFGDriver.cpp
index 14cd0d0..74c98ca 100644
--- a/Source/JavaScriptCore/dfg/DFGDriver.cpp
+++ b/Source/JavaScriptCore/dfg/DFGDriver.cpp
@@ -100,7 +100,7 @@
new Plan(codeBlock, profiledDFGCodeBlock, mode, osrEntryBytecodeIndex, mustHandleValues));
plan->callback = callback;
- if (Options::useConcurrentJIT()) {
+ if (Options::useConcurrentJS()) {
Worklist& worklist = ensureGlobalWorklistFor(mode);
if (logCompilationChanges(mode))
dataLog("Deferring DFG compilation of ", *codeBlock, " with queue length ", worklist.queueLength(), ".\n");
diff --git a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
index b15f00f..3fb4a26 100644
--- a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
+++ b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
@@ -1577,7 +1577,7 @@
} else if (typeSet->doesTypeConformTo(TypeObject)) {
StructureSet set;
{
- ConcurrentJITLocker locker(typeSet->m_lock);
+ ConcurrentJSLocker locker(typeSet->m_lock);
set = typeSet->structureSet(locker);
}
if (!set.isEmpty()) {
@@ -2659,7 +2659,7 @@
profiledBlock->getArrayProfile(node->origin.semantic.bytecodeIndex);
ArrayMode arrayMode = ArrayMode(Array::SelectUsingPredictions);
if (arrayProfile) {
- ConcurrentJITLocker locker(profiledBlock->m_lock);
+ ConcurrentJSLocker locker(profiledBlock->m_lock);
arrayProfile->computeUpdatedPrediction(locker, profiledBlock);
arrayMode = ArrayMode::fromObserved(locker, arrayProfile, Array::Read, false);
if (arrayMode.type() == Array::Unprofiled) {
diff --git a/Source/JavaScriptCore/dfg/DFGGraph.cpp b/Source/JavaScriptCore/dfg/DFGGraph.cpp
index a29b86d..f9f8e4c 100644
--- a/Source/JavaScriptCore/dfg/DFGGraph.cpp
+++ b/Source/JavaScriptCore/dfg/DFGGraph.cpp
@@ -1323,7 +1323,7 @@
JSValue value;
WatchpointSet* set;
{
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
SymbolTableEntry* entry = symbolTable->entryFor(locker, offset);
if (!entry)
diff --git a/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp b/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp
index a1b8393..a752f00 100644
--- a/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp
+++ b/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp
@@ -865,7 +865,7 @@
writes.add(ActivationScopePLoc, LazyNode(node->child1().node()));
{
SymbolTable* symbolTable = node->castOperand<SymbolTable*>();
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
LazyNode initialValue(m_graph.freeze(node->initializationValueForActivation()));
for (auto iter = symbolTable->begin(locker), end = symbolTable->end(locker); iter != end; ++iter) {
writes.add(
diff --git a/Source/JavaScriptCore/dfg/DFGPredictionInjectionPhase.cpp b/Source/JavaScriptCore/dfg/DFGPredictionInjectionPhase.cpp
index 89aaa5b..27fb903 100644
--- a/Source/JavaScriptCore/dfg/DFGPredictionInjectionPhase.cpp
+++ b/Source/JavaScriptCore/dfg/DFGPredictionInjectionPhase.cpp
@@ -49,7 +49,7 @@
ASSERT(codeBlock()->numParameters() >= 1);
{
- ConcurrentJITLocker locker(profiledBlock()->m_lock);
+ ConcurrentJSLocker locker(profiledBlock()->m_lock);
for (size_t arg = 0; arg < static_cast<size_t>(codeBlock()->numParameters()); ++arg) {
ValueProfile* profile = profiledBlock()->valueProfileForArgument(arg);
diff --git a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
index f1dd18a..f17acc9 100644
--- a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
+++ b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
@@ -8388,7 +8388,7 @@
if (validationEnabled()) {
// Validate to make sure every slot in the scope has one value.
- ConcurrentJITLocker locker(table->m_lock);
+ ConcurrentJSLocker locker(table->m_lock);
for (auto iter = table->begin(locker), end = table->end(locker); iter != end; ++iter) {
bool found = false;
for (unsigned i = 0; i < data.m_properties.size(); ++i) {
diff --git a/Source/JavaScriptCore/ftl/FTLOperations.cpp b/Source/JavaScriptCore/ftl/FTLOperations.cpp
index d747524..467f517 100644
--- a/Source/JavaScriptCore/ftl/FTLOperations.cpp
+++ b/Source/JavaScriptCore/ftl/FTLOperations.cpp
@@ -214,7 +214,7 @@
if (validationEnabled()) {
// Validate to make sure every slot in the scope has one value.
- ConcurrentJITLocker locker(table->m_lock);
+ ConcurrentJSLocker locker(table->m_lock);
for (auto iter = table->begin(locker), end = table->end(locker); iter != end; ++iter) {
bool found = false;
for (unsigned i = materialization->properties().size(); i--;) {
diff --git a/Source/JavaScriptCore/heap/Heap.cpp b/Source/JavaScriptCore/heap/Heap.cpp
index 9611892..b528307 100644
--- a/Source/JavaScriptCore/heap/Heap.cpp
+++ b/Source/JavaScriptCore/heap/Heap.cpp
@@ -987,7 +987,7 @@
void Heap::addToRememberedSet(const JSCell* cell)
{
ASSERT(cell);
- ASSERT(!Options::useConcurrentJIT() || !isCompilationThread());
+ ASSERT(!Options::useConcurrentJS() || !isCompilationThread());
if (!Heap::isMarkedConcurrently(cell)) {
// During a full collection a store into an unmarked object that had surivived past
// collections will manifest as a store to an unmarked black object. If the object gets
diff --git a/Source/JavaScriptCore/jit/JIT.cpp b/Source/JavaScriptCore/jit/JIT.cpp
index f4c5f29..c2acfb3 100644
--- a/Source/JavaScriptCore/jit/JIT.cpp
+++ b/Source/JavaScriptCore/jit/JIT.cpp
@@ -525,7 +525,7 @@
before = monotonicallyIncreasingTimeMS();
{
- ConcurrentJITLocker locker(m_codeBlock->m_lock);
+ ConcurrentJSLocker locker(m_codeBlock->m_lock);
m_instructions = m_codeBlock->instructions().clone();
}
diff --git a/Source/JavaScriptCore/jit/JITInlines.h b/Source/JavaScriptCore/jit/JITInlines.h
index 0877249..eade9af 100644
--- a/Source/JavaScriptCore/jit/JITInlines.h
+++ b/Source/JavaScriptCore/jit/JITInlines.h
@@ -1021,7 +1021,7 @@
inline JITArrayMode JIT::chooseArrayMode(ArrayProfile* profile)
{
- ConcurrentJITLocker locker(m_codeBlock->m_lock);
+ ConcurrentJSLocker locker(m_codeBlock->m_lock);
profile->computeUpdatedPrediction(locker, m_codeBlock);
ArrayModes arrayModes = profile->observedArrayModes(locker);
if (arrayProfileSaw(arrayModes, DoubleShape))
diff --git a/Source/JavaScriptCore/jit/JITOperations.cpp b/Source/JavaScriptCore/jit/JITOperations.cpp
index 843dda9..e8ca4e2 100644
--- a/Source/JavaScriptCore/jit/JITOperations.cpp
+++ b/Source/JavaScriptCore/jit/JITOperations.cpp
@@ -610,7 +610,7 @@
JITArrayMode arrayMode = jitArrayModeForStructure(structure);
if (jitArrayModePermitsPut(arrayMode) && arrayMode != byValInfo->arrayMode) {
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->arrayProfile->computeUpdatedPrediction(locker, codeBlock, structure);
JIT::compilePutByVal(&vm, exec->codeBlock(), byValInfo, returnAddress, arrayMode);
@@ -638,7 +638,7 @@
}
} else {
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->seen = true;
byValInfo->cachedId = propertyName;
if (subscript.isSymbol())
@@ -694,7 +694,7 @@
JITArrayMode arrayMode = jitArrayModeForStructure(structure);
if (jitArrayModePermitsPut(arrayMode) && arrayMode != byValInfo->arrayMode) {
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->arrayProfile->computeUpdatedPrediction(locker, codeBlock, structure);
JIT::compileDirectPutByVal(&vm, exec->codeBlock(), byValInfo, returnAddress, arrayMode);
@@ -720,7 +720,7 @@
}
} else {
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->seen = true;
byValInfo->cachedId = propertyName;
if (subscript.isSymbol())
@@ -1743,7 +1743,7 @@
// If we reached this case, we got an interesting array mode we did not expect when we compiled.
// Let's update the profile to do better next time.
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->arrayProfile->computeUpdatedPrediction(locker, codeBlock, structure);
JIT::compileGetByVal(&vm, exec->codeBlock(), byValInfo, returnAddress, arrayMode);
@@ -1771,7 +1771,7 @@
}
} else {
CodeBlock* codeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
byValInfo->seen = true;
byValInfo->cachedId = propertyName;
if (subscript.isSymbol())
diff --git a/Source/JavaScriptCore/jit/JITPropertyAccess.cpp b/Source/JavaScriptCore/jit/JITPropertyAccess.cpp
index 891e582..7ea1e20 100644
--- a/Source/JavaScriptCore/jit/JITPropertyAccess.cpp
+++ b/Source/JavaScriptCore/jit/JITPropertyAccess.cpp
@@ -1324,7 +1324,7 @@
JITGetByIdGenerator gen = emitGetByValWithCachedId(byValInfo, currentInstruction, propertyName, fastDoneCase, slowDoneCase, slowCases);
- ConcurrentJITLocker locker(m_codeBlock->m_lock);
+ ConcurrentJSLocker locker(m_codeBlock->m_lock);
LinkBuffer patchBuffer(*m_vm, *this, m_codeBlock);
patchBuffer.link(slowCases, CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(returnAddress.value())).labelAtOffset(byValInfo->returnAddressToSlowPath));
patchBuffer.link(fastDoneCase, byValInfo->badTypeJump.labelAtOffset(byValInfo->badTypeJumpToDone));
@@ -1415,7 +1415,7 @@
JITPutByIdGenerator gen = emitPutByValWithCachedId(byValInfo, currentInstruction, putKind, propertyName, doneCases, slowCases);
- ConcurrentJITLocker locker(m_codeBlock->m_lock);
+ ConcurrentJSLocker locker(m_codeBlock->m_lock);
LinkBuffer patchBuffer(*m_vm, *this, m_codeBlock);
patchBuffer.link(slowCases, CodeLocationLabel(MacroAssemblerCodePtr::createFromExecutableAddress(returnAddress.value())).labelAtOffset(byValInfo->returnAddressToSlowPath));
patchBuffer.link(doneCases, byValInfo->badTypeJump.labelAtOffset(byValInfo->badTypeJumpToDone));
diff --git a/Source/JavaScriptCore/jit/JITWorklist.cpp b/Source/JavaScriptCore/jit/JITWorklist.cpp
index 2c22da3..71c139f 100644
--- a/Source/JavaScriptCore/jit/JITWorklist.cpp
+++ b/Source/JavaScriptCore/jit/JITWorklist.cpp
@@ -229,7 +229,7 @@
return;
}
- if (!Options::useConcurrentJIT()) {
+ if (!Options::useConcurrentJS()) {
Plan::compileNow(codeBlock);
return;
}
@@ -284,7 +284,7 @@
}
if (isPlanned) {
- RELEASE_ASSERT(Options::useConcurrentJIT());
+ RELEASE_ASSERT(Options::useConcurrentJS());
// This is expensive, but probably good enough.
completeAllForVM(*codeBlock->vm());
}
diff --git a/Source/JavaScriptCore/jit/Repatch.cpp b/Source/JavaScriptCore/jit/Repatch.cpp
index baa5b7d..b2c3a5f 100644
--- a/Source/JavaScriptCore/jit/Repatch.cpp
+++ b/Source/JavaScriptCore/jit/Repatch.cpp
@@ -319,7 +319,7 @@
void repatchGetByID(ExecState* exec, JSValue baseValue, const Identifier& propertyName, const PropertySlot& slot, StructureStubInfo& stubInfo, GetByIDKind kind)
{
SuperSamplerScope superSamplerScope(false);
- GCSafeConcurrentJITLocker locker(exec->codeBlock()->m_lock, exec->vm().heap);
+ GCSafeConcurrentJSLocker locker(exec->codeBlock()->m_lock, exec->vm().heap);
if (tryCacheGetByID(exec, baseValue, propertyName, slot, stubInfo, kind) == GiveUpOnCache)
ftlThunkAwareRepatchCall(exec->codeBlock(), stubInfo.slowPathCallLocation(), appropriateGenericGetByIdFunction(kind));
@@ -473,7 +473,7 @@
void repatchPutByID(ExecState* exec, JSValue baseValue, Structure* structure, const Identifier& propertyName, const PutPropertySlot& slot, StructureStubInfo& stubInfo, PutKind putKind)
{
SuperSamplerScope superSamplerScope(false);
- GCSafeConcurrentJITLocker locker(exec->codeBlock()->m_lock, exec->vm().heap);
+ GCSafeConcurrentJSLocker locker(exec->codeBlock()->m_lock, exec->vm().heap);
if (tryCachePutByID(exec, baseValue, structure, propertyName, slot, stubInfo, putKind) == GiveUpOnCache)
ftlThunkAwareRepatchCall(exec->codeBlock(), stubInfo.slowPathCallLocation(), appropriateGenericPutByIdFunction(slot, putKind));
diff --git a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
index 68ae154..c593408 100644
--- a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
+++ b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
@@ -627,7 +627,7 @@
}
ASSERT((offset == invalidOffset) == slot.isUnset());
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
if (slot.isUnset()) {
pc[0].u.opcode = LLInt::getOpcode(op_get_by_id_unset);
@@ -675,7 +675,7 @@
if (structure->propertyAccessesAreCacheable()) {
vm.heap.writeBarrier(codeBlock);
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
pc[4].u.structureID = structure->id();
pc[5].u.operand = slot.cachedOffset();
@@ -748,7 +748,7 @@
vm.heap.writeBarrier(codeBlock);
if (slot.type() == PutPropertySlot::NewProperty) {
- GCSafeConcurrentJITLocker locker(codeBlock->m_lock, vm.heap);
+ GCSafeConcurrentJSLocker locker(codeBlock->m_lock, vm.heap);
if (!structure->isDictionary() && structure->previousID()->outOfLineCapacity() == structure->outOfLineCapacity()) {
ASSERT(structure->previousID()->transitionWatchpointSetHasBeenInvalidated());
@@ -1335,7 +1335,7 @@
if (!LLINT_ALWAYS_ACCESS_SLOW && callLinkInfo) {
CodeBlock* callerCodeBlock = exec->codeBlock();
- ConcurrentJITLocker locker(callerCodeBlock->m_lock);
+ ConcurrentJSLocker locker(callerCodeBlock->m_lock);
if (callLinkInfo->isOnList())
callLinkInfo->remove();
diff --git a/Source/JavaScriptCore/profiler/ProfilerBytecodeSequence.cpp b/Source/JavaScriptCore/profiler/ProfilerBytecodeSequence.cpp
index f5759d0..0470a37 100644
--- a/Source/JavaScriptCore/profiler/ProfilerBytecodeSequence.cpp
+++ b/Source/JavaScriptCore/profiler/ProfilerBytecodeSequence.cpp
@@ -40,7 +40,7 @@
StringPrintStream out;
for (unsigned i = 0; i < codeBlock->numberOfArgumentValueProfiles(); ++i) {
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
CString description = codeBlock->valueProfileForArgument(i)->briefDescription(locker);
if (!description.length())
continue;
diff --git a/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp b/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
index 4806a30..f63ed57 100644
--- a/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
+++ b/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
@@ -826,7 +826,7 @@
if (resolvedScope->isGlobalObject()) {
JSGlobalObject* globalObject = jsCast<JSGlobalObject*>(resolvedScope);
if (globalObject->hasProperty(exec, ident)) {
- ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
+ ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
if (resolveType == UnresolvedProperty)
pc[4].u.operand = GlobalProperty;
else
@@ -836,7 +836,7 @@
}
} else if (resolvedScope->isGlobalLexicalEnvironment()) {
JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(resolvedScope);
- ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
+ ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
if (resolveType == UnresolvedProperty)
pc[4].u.operand = GlobalLexicalVar;
else
diff --git a/Source/JavaScriptCore/runtime/CommonSlowPaths.h b/Source/JavaScriptCore/runtime/CommonSlowPaths.h
index 9eed6f1..f7daabb 100644
--- a/Source/JavaScriptCore/runtime/CommonSlowPaths.h
+++ b/Source/JavaScriptCore/runtime/CommonSlowPaths.h
@@ -106,7 +106,7 @@
ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalProperty : GlobalPropertyWithVarInjectionChecks;
resolveType = newResolveType;
getPutInfo = GetPutInfo(getPutInfo.resolveMode(), newResolveType, getPutInfo.initializationMode());
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
pc[4].u.operand = getPutInfo.operand();
} else if (scope->isGlobalLexicalEnvironment()) {
JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
@@ -114,7 +114,7 @@
pc[4].u.operand = GetPutInfo(getPutInfo.resolveMode(), newResolveType, getPutInfo.initializationMode()).operand();
SymbolTableEntry entry = globalLexicalEnvironment->symbolTable()->get(ident.impl());
ASSERT(!entry.isNull());
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
pc[5].u.watchpointSet = entry.watchpointSet();
pc[6].u.pointer = static_cast<void*>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
}
@@ -134,7 +134,7 @@
scope->structure()->didCachePropertyReplacement(exec->vm(), slot.cachedOffset());
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
pc[5].u.structure.set(exec->vm(), codeBlock, scope->structure());
pc[6].u.operand = slot.cachedOffset();
}
@@ -150,14 +150,14 @@
if (scope->isGlobalObject()) {
ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalProperty : GlobalPropertyWithVarInjectionChecks;
resolveType = newResolveType; // Allow below caching mechanism to kick in.
- ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
+ ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
pc[4].u.operand = GetPutInfo(getPutInfo.resolveMode(), newResolveType, getPutInfo.initializationMode()).operand();
} else if (scope->isGlobalLexicalEnvironment()) {
JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
ResolveType newResolveType = resolveType == UnresolvedProperty ? GlobalLexicalVar : GlobalLexicalVarWithVarInjectionChecks;
SymbolTableEntry entry = globalLexicalEnvironment->symbolTable()->get(ident.impl());
ASSERT(!entry.isNull());
- ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
+ ConcurrentJSLocker locker(exec->codeBlock()->m_lock);
pc[4].u.operand = GetPutInfo(getPutInfo.resolveMode(), newResolveType, getPutInfo.initializationMode()).operand();
pc[5].u.watchpointSet = entry.watchpointSet();
pc[6].u.pointer = static_cast<void*>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot());
@@ -170,7 +170,7 @@
CodeBlock* codeBlock = exec->codeBlock();
Structure* structure = scope->structure(vm);
{
- ConcurrentJITLocker locker(codeBlock->m_lock);
+ ConcurrentJSLocker locker(codeBlock->m_lock);
pc[5].u.structure.set(exec->vm(), codeBlock, structure);
pc[6].u.operand = slot.cachedOffset();
}
diff --git a/Source/JavaScriptCore/runtime/ConcurrentJITLock.h b/Source/JavaScriptCore/runtime/ConcurrentJSLock.h
similarity index 62%
rename from Source/JavaScriptCore/runtime/ConcurrentJITLock.h
rename to Source/JavaScriptCore/runtime/ConcurrentJSLock.h
index bfb7ec9..9811a38 100644
--- a/Source/JavaScriptCore/runtime/ConcurrentJITLock.h
+++ b/Source/JavaScriptCore/runtime/ConcurrentJSLock.h
@@ -32,32 +32,32 @@
namespace JSC {
-#if ENABLE(CONCURRENT_JIT)
-typedef Lock ConcurrentJITLock;
-typedef LockHolder ConcurrentJITLockerImpl;
+#if ENABLE(CONCURRENT_JS)
+typedef Lock ConcurrentJSLock;
+typedef LockHolder ConcurrentJSLockerImpl;
#else
-typedef NoLock ConcurrentJITLock;
-typedef NoLockLocker ConcurrentJITLockerImpl;
+typedef NoLock ConcurrentJSLock;
+typedef NoLockLocker ConcurrentJSLockerImpl;
#endif
-class ConcurrentJITLockerBase {
- WTF_MAKE_NONCOPYABLE(ConcurrentJITLockerBase);
+class ConcurrentJSLockerBase {
+ WTF_MAKE_NONCOPYABLE(ConcurrentJSLockerBase);
public:
- explicit ConcurrentJITLockerBase(ConcurrentJITLock& lockable)
+ explicit ConcurrentJSLockerBase(ConcurrentJSLock& lockable)
: m_locker(&lockable)
{
}
- explicit ConcurrentJITLockerBase(ConcurrentJITLock* lockable)
+ explicit ConcurrentJSLockerBase(ConcurrentJSLock* lockable)
: m_locker(lockable)
{
}
- explicit ConcurrentJITLockerBase(NoLockingNecessaryTag)
+ explicit ConcurrentJSLockerBase(NoLockingNecessaryTag)
: m_locker(NoLockingNecessary)
{
}
- ~ConcurrentJITLockerBase()
+ ~ConcurrentJSLockerBase()
{
}
@@ -67,24 +67,24 @@
}
private:
- ConcurrentJITLockerImpl m_locker;
+ ConcurrentJSLockerImpl m_locker;
};
-class GCSafeConcurrentJITLocker : public ConcurrentJITLockerBase {
+class GCSafeConcurrentJSLocker : public ConcurrentJSLockerBase {
public:
- GCSafeConcurrentJITLocker(ConcurrentJITLock& lockable, Heap& heap)
- : ConcurrentJITLockerBase(lockable)
+ GCSafeConcurrentJSLocker(ConcurrentJSLock& lockable, Heap& heap)
+ : ConcurrentJSLockerBase(lockable)
, m_deferGC(heap)
{
}
- GCSafeConcurrentJITLocker(ConcurrentJITLock* lockable, Heap& heap)
- : ConcurrentJITLockerBase(lockable)
+ GCSafeConcurrentJSLocker(ConcurrentJSLock* lockable, Heap& heap)
+ : ConcurrentJSLockerBase(lockable)
, m_deferGC(heap)
{
}
- ~GCSafeConcurrentJITLocker()
+ ~GCSafeConcurrentJSLocker()
{
// We have to unlock early due to the destruction order of base
// vs. derived classes. If we didn't, then we would destroy the
@@ -97,35 +97,35 @@
DeferGC m_deferGC;
};
-class ConcurrentJITLocker : public ConcurrentJITLockerBase {
+class ConcurrentJSLocker : public ConcurrentJSLockerBase {
public:
- ConcurrentJITLocker(ConcurrentJITLock& lockable)
- : ConcurrentJITLockerBase(lockable)
-#if ENABLE(CONCURRENT_JIT) && !defined(NDEBUG)
+ ConcurrentJSLocker(ConcurrentJSLock& lockable)
+ : ConcurrentJSLockerBase(lockable)
+#if ENABLE(CONCURRENT_JS) && !defined(NDEBUG)
, m_disallowGC(InPlace)
#endif
{
}
- ConcurrentJITLocker(ConcurrentJITLock* lockable)
- : ConcurrentJITLockerBase(lockable)
-#if ENABLE(CONCURRENT_JIT) && !defined(NDEBUG)
+ ConcurrentJSLocker(ConcurrentJSLock* lockable)
+ : ConcurrentJSLockerBase(lockable)
+#if ENABLE(CONCURRENT_JS) && !defined(NDEBUG)
, m_disallowGC(InPlace)
#endif
{
}
- ConcurrentJITLocker(NoLockingNecessaryTag)
- : ConcurrentJITLockerBase(NoLockingNecessary)
-#if ENABLE(CONCURRENT_JIT) && !defined(NDEBUG)
+ ConcurrentJSLocker(NoLockingNecessaryTag)
+ : ConcurrentJSLockerBase(NoLockingNecessary)
+#if ENABLE(CONCURRENT_JS) && !defined(NDEBUG)
, m_disallowGC(Nullopt)
#endif
{
}
- ConcurrentJITLocker(int) = delete;
+ ConcurrentJSLocker(int) = delete;
-#if ENABLE(CONCURRENT_JIT) && !defined(NDEBUG)
+#if ENABLE(CONCURRENT_JS) && !defined(NDEBUG)
private:
Optional<DisallowGC> m_disallowGC;
#endif
diff --git a/Source/JavaScriptCore/runtime/InferredType.cpp b/Source/JavaScriptCore/runtime/InferredType.cpp
index d1a3249..e1ef0c0 100644
--- a/Source/JavaScriptCore/runtime/InferredType.cpp
+++ b/Source/JavaScriptCore/runtime/InferredType.cpp
@@ -366,7 +366,7 @@
{
}
-bool InferredType::canWatch(const ConcurrentJITLocker& locker, const Descriptor& expected)
+bool InferredType::canWatch(const ConcurrentJSLocker& locker, const Descriptor& expected)
{
if (expected.kind() == Top)
return false;
@@ -376,11 +376,11 @@
bool InferredType::canWatch(const Descriptor& expected)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return canWatch(locker, expected);
}
-void InferredType::addWatchpoint(const ConcurrentJITLocker& locker, Watchpoint* watchpoint)
+void InferredType::addWatchpoint(const ConcurrentJSLocker& locker, Watchpoint* watchpoint)
{
RELEASE_ASSERT(descriptor(locker).kind() != Top);
@@ -389,7 +389,7 @@
void InferredType::addWatchpoint(Watchpoint* watchpoint)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
addWatchpoint(locker, watchpoint);
}
@@ -404,7 +404,7 @@
Descriptor myType;
bool result;
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
oldType = descriptor(locker);
myType = Descriptor::forValue(value);
@@ -427,7 +427,7 @@
{
Descriptor oldType;
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
oldType = descriptor(locker);
if (!set(locker, vm, Top))
return;
@@ -437,11 +437,11 @@
m_watchpointSet.fireAll(vm, detail);
}
-bool InferredType::set(const ConcurrentJITLocker& locker, VM& vm, Descriptor newDescriptor)
+bool InferredType::set(const ConcurrentJSLocker& locker, VM& vm, Descriptor newDescriptor)
{
// We will trigger write barriers while holding our lock. Currently, write barriers don't GC, but that
// could change. If it does, we don't want to deadlock. Note that we could have used
- // GCSafeConcurrentJITLocker in the caller, but the caller is on a fast path so maybe that wouldn't be
+ // GCSafeConcurrentJSLocker in the caller, but the caller is on a fast path so maybe that wouldn't be
// a good idea.
DeferGCForAWhile deferGC(vm.heap);
@@ -506,7 +506,7 @@
Descriptor oldDescriptor;
Descriptor newDescriptor;
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
oldDescriptor = descriptor(locker);
newDescriptor = oldDescriptor;
newDescriptor.removeStructure();
diff --git a/Source/JavaScriptCore/runtime/InferredType.h b/Source/JavaScriptCore/runtime/InferredType.h
index ddf244e..f60a9af 100644
--- a/Source/JavaScriptCore/runtime/InferredType.h
+++ b/Source/JavaScriptCore/runtime/InferredType.h
@@ -25,7 +25,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "JSCell.h"
#include "PropertyName.h"
#include "PutByIdFlags.h"
@@ -173,24 +173,24 @@
Structure* m_structure;
};
- ConcurrentJITLock& lock() const { return m_lock; }
+ ConcurrentJSLock& lock() const { return m_lock; }
Descriptor descriptorMainThread() const
{
return Descriptor(m_kind, m_structure ? m_structure->structure() : nullptr);
}
- Descriptor descriptor(const ConcurrentJITLocker&) const
+ Descriptor descriptor(const ConcurrentJSLocker&) const
{
return descriptorMainThread();
}
Descriptor descriptor() const
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return descriptor(locker);
}
- Kind kind(const ConcurrentJITLocker& locker) const { return descriptor(locker).kind(); }
+ Kind kind(const ConcurrentJSLocker& locker) const { return descriptor(locker).kind(); }
bool isTop() const { return m_kind == Top; }
bool isRelevant() const { return m_kind != Top; }
@@ -214,10 +214,10 @@
// Returns true if it currently makes sense to watch this InferredType for this descriptor. Note that
// this will always return false for Top.
- bool canWatch(const ConcurrentJITLocker&, const Descriptor&);
+ bool canWatch(const ConcurrentJSLocker&, const Descriptor&);
bool canWatch(const Descriptor&);
- void addWatchpoint(const ConcurrentJITLocker&, Watchpoint*);
+ void addWatchpoint(const ConcurrentJSLocker&, Watchpoint*);
void addWatchpoint(Watchpoint*);
void dump(PrintStream&) const;
@@ -231,11 +231,11 @@
// Helper for willStoreValueSlow() and makeTopSlow(). This returns true if we should fire the
// watchpoint set.
- bool set(const ConcurrentJITLocker&, VM&, Descriptor);
+ bool set(const ConcurrentJSLocker&, VM&, Descriptor);
void removeStructure();
- mutable ConcurrentJITLock m_lock;
+ mutable ConcurrentJSLock m_lock;
Kind m_kind { Bottom };
diff --git a/Source/JavaScriptCore/runtime/InferredTypeTable.cpp b/Source/JavaScriptCore/runtime/InferredTypeTable.cpp
index f769368..95563e4 100644
--- a/Source/JavaScriptCore/runtime/InferredTypeTable.cpp
+++ b/Source/JavaScriptCore/runtime/InferredTypeTable.cpp
@@ -54,7 +54,7 @@
{
InferredTypeTable* inferredTypeTable = jsCast<InferredTypeTable*>(cell);
- ConcurrentJITLocker locker(inferredTypeTable->m_lock);
+ ConcurrentJSLocker locker(inferredTypeTable->m_lock);
for (auto& entry : inferredTypeTable->m_table) {
if (!entry.value)
@@ -66,7 +66,7 @@
}
}
-InferredType* InferredTypeTable::get(const ConcurrentJITLocker&, UniquedStringImpl* uid)
+InferredType* InferredTypeTable::get(const ConcurrentJSLocker&, UniquedStringImpl* uid)
{
auto iter = m_table.find(uid);
if (iter == m_table.end() || !iter->value)
@@ -83,7 +83,7 @@
InferredType* InferredTypeTable::get(UniquedStringImpl* uid)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return get(locker, uid);
}
@@ -111,7 +111,7 @@
TableType::AddResult result;
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
result = m_table.add(propertyName.uid(), WriteBarrier<InferredType>());
}
if (result.isNewEntry) {
@@ -143,7 +143,7 @@
TableType::AddResult result;
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
result = m_table.add(propertyName.uid(), WriteBarrier<InferredType>());
}
if (!result.iterator->value)
diff --git a/Source/JavaScriptCore/runtime/InferredTypeTable.h b/Source/JavaScriptCore/runtime/InferredTypeTable.h
index db69eb4..6b4515f 100644
--- a/Source/JavaScriptCore/runtime/InferredTypeTable.h
+++ b/Source/JavaScriptCore/runtime/InferredTypeTable.h
@@ -55,13 +55,13 @@
DECLARE_INFO;
- ConcurrentJITLock& lock() { return m_lock; }
+ ConcurrentJSLock& lock() { return m_lock; }
bool isEmpty() const { return m_table.isEmpty(); }
// Get the current inferred type. Returns nullptr for both Top and Bottom. Null means Bottom if the
// owning Structure doesn't know about the property.
- InferredType* get(const ConcurrentJITLocker&, UniquedStringImpl*);
+ InferredType* get(const ConcurrentJSLocker&, UniquedStringImpl*);
InferredType* get(UniquedStringImpl*);
InferredType* get(PropertyName);
@@ -103,7 +103,7 @@
// We only grab this lock when we're doing modifications on the main thread, or reads on the compiler
// thread. The compiler thread is not allowed to do modifications.
- ConcurrentJITLock m_lock;
+ ConcurrentJSLock m_lock;
};
} // namespace JSC
diff --git a/Source/JavaScriptCore/runtime/JSEnvironmentRecord.cpp b/Source/JavaScriptCore/runtime/JSEnvironmentRecord.cpp
index 923cd49..8807c42 100644
--- a/Source/JavaScriptCore/runtime/JSEnvironmentRecord.cpp
+++ b/Source/JavaScriptCore/runtime/JSEnvironmentRecord.cpp
@@ -49,7 +49,7 @@
JSEnvironmentRecord* thisObject = jsCast<JSEnvironmentRecord*>(cell);
Base::heapSnapshot(cell, builder);
- ConcurrentJITLocker locker(thisObject->symbolTable()->m_lock);
+ ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
SymbolTableEntry::Fast entry = it->value;
diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
index d6878aa..6199c63 100644
--- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
+++ b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
@@ -960,7 +960,7 @@
void JSGlobalObject::addGlobalVar(const Identifier& ident)
{
- ConcurrentJITLocker locker(symbolTable()->m_lock);
+ ConcurrentJSLocker locker(symbolTable()->m_lock);
SymbolTableEntry entry = symbolTable()->get(locker, ident.impl());
if (!entry.isNull())
return;
@@ -1283,7 +1283,7 @@
WatchpointSet* watchpointSet = nullptr;
WriteBarrierBase<Unknown>* variable = nullptr;
{
- ConcurrentJITLocker locker(symbolTable()->m_lock);
+ ConcurrentJSLocker locker(symbolTable()->m_lock);
ScopeOffset offset = symbolTable()->takeNextScopeOffset(locker);
RELEASE_ASSERT(offset = startOffset + i);
SymbolTableEntry newEntry(VarOffset(offset), global.attributes);
diff --git a/Source/JavaScriptCore/runtime/JSLexicalEnvironment.cpp b/Source/JavaScriptCore/runtime/JSLexicalEnvironment.cpp
index dc923ac..436d6f2 100644
--- a/Source/JavaScriptCore/runtime/JSLexicalEnvironment.cpp
+++ b/Source/JavaScriptCore/runtime/JSLexicalEnvironment.cpp
@@ -44,7 +44,7 @@
JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(object);
{
- ConcurrentJITLocker locker(thisObject->symbolTable()->m_lock);
+ ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
if (it->value.getAttributes() & DontEnum && !mode.includeDontEnumProperties())
diff --git a/Source/JavaScriptCore/runtime/JSObject.cpp b/Source/JavaScriptCore/runtime/JSObject.cpp
index 946e941..d1e0731 100644
--- a/Source/JavaScriptCore/runtime/JSObject.cpp
+++ b/Source/JavaScriptCore/runtime/JSObject.cpp
@@ -1554,7 +1554,7 @@
PropertyOffset offset;
if (structure->isUncacheableDictionary())
- offset = structure->removePropertyWithoutTransition(vm, propertyName, [] (const ConcurrentJITLocker&, PropertyOffset) { });
+ offset = structure->removePropertyWithoutTransition(vm, propertyName, [] (const ConcurrentJSLocker&, PropertyOffset) { });
else
thisObject->setStructure(vm, Structure::removePropertyTransition(vm, structure, propertyName, offset));
@@ -3189,7 +3189,7 @@
vm, Structure::toCacheableDictionaryTransition(vm, structure(vm), &deferredWatchpointFire));
}
-void JSObject::shiftButterflyAfterFlattening(const GCSafeConcurrentJITLocker&, VM& vm, Structure* structure, size_t outOfLineCapacityAfter)
+void JSObject::shiftButterflyAfterFlattening(const GCSafeConcurrentJSLocker&, VM& vm, Structure* structure, size_t outOfLineCapacityAfter)
{
// This could interleave visitChildren because some old structure could have been a non
// dictionary structure. We have to be crazy careful. But, we are guaranteed to be holding
diff --git a/Source/JavaScriptCore/runtime/JSObject.h b/Source/JavaScriptCore/runtime/JSObject.h
index b4097a4..2996866 100644
--- a/Source/JavaScriptCore/runtime/JSObject.h
+++ b/Source/JavaScriptCore/runtime/JSObject.h
@@ -758,7 +758,7 @@
{
structure(vm)->flattenDictionaryStructure(vm, this);
}
- void shiftButterflyAfterFlattening(const GCSafeConcurrentJITLocker&, VM&, Structure* structure, size_t outOfLineCapacityAfter);
+ void shiftButterflyAfterFlattening(const GCSafeConcurrentJSLocker&, VM&, Structure* structure, size_t outOfLineCapacityAfter);
JSGlobalObject* globalObject() const
{
diff --git a/Source/JavaScriptCore/runtime/JSObjectInlines.h b/Source/JavaScriptCore/runtime/JSObjectInlines.h
index ae7693e..179bcf8 100644
--- a/Source/JavaScriptCore/runtime/JSObjectInlines.h
+++ b/Source/JavaScriptCore/runtime/JSObjectInlines.h
@@ -167,7 +167,7 @@
unsigned oldOutOfLineCapacity = structure->outOfLineCapacity();
structure->addPropertyWithoutTransition(
vm, propertyName, attributes,
- [&] (const GCSafeConcurrentJITLocker&, PropertyOffset offset) {
+ [&] (const GCSafeConcurrentJSLocker&, PropertyOffset offset) {
if (structure->outOfLineCapacity() != oldOutOfLineCapacity) {
butterfly = allocateMoreOutOfLineStorage(vm, oldOutOfLineCapacity, structure->outOfLineCapacity());
WTF::storeStoreFence();
@@ -266,7 +266,7 @@
unsigned oldOutOfLineCapacity = structure->outOfLineCapacity();
offset = structure->addPropertyWithoutTransition(
vm, propertyName, attributes,
- [&] (const GCSafeConcurrentJITLocker&, PropertyOffset offset) {
+ [&] (const GCSafeConcurrentJSLocker&, PropertyOffset offset) {
Butterfly* butterfly = this->butterfly();
if (structure->outOfLineCapacity() != oldOutOfLineCapacity) {
butterfly = allocateMoreOutOfLineStorage(vm, oldOutOfLineCapacity, structure->outOfLineCapacity());
diff --git a/Source/JavaScriptCore/runtime/JSScope.cpp b/Source/JavaScriptCore/runtime/JSScope.cpp
index b0125e7..c4c749f 100644
--- a/Source/JavaScriptCore/runtime/JSScope.cpp
+++ b/Source/JavaScriptCore/runtime/JSScope.cpp
@@ -59,7 +59,7 @@
SymbolTable* symbolTable = lexicalEnvironment->symbolTable();
{
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto iter = symbolTable->find(locker, ident.impl());
if (iter != symbolTable->end(locker)) {
SymbolTableEntry& entry = iter->value;
@@ -83,7 +83,7 @@
JSModuleRecord* importedRecord = resolution.moduleRecord;
JSModuleEnvironment* importedEnvironment = importedRecord->moduleEnvironment();
SymbolTable* symbolTable = importedEnvironment->symbolTable();
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto iter = symbolTable->find(locker, resolution.localName.impl());
ASSERT(iter != symbolTable->end(locker));
SymbolTableEntry& entry = iter->value;
@@ -101,7 +101,7 @@
if (scope->isGlobalLexicalEnvironment()) {
JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope);
SymbolTable* symbolTable = globalLexicalEnvironment->symbolTable();
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto iter = symbolTable->find(locker, ident.impl());
if (iter != symbolTable->end(locker)) {
SymbolTableEntry& entry = iter->value;
@@ -134,7 +134,7 @@
JSGlobalObject* globalObject = jsCast<JSGlobalObject*>(scope);
{
SymbolTable* symbolTable = globalObject->symbolTable();
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
auto iter = symbolTable->find(locker, ident.impl());
if (iter != symbolTable->end(locker)) {
SymbolTableEntry& entry = iter->value;
@@ -277,7 +277,7 @@
SymbolTable* symbolTable = jsCast<JSSymbolTableObject*>(scope)->symbolTable();
ASSERT(symbolTable->scopeType() == SymbolTable::ScopeType::LexicalScope || symbolTable->scopeType() == SymbolTable::ScopeType::CatchScope);
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
for (auto end = symbolTable->end(locker), iter = symbolTable->begin(locker); iter != end; ++iter)
result.add(iter->key);
}
diff --git a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp b/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp
index 9d5bdf5..49c4c94 100644
--- a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp
+++ b/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp
@@ -36,7 +36,7 @@
ScopeOffset JSSegmentedVariableObject::findVariableIndex(void* variableAddress)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
for (unsigned i = m_variables.size(); i--;) {
if (&m_variables[i] != variableAddress)
@@ -49,7 +49,7 @@
ScopeOffset JSSegmentedVariableObject::addVariables(unsigned numberOfVariablesToAdd, JSValue initialValue)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
size_t oldSize = m_variables.size();
m_variables.grow(oldSize + numberOfVariablesToAdd);
@@ -75,7 +75,7 @@
JSSegmentedVariableObject* thisObject = jsCast<JSSegmentedVariableObject*>(cell);
Base::heapSnapshot(cell, builder);
- ConcurrentJITLocker locker(thisObject->symbolTable()->m_lock);
+ ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
SymbolTableEntry::Fast entry = it->value;
diff --git a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h b/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h
index 0f2e7ca..0d4a815 100644
--- a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h
+++ b/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h
@@ -28,7 +28,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "JSObject.h"
#include "JSSymbolTableObject.h"
#include "SymbolTable.h"
@@ -97,7 +97,7 @@
}
SegmentedVector<WriteBarrier<Unknown>, 16> m_variables;
- ConcurrentJITLock m_lock;
+ ConcurrentJSLock m_lock;
};
} // namespace JSC
diff --git a/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp b/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp
index fc8c92e..efbc191 100644
--- a/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp
+++ b/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp
@@ -57,7 +57,7 @@
{
JSSymbolTableObject* thisObject = jsCast<JSSymbolTableObject*>(object);
{
- ConcurrentJITLocker locker(thisObject->symbolTable()->m_lock);
+ ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
if (!(it->value.getAttributes() & DontEnum) || mode.includeDontEnumProperties()) {
diff --git a/Source/JavaScriptCore/runtime/JSSymbolTableObject.h b/Source/JavaScriptCore/runtime/JSSymbolTableObject.h
index 8a299e5..366b5a0 100644
--- a/Source/JavaScriptCore/runtime/JSSymbolTableObject.h
+++ b/Source/JavaScriptCore/runtime/JSSymbolTableObject.h
@@ -81,7 +81,7 @@
SymbolTableObjectType* object, PropertyName propertyName, PropertySlot& slot)
{
SymbolTable& symbolTable = *object->symbolTable();
- ConcurrentJITLocker locker(symbolTable.m_lock);
+ ConcurrentJSLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
@@ -102,7 +102,7 @@
SymbolTableObjectType* object, PropertyName propertyName, PropertyDescriptor& descriptor)
{
SymbolTable& symbolTable = *object->symbolTable();
- ConcurrentJITLocker locker(symbolTable.m_lock);
+ ConcurrentJSLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
@@ -124,7 +124,7 @@
bool& slotIsWriteable)
{
SymbolTable& symbolTable = *object->symbolTable();
- ConcurrentJITLocker locker(symbolTable.m_lock);
+ ConcurrentJSLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
@@ -174,7 +174,7 @@
SymbolTable& symbolTable = *object->symbolTable();
// FIXME: This is very suspicious. We shouldn't need a GC-safe lock here.
// https://bugs.webkit.org/show_bug.cgi?id=134601
- GCSafeConcurrentJITLocker locker(symbolTable.m_lock, vm.heap);
+ GCSafeConcurrentJSLocker locker(symbolTable.m_lock, vm.heap);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
diff --git a/Source/JavaScriptCore/runtime/Options.cpp b/Source/JavaScriptCore/runtime/Options.cpp
index 4508b7b..88d70ca8 100644
--- a/Source/JavaScriptCore/runtime/Options.cpp
+++ b/Source/JavaScriptCore/runtime/Options.cpp
@@ -317,8 +317,8 @@
#if !ENABLE(YARR_JIT)
Options::useRegExpJIT() = false;
#endif
-#if !ENABLE(CONCURRENT_JIT)
- Options::useConcurrentJIT() = false;
+#if !ENABLE(CONCURRENT_JS)
+ Options::useConcurrentJS() = false;
#endif
#if !ENABLE(DFG_JIT)
Options::useDFGJIT() = false;
@@ -370,7 +370,7 @@
Options::thresholdForFTLOptimizeAfterWarmUp() = 20;
Options::thresholdForFTLOptimizeSoon() = 20;
Options::maximumEvalCacheableSourceLength() = 150000;
- Options::useConcurrentJIT() = false;
+ Options::useConcurrentJS() = false;
}
if (Options::useMaximalFlushInsertionPhase()) {
Options::useOSREntryToDFG() = false;
diff --git a/Source/JavaScriptCore/runtime/Options.h b/Source/JavaScriptCore/runtime/Options.h
index 7c3e941..15beb22 100644
--- a/Source/JavaScriptCore/runtime/Options.h
+++ b/Source/JavaScriptCore/runtime/Options.h
@@ -233,7 +233,7 @@
v(bool, useObjectAllocationSinking, true, Normal, nullptr) \
v(bool, logExecutableAllocation, false, Normal, nullptr) \
\
- v(bool, useConcurrentJIT, true, Normal, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
+ v(bool, useConcurrentJS, true, Normal, "allows the DFG / FTL compilation in threads other than the executing JS thread") \
v(unsigned, numberOfDFGCompilerThreads, computeNumberOfWorkerThreads(2, 2) - 1, Normal, nullptr) \
v(unsigned, numberOfFTLCompilerThreads, computeNumberOfWorkerThreads(8, 2) - 1, Normal, nullptr) \
v(int32, priorityDeltaOfDFGCompilerThreads, computePriorityDeltaOfWorkerThreads(-1, 0), Normal, nullptr) \
@@ -431,7 +431,7 @@
v(enablePolymorphicCallInlining, usePolymorphicCallInlining, SameOption) \
v(enableMovHintRemoval, useMovHintRemoval, SameOption) \
v(enableObjectAllocationSinking, useObjectAllocationSinking, SameOption) \
- v(enableConcurrentJIT, useConcurrentJIT, SameOption) \
+ v(enableConcurrentJS, useConcurrentJS, SameOption) \
v(enableProfiler, useProfiler, SameOption) \
v(enableArchitectureSpecificOptimizations, useArchitectureSpecificOptimizations, SameOption) \
v(enablePolyvariantCallInlining, usePolyvariantCallInlining, SameOption) \
diff --git a/Source/JavaScriptCore/runtime/ProgramExecutable.cpp b/Source/JavaScriptCore/runtime/ProgramExecutable.cpp
index c77fa61..f874f17 100644
--- a/Source/JavaScriptCore/runtime/ProgramExecutable.cpp
+++ b/Source/JavaScriptCore/runtime/ProgramExecutable.cpp
@@ -153,7 +153,7 @@
{
JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(globalObject->globalScope());
SymbolTable* symbolTable = globalLexicalEnvironment->symbolTable();
- ConcurrentJITLocker locker(symbolTable->m_lock);
+ ConcurrentJSLocker locker(symbolTable->m_lock);
for (auto& entry : lexicalDeclarations) {
if (UNLIKELY(entry.value.isConst() && !vm.globalConstRedeclarationShouldThrow() && !isStrictMode())) {
if (symbolTable->contains(locker, entry.key.get()))
diff --git a/Source/JavaScriptCore/runtime/RegExp.cpp b/Source/JavaScriptCore/runtime/RegExp.cpp
index 9939704..a372360 100644
--- a/Source/JavaScriptCore/runtime/RegExp.cpp
+++ b/Source/JavaScriptCore/runtime/RegExp.cpp
@@ -262,7 +262,7 @@
void RegExp::compile(VM* vm, Yarr::YarrCharSize charSize)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->stackLimit());
if (m_constructionError) {
@@ -304,7 +304,7 @@
bool RegExp::matchConcurrently(
VM& vm, const String& s, unsigned startOffset, int& position, Vector<int>& ovector)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!hasCodeFor(s.is8Bit() ? Yarr::Char8 : Yarr::Char16))
return false;
@@ -315,7 +315,7 @@
void RegExp::compileMatchOnly(VM* vm, Yarr::YarrCharSize charSize)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
Yarr::YarrPattern pattern(m_patternString, m_flags, &m_constructionError, vm->stackLimit());
if (m_constructionError) {
@@ -356,7 +356,7 @@
bool RegExp::matchConcurrently(VM& vm, const String& s, unsigned startOffset, MatchResult& result)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!hasMatchOnlyCodeFor(s.is8Bit() ? Yarr::Char8 : Yarr::Char16))
return false;
@@ -367,7 +367,7 @@
void RegExp::deleteCode()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!hasCode())
return;
diff --git a/Source/JavaScriptCore/runtime/RegExp.h b/Source/JavaScriptCore/runtime/RegExp.h
index 996571f..bbe93f5 100644
--- a/Source/JavaScriptCore/runtime/RegExp.h
+++ b/Source/JavaScriptCore/runtime/RegExp.h
@@ -21,7 +21,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ExecutableAllocator.h"
#include "MatchResult.h"
#include "RegExpKey.h"
@@ -142,7 +142,7 @@
unsigned m_rtMatchCallCount;
unsigned m_rtMatchFoundCount;
#endif
- ConcurrentJITLock m_lock;
+ ConcurrentJSLock m_lock;
#if ENABLE(YARR_JIT)
Yarr::YarrCodeBlock m_regExpJITCode;
diff --git a/Source/JavaScriptCore/runtime/Structure.cpp b/Source/JavaScriptCore/runtime/Structure.cpp
index 428de5f..5a97f4a 100644
--- a/Source/JavaScriptCore/runtime/Structure.cpp
+++ b/Source/JavaScriptCore/runtime/Structure.cpp
@@ -337,7 +337,7 @@
// Must hold the lock on this structure, since we will be modifying this structure's
// property map. We don't want getConcurrently() to see the property map in a half-baked
// state.
- GCSafeConcurrentJITLocker locker(m_lock, vm.heap);
+ GCSafeConcurrentJSLocker locker(m_lock, vm.heap);
if (setPropertyTable)
this->setPropertyTable(vm, table);
@@ -380,7 +380,7 @@
Structure* Structure::addPropertyTransitionToExistingStructureConcurrently(Structure* structure, UniquedStringImpl* uid, unsigned attributes, PropertyOffset& offset)
{
- ConcurrentJITLocker locker(structure->m_lock);
+ ConcurrentJSLocker locker(structure->m_lock);
return addPropertyTransitionToExistingStructureImpl(structure, uid, attributes, offset);
}
@@ -478,7 +478,7 @@
checkOffset(transition->m_offset, transition->inlineCapacity());
{
- ConcurrentJITLocker locker(structure->m_lock);
+ ConcurrentJSLocker locker(structure->m_lock);
structure->m_transitionTable.add(vm, transition);
}
transition->checkOffsetConsistency();
@@ -597,7 +597,7 @@
if (result) {
if (isPinnedPropertyTable())
return result->copy(vm, result->size() + 1);
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
setPropertyTable(vm, nullptr);
return result;
}
@@ -668,7 +668,7 @@
if (structure->isDictionary())
transition->pin(vm, transition->ensurePropertyTable(vm));
else {
- ConcurrentJITLocker locker(structure->m_lock);
+ ConcurrentJSLocker locker(structure->m_lock);
structure->m_transitionTable.add(vm, transition);
}
@@ -719,7 +719,7 @@
checkOffsetConsistency();
ASSERT(isDictionary());
- GCSafeConcurrentJITLocker locker(m_lock, vm.heap);
+ GCSafeConcurrentJSLocker locker(m_lock, vm.heap);
size_t beforeOutOfLineCapacity = this->outOfLineCapacity();
if (isUncacheableDictionary()) {
@@ -803,7 +803,7 @@
if (!hasRareData())
allocateRareData(vm);
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
StructureRareData* rareData = this->rareData();
if (!rareData->m_replacementWatchpointSets) {
rareData->m_replacementWatchpointSets =
@@ -943,12 +943,12 @@
PropertyOffset Structure::add(VM& vm, PropertyName propertyName, unsigned attributes)
{
- return add(vm, propertyName, attributes, [] (const GCSafeConcurrentJITLocker&, PropertyOffset) { });
+ return add(vm, propertyName, attributes, [] (const GCSafeConcurrentJSLocker&, PropertyOffset) { });
}
PropertyOffset Structure::remove(PropertyName propertyName)
{
- return remove(propertyName, [] (const ConcurrentJITLocker&, PropertyOffset) { });
+ return remove(propertyName, [] (const ConcurrentJSLocker&, PropertyOffset) { });
}
void Structure::getPropertyNamesFromStructure(VM& vm, PropertyNameArray& propertyNames, EnumerationMode mode)
@@ -1023,7 +1023,7 @@
JSCell::visitChildren(thisObject, visitor);
- ConcurrentJITLocker locker(thisObject->m_lock);
+ ConcurrentJSLocker locker(thisObject->m_lock);
visitor.append(&thisObject->m_globalObject);
if (!thisObject->isObject())
diff --git a/Source/JavaScriptCore/runtime/Structure.h b/Source/JavaScriptCore/runtime/Structure.h
index 1a2f1ba..36fb34a 100644
--- a/Source/JavaScriptCore/runtime/Structure.h
+++ b/Source/JavaScriptCore/runtime/Structure.h
@@ -26,7 +26,7 @@
#pragma once
#include "ClassInfo.h"
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "IndexingType.h"
#include "InferredTypeTable.h"
#include "JSCJSValue.h"
@@ -581,7 +581,7 @@
static void dumpContextHeader(PrintStream&);
- ConcurrentJITLock& lock() { return m_lock; }
+ ConcurrentJSLock& lock() { return m_lock; }
DECLARE_EXPORT_INFO;
@@ -760,7 +760,7 @@
uint8_t m_inlineCapacity;
- ConcurrentJITLock m_lock;
+ ConcurrentJSLock m_lock;
uint32_t m_bitField;
};
diff --git a/Source/JavaScriptCore/runtime/StructureInlines.h b/Source/JavaScriptCore/runtime/StructureInlines.h
index 4a0b670..1dba9c7 100644
--- a/Source/JavaScriptCore/runtime/StructureInlines.h
+++ b/Source/JavaScriptCore/runtime/StructureInlines.h
@@ -233,7 +233,7 @@
inline WatchpointSet* Structure::propertyReplacementWatchpointSet(PropertyOffset offset)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
if (!hasRareData())
return nullptr;
WTF::loadLoadFence();
@@ -290,7 +290,7 @@
{
PropertyTable* table = ensurePropertyTable(vm);
- GCSafeConcurrentJITLocker locker(m_lock, vm.heap);
+ GCSafeConcurrentJSLocker locker(m_lock, vm.heap);
setPropertyTable(vm, table);
@@ -315,7 +315,7 @@
template<typename Func>
inline PropertyOffset Structure::remove(PropertyName propertyName, const Func& func)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
checkConsistency();
diff --git a/Source/JavaScriptCore/runtime/SymbolTable.cpp b/Source/JavaScriptCore/runtime/SymbolTable.cpp
index a127301..7596f4a 100644
--- a/Source/JavaScriptCore/runtime/SymbolTable.cpp
+++ b/Source/JavaScriptCore/runtime/SymbolTable.cpp
@@ -108,11 +108,11 @@
visitor.append(&thisSymbolTable->m_rareData->m_codeBlock);
// Save some memory. This is O(n) to rebuild and we do so on the fly.
- ConcurrentJITLocker locker(thisSymbolTable->m_lock);
+ ConcurrentJSLocker locker(thisSymbolTable->m_lock);
thisSymbolTable->m_localToEntry = nullptr;
}
-const SymbolTable::LocalToEntryVec& SymbolTable::localToEntry(const ConcurrentJITLocker&)
+const SymbolTable::LocalToEntryVec& SymbolTable::localToEntry(const ConcurrentJSLocker&)
{
if (UNLIKELY(!m_localToEntry)) {
unsigned size = 0;
@@ -133,7 +133,7 @@
return *m_localToEntry;
}
-SymbolTableEntry* SymbolTable::entryFor(const ConcurrentJITLocker& locker, ScopeOffset offset)
+SymbolTableEntry* SymbolTable::entryFor(const ConcurrentJSLocker& locker, ScopeOffset offset)
{
auto& toEntryVector = localToEntry(locker);
if (offset.offset() >= toEntryVector.size())
@@ -190,7 +190,7 @@
return result;
}
-void SymbolTable::prepareForTypeProfiling(const ConcurrentJITLocker&)
+void SymbolTable::prepareForTypeProfiling(const ConcurrentJSLocker&)
{
if (m_rareData)
return;
@@ -220,7 +220,7 @@
m_rareData->m_codeBlock.set(*codeBlock->vm(), this, codeBlock);
}
-GlobalVariableID SymbolTable::uniqueIDForVariable(const ConcurrentJITLocker&, UniquedStringImpl* key, VM& vm)
+GlobalVariableID SymbolTable::uniqueIDForVariable(const ConcurrentJSLocker&, UniquedStringImpl* key, VM& vm)
{
RELEASE_ASSERT(m_rareData);
@@ -239,7 +239,7 @@
return id;
}
-GlobalVariableID SymbolTable::uniqueIDForOffset(const ConcurrentJITLocker& locker, VarOffset offset, VM& vm)
+GlobalVariableID SymbolTable::uniqueIDForOffset(const ConcurrentJSLocker& locker, VarOffset offset, VM& vm)
{
RELEASE_ASSERT(m_rareData);
@@ -251,7 +251,7 @@
return uniqueIDForVariable(locker, iter->value.get(), vm);
}
-RefPtr<TypeSet> SymbolTable::globalTypeSetForOffset(const ConcurrentJITLocker& locker, VarOffset offset, VM& vm)
+RefPtr<TypeSet> SymbolTable::globalTypeSetForOffset(const ConcurrentJSLocker& locker, VarOffset offset, VM& vm)
{
RELEASE_ASSERT(m_rareData);
@@ -265,7 +265,7 @@
return globalTypeSetForVariable(locker, iter->value.get(), vm);
}
-RefPtr<TypeSet> SymbolTable::globalTypeSetForVariable(const ConcurrentJITLocker& locker, UniquedStringImpl* key, VM& vm)
+RefPtr<TypeSet> SymbolTable::globalTypeSetForVariable(const ConcurrentJSLocker& locker, UniquedStringImpl* key, VM& vm)
{
RELEASE_ASSERT(m_rareData);
diff --git a/Source/JavaScriptCore/runtime/SymbolTable.h b/Source/JavaScriptCore/runtime/SymbolTable.h
index eebadf8..3183664 100644
--- a/Source/JavaScriptCore/runtime/SymbolTable.h
+++ b/Source/JavaScriptCore/runtime/SymbolTable.h
@@ -28,7 +28,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ConstantMode.h"
#include "InferredValue.h"
#include "JSObject.h"
@@ -462,61 +462,61 @@
}
// You must hold the lock until after you're done with the iterator.
- Map::iterator find(const ConcurrentJITLocker&, UniquedStringImpl* key)
+ Map::iterator find(const ConcurrentJSLocker&, UniquedStringImpl* key)
{
return m_map.find(key);
}
- Map::iterator find(const GCSafeConcurrentJITLocker&, UniquedStringImpl* key)
+ Map::iterator find(const GCSafeConcurrentJSLocker&, UniquedStringImpl* key)
{
return m_map.find(key);
}
- SymbolTableEntry get(const ConcurrentJITLocker&, UniquedStringImpl* key)
+ SymbolTableEntry get(const ConcurrentJSLocker&, UniquedStringImpl* key)
{
return m_map.get(key);
}
SymbolTableEntry get(UniquedStringImpl* key)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return get(locker, key);
}
- SymbolTableEntry inlineGet(const ConcurrentJITLocker&, UniquedStringImpl* key)
+ SymbolTableEntry inlineGet(const ConcurrentJSLocker&, UniquedStringImpl* key)
{
return m_map.inlineGet(key);
}
SymbolTableEntry inlineGet(UniquedStringImpl* key)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return inlineGet(locker, key);
}
- Map::iterator begin(const ConcurrentJITLocker&)
+ Map::iterator begin(const ConcurrentJSLocker&)
{
return m_map.begin();
}
- Map::iterator end(const ConcurrentJITLocker&)
+ Map::iterator end(const ConcurrentJSLocker&)
{
return m_map.end();
}
- Map::iterator end(const GCSafeConcurrentJITLocker&)
+ Map::iterator end(const GCSafeConcurrentJSLocker&)
{
return m_map.end();
}
- size_t size(const ConcurrentJITLocker&) const
+ size_t size(const ConcurrentJSLocker&) const
{
return m_map.size();
}
size_t size() const
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return size(locker);
}
@@ -555,7 +555,7 @@
return ScopeOffset(scopeSize());
}
- ScopeOffset takeNextScopeOffset(const ConcurrentJITLocker&)
+ ScopeOffset takeNextScopeOffset(const ConcurrentJSLocker&)
{
ScopeOffset result = nextScopeOffset();
m_maxScopeOffset = result;
@@ -564,12 +564,12 @@
ScopeOffset takeNextScopeOffset()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return takeNextScopeOffset(locker);
}
template<typename Entry>
- void add(const ConcurrentJITLocker&, UniquedStringImpl* key, Entry&& entry)
+ void add(const ConcurrentJSLocker&, UniquedStringImpl* key, Entry&& entry)
{
RELEASE_ASSERT(!m_localToEntry);
didUseVarOffset(entry.varOffset());
@@ -580,12 +580,12 @@
template<typename Entry>
void add(UniquedStringImpl* key, Entry&& entry)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
add(locker, key, std::forward<Entry>(entry));
}
template<typename Entry>
- void set(const ConcurrentJITLocker&, UniquedStringImpl* key, Entry&& entry)
+ void set(const ConcurrentJSLocker&, UniquedStringImpl* key, Entry&& entry)
{
RELEASE_ASSERT(!m_localToEntry);
didUseVarOffset(entry.varOffset());
@@ -595,18 +595,18 @@
template<typename Entry>
void set(UniquedStringImpl* key, Entry&& entry)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
set(locker, key, std::forward<Entry>(entry));
}
- bool contains(const ConcurrentJITLocker&, UniquedStringImpl* key)
+ bool contains(const ConcurrentJSLocker&, UniquedStringImpl* key)
{
return m_map.contains(key);
}
bool contains(UniquedStringImpl* key)
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
return contains(locker, key);
}
@@ -651,13 +651,13 @@
return m_arguments.get();
}
- const LocalToEntryVec& localToEntry(const ConcurrentJITLocker&);
- SymbolTableEntry* entryFor(const ConcurrentJITLocker&, ScopeOffset);
+ const LocalToEntryVec& localToEntry(const ConcurrentJSLocker&);
+ SymbolTableEntry* entryFor(const ConcurrentJSLocker&, ScopeOffset);
- GlobalVariableID uniqueIDForVariable(const ConcurrentJITLocker&, UniquedStringImpl* key, VM&);
- GlobalVariableID uniqueIDForOffset(const ConcurrentJITLocker&, VarOffset, VM&);
- RefPtr<TypeSet> globalTypeSetForOffset(const ConcurrentJITLocker&, VarOffset, VM&);
- RefPtr<TypeSet> globalTypeSetForVariable(const ConcurrentJITLocker&, UniquedStringImpl* key, VM&);
+ GlobalVariableID uniqueIDForVariable(const ConcurrentJSLocker&, UniquedStringImpl* key, VM&);
+ GlobalVariableID uniqueIDForOffset(const ConcurrentJSLocker&, VarOffset, VM&);
+ RefPtr<TypeSet> globalTypeSetForOffset(const ConcurrentJSLocker&, VarOffset, VM&);
+ RefPtr<TypeSet> globalTypeSetForVariable(const ConcurrentJSLocker&, UniquedStringImpl* key, VM&);
bool usesNonStrictEval() const { return m_usesNonStrictEval; }
void setUsesNonStrictEval(bool usesNonStrictEval) { m_usesNonStrictEval = usesNonStrictEval; }
@@ -677,7 +677,7 @@
SymbolTable* cloneScopePart(VM&);
- void prepareForTypeProfiling(const ConcurrentJITLocker&);
+ void prepareForTypeProfiling(const ConcurrentJSLocker&);
CodeBlock* rareDataCodeBlock();
void setRareDataCodeBlock(CodeBlock*);
@@ -715,7 +715,7 @@
std::unique_ptr<LocalToEntryVec> m_localToEntry;
public:
- mutable ConcurrentJITLock m_lock;
+ mutable ConcurrentJSLock m_lock;
};
} // namespace JSC
diff --git a/Source/JavaScriptCore/runtime/TypeSet.cpp b/Source/JavaScriptCore/runtime/TypeSet.cpp
index c240ccb..1f638c0 100644
--- a/Source/JavaScriptCore/runtime/TypeSet.cpp
+++ b/Source/JavaScriptCore/runtime/TypeSet.cpp
@@ -49,7 +49,7 @@
if (structure && newShape && !runtimeTypeIsPrimitive(type)) {
if (!m_structureSet.contains(structure)) {
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
m_structureSet.add(structure);
}
// Make one more pass making sure that:
@@ -83,7 +83,7 @@
void TypeSet::invalidateCache()
{
- ConcurrentJITLocker locker(m_lock);
+ ConcurrentJSLocker locker(m_lock);
auto keepMarkedStructuresFilter = [] (Structure* structure) -> bool { return Heap::isMarked(structure); };
m_structureSet.genericFilter(keepMarkedStructuresFilter);
}
diff --git a/Source/JavaScriptCore/runtime/TypeSet.h b/Source/JavaScriptCore/runtime/TypeSet.h
index ca90a84..22f178d 100644
--- a/Source/JavaScriptCore/runtime/TypeSet.h
+++ b/Source/JavaScriptCore/runtime/TypeSet.h
@@ -25,7 +25,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "RuntimeType.h"
#include "StructureSet.h"
#include <wtf/HashSet.h>
@@ -97,9 +97,9 @@
bool isEmpty() const { return m_seenTypes == TypeNothing; }
bool doesTypeConformTo(RuntimeTypeMask test) const;
RuntimeTypeMask seenTypes() const { return m_seenTypes; }
- StructureSet structureSet(const ConcurrentJITLocker&) const { return m_structureSet; }
+ StructureSet structureSet(const ConcurrentJSLocker&) const { return m_structureSet; }
- ConcurrentJITLock m_lock;
+ ConcurrentJSLock m_lock;
private:
bool m_isOverflown;
RuntimeTypeMask m_seenTypes;
diff --git a/Source/JavaScriptCore/runtime/VM.h b/Source/JavaScriptCore/runtime/VM.h
index 28a9b63..d5c97be 100644
--- a/Source/JavaScriptCore/runtime/VM.h
+++ b/Source/JavaScriptCore/runtime/VM.h
@@ -29,7 +29,7 @@
#pragma once
#include "CallData.h"
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "ControlFlowProfiler.h"
#include "DateInstanceCache.h"
#include "ExceptionEventLocation.h"
@@ -557,7 +557,7 @@
RefPtr<TypedArrayController> m_typedArrayController;
RegExpCache* m_regExpCache;
BumpPointerAllocator m_regExpAllocator;
- ConcurrentJITLock m_regExpAllocatorLock;
+ ConcurrentJSLock m_regExpAllocatorLock;
std::unique_ptr<HasOwnPropertyCache> m_hasOwnPropertyCache;
ALWAYS_INLINE HasOwnPropertyCache* hasOwnPropertyCache() { return m_hasOwnPropertyCache.get(); }
diff --git a/Source/JavaScriptCore/runtime/WriteBarrierInlines.h b/Source/JavaScriptCore/runtime/WriteBarrierInlines.h
index 4bd2dd6..7d8d66f 100644
--- a/Source/JavaScriptCore/runtime/WriteBarrierInlines.h
+++ b/Source/JavaScriptCore/runtime/WriteBarrierInlines.h
@@ -34,7 +34,7 @@
inline void WriteBarrierBase<T>::set(VM& vm, const JSCell* owner, T* value)
{
ASSERT(value);
- ASSERT(!Options::useConcurrentJIT() || !isCompilationThread());
+ ASSERT(!Options::useConcurrentJS() || !isCompilationThread());
validateCell(value);
setEarlyValue(vm, owner, value);
}
@@ -56,7 +56,7 @@
inline void WriteBarrierBase<Unknown>::set(VM& vm, const JSCell* owner, JSValue value)
{
- ASSERT(!Options::useConcurrentJIT() || !isCompilationThread());
+ ASSERT(!Options::useConcurrentJS() || !isCompilationThread());
m_value = JSValue::encode(value);
vm.heap.writeBarrier(owner, value);
}
diff --git a/Source/JavaScriptCore/yarr/YarrInterpreter.cpp b/Source/JavaScriptCore/yarr/YarrInterpreter.cpp
index 727ae3a..0a9fd82c 100644
--- a/Source/JavaScriptCore/yarr/YarrInterpreter.cpp
+++ b/Source/JavaScriptCore/yarr/YarrInterpreter.cpp
@@ -1588,7 +1588,7 @@
m_currentAlternativeIndex = 0;
}
- std::unique_ptr<BytecodePattern> compile(BumpPointerAllocator* allocator, ConcurrentJITLock* lock)
+ std::unique_ptr<BytecodePattern> compile(BumpPointerAllocator* allocator, ConcurrentJSLock* lock)
{
regexBegin(m_pattern.m_numSubpatterns, m_pattern.m_body->m_callFrameSize, m_pattern.m_body->m_alternatives[0]->onceThrough());
emitDisjunction(m_pattern.m_body);
@@ -2042,7 +2042,7 @@
Vector<std::unique_ptr<ByteDisjunction>> m_allParenthesesInfo;
};
-std::unique_ptr<BytecodePattern> byteCompile(YarrPattern& pattern, BumpPointerAllocator* allocator, ConcurrentJITLock* lock)
+std::unique_ptr<BytecodePattern> byteCompile(YarrPattern& pattern, BumpPointerAllocator* allocator, ConcurrentJSLock* lock)
{
return ByteCompiler(pattern).compile(allocator, lock);
}
diff --git a/Source/JavaScriptCore/yarr/YarrInterpreter.h b/Source/JavaScriptCore/yarr/YarrInterpreter.h
index 28d3d51..b8ea350 100644
--- a/Source/JavaScriptCore/yarr/YarrInterpreter.h
+++ b/Source/JavaScriptCore/yarr/YarrInterpreter.h
@@ -25,7 +25,7 @@
#pragma once
-#include "ConcurrentJITLock.h"
+#include "ConcurrentJSLock.h"
#include "YarrPattern.h"
namespace WTF {
@@ -337,7 +337,7 @@
struct BytecodePattern {
WTF_MAKE_FAST_ALLOCATED;
public:
- BytecodePattern(std::unique_ptr<ByteDisjunction> body, Vector<std::unique_ptr<ByteDisjunction>>& parenthesesInfoToAdopt, YarrPattern& pattern, BumpPointerAllocator* allocator, ConcurrentJITLock* lock)
+ BytecodePattern(std::unique_ptr<ByteDisjunction> body, Vector<std::unique_ptr<ByteDisjunction>>& parenthesesInfoToAdopt, YarrPattern& pattern, BumpPointerAllocator* allocator, ConcurrentJSLock* lock)
: m_body(WTFMove(body))
, m_flags(pattern.m_flags)
, m_allocator(allocator)
@@ -370,7 +370,7 @@
// Each BytecodePattern is associated with a RegExp, each RegExp is associated
// with a VM. Cache a pointer to out VM's m_regExpAllocator.
BumpPointerAllocator* m_allocator;
- ConcurrentJITLock* m_lock;
+ ConcurrentJSLock* m_lock;
CharacterClass* newlineCharacterClass;
CharacterClass* wordcharCharacterClass;
@@ -380,7 +380,7 @@
Vector<std::unique_ptr<CharacterClass>> m_userCharacterClasses;
};
-JS_EXPORT_PRIVATE std::unique_ptr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*, ConcurrentJITLock* = nullptr);
+JS_EXPORT_PRIVATE std::unique_ptr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*, ConcurrentJSLock* = nullptr);
JS_EXPORT_PRIVATE unsigned interpret(BytecodePattern*, const String& input, unsigned start, unsigned* output);
unsigned interpret(BytecodePattern*, const LChar* input, unsigned length, unsigned start, unsigned* output);
unsigned interpret(BytecodePattern*, const UChar* input, unsigned length, unsigned start, unsigned* output);
