fourthTier: should use ConcurrentJITLock[er] directly and not through typedef
authoroliver@apple.com <oliver@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 25 Jul 2013 04:00:37 +0000 (04:00 +0000)
committeroliver@apple.com <oliver@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 25 Jul 2013 04:00:37 +0000 (04:00 +0000)
https://bugs.webkit.org/show_bug.cgi?id=116561

Rubber stamped by Geoffrey Garen.

* JavaScriptCore.xcodeproj/project.pbxproj:
* bytecode/ArrayProfile.cpp:
(JSC::ArrayProfile::computeUpdatedPrediction):
(JSC::ArrayProfile::briefDescription):
* bytecode/ArrayProfile.h:
(ArrayProfile):
(JSC::ArrayProfile::expectedStructure):
(JSC::ArrayProfile::structureIsPolymorphic):
(JSC::ArrayProfile::hasDefiniteStructure):
(JSC::ArrayProfile::observedArrayModes):
(JSC::ArrayProfile::mayInterceptIndexedAccesses):
(JSC::ArrayProfile::mayStoreToHole):
(JSC::ArrayProfile::outOfBounds):
(JSC::ArrayProfile::usesOriginalArrayStructures):
* bytecode/CallLinkStatus.cpp:
(JSC::CallLinkStatus::computeFor):
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::dumpValueProfiling):
(JSC::CodeBlock::dumpArrayProfiling):
(JSC::CodeBlock::updateAllPredictionsAndCountLiveness):
(JSC::CodeBlock::updateAllArrayPredictions):
(JSC::CodeBlock::nameForRegister):
* bytecode/CodeBlock.h:
(JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):
(CodeBlock):
* bytecode/CodeBlockLock.h: Removed.
* bytecode/GetByIdStatus.cpp:
(JSC::GetByIdStatus::computeFor):
* bytecode/LazyOperandValueProfile.cpp:
(JSC::CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions):
(JSC::CompressedLazyOperandValueProfileHolder::add):
(JSC::LazyOperandValueProfileParser::initialize):
(JSC::LazyOperandValueProfileParser::prediction):
* bytecode/LazyOperandValueProfile.h:
(CompressedLazyOperandValueProfileHolder):
(LazyOperandValueProfileParser):
* bytecode/MethodOfGettingAValueProfile.cpp:
(JSC::MethodOfGettingAValueProfile::getSpecFailBucket):
* bytecode/PutByIdStatus.cpp:
(JSC::PutByIdStatus::computeFor):
* bytecode/ResolveGlobalStatus.cpp:
(JSC::ResolveGlobalStatus::computeFor):
* bytecode/ValueProfile.h:
(JSC::ValueProfileBase::briefDescription):
(JSC::ValueProfileBase::computeUpdatedPrediction):
* bytecompiler/BytecodeGenerator.cpp:
(JSC::BytecodeGenerator::addVar):
* dfg/DFGArrayMode.cpp:
(JSC::DFG::ArrayMode::fromObserved):
* dfg/DFGArrayMode.h:
(ArrayMode):
(JSC::DFG::ArrayMode::withProfile):
* dfg/DFGByteCodeParser.cpp:
(JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
(JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
(JSC::DFG::ByteCodeParser::getArrayMode):
(JSC::DFG::ByteCodeParser::getArrayModeAndEmitChecks):
(JSC::DFG::ByteCodeParser::parseResolveOperations):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
* dfg/DFGPredictionInjectionPhase.cpp:
(JSC::DFG::PredictionInjectionPhase::run):
* jit/JITInlines.h:
(JSC::JIT::chooseArrayMode):
* jit/JITStubs.cpp:
(JSC::tryCachePutByID):
(JSC::tryCacheGetByID):
(JSC::DEFINE_STUB_FUNCTION):
(JSC::lazyLinkFor):
* llint/LLIntSlowPaths.cpp:
(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::setUpCall):
* profiler/ProfilerBytecodeSequence.cpp:
(JSC::Profiler::BytecodeSequence::BytecodeSequence):
* runtime/Executable.cpp:
(JSC::ProgramExecutable::addGlobalVar):
* runtime/JSActivation.cpp:
(JSC::JSActivation::getOwnNonIndexPropertyNames):
(JSC::JSActivation::symbolTablePutWithAttributes):
* runtime/JSScope.cpp:
(JSC::JSScope::resolveContainingScopeInternal):
(JSC::JSScope::resolvePut):
* runtime/JSSegmentedVariableObject.cpp:
(JSC::JSSegmentedVariableObject::findRegisterIndex):
(JSC::JSSegmentedVariableObject::addRegisters):
* runtime/JSSegmentedVariableObject.h:
(JSSegmentedVariableObject):
* runtime/JSSymbolTableObject.cpp:
(JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
* runtime/JSSymbolTableObject.h:
(JSC::symbolTableGet):
(JSC::symbolTablePut):
(JSC::symbolTablePutWithAttributes):
* runtime/Structure.cpp:
(JSC::Structure::materializePropertyMap):
(JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
(JSC::Structure::addPropertyTransition):
(JSC::Structure::takePropertyTableOrCloneIfPinned):
(JSC::Structure::nonPropertyTransition):
(JSC::Structure::putSpecificValue):
(JSC::Structure::remove):
(JSC::Structure::createPropertyMap):
* runtime/Structure.h:
(Structure):
* runtime/SymbolTable.h:
(SymbolTable):
(JSC::SymbolTable::find):
(JSC::SymbolTable::get):
(JSC::SymbolTable::inlineGet):
(JSC::SymbolTable::begin):
(JSC::SymbolTable::end):
(JSC::SymbolTable::size):
(JSC::SymbolTable::add):
(JSC::SymbolTable::set):
(JSC::SymbolTable::contains):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@153170 268f45cc-cd09-0410-ab3c-d52691b4dbfc

35 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
Source/JavaScriptCore/bytecode/ArrayProfile.cpp
Source/JavaScriptCore/bytecode/ArrayProfile.h
Source/JavaScriptCore/bytecode/CallLinkStatus.cpp
Source/JavaScriptCore/bytecode/CodeBlock.cpp
Source/JavaScriptCore/bytecode/CodeBlock.h
Source/JavaScriptCore/bytecode/CodeBlockLock.h [deleted file]
Source/JavaScriptCore/bytecode/GetByIdStatus.cpp
Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp
Source/JavaScriptCore/bytecode/LazyOperandValueProfile.h
Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp
Source/JavaScriptCore/bytecode/PutByIdStatus.cpp
Source/JavaScriptCore/bytecode/ResolveGlobalStatus.cpp
Source/JavaScriptCore/bytecode/ValueProfile.h
Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
Source/JavaScriptCore/dfg/DFGArrayMode.cpp
Source/JavaScriptCore/dfg/DFGArrayMode.h
Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
Source/JavaScriptCore/dfg/DFGPredictionInjectionPhase.cpp
Source/JavaScriptCore/jit/JITInlines.h
Source/JavaScriptCore/jit/JITStubs.cpp
Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
Source/JavaScriptCore/profiler/ProfilerBytecodeSequence.cpp
Source/JavaScriptCore/runtime/Executable.cpp
Source/JavaScriptCore/runtime/JSActivation.cpp
Source/JavaScriptCore/runtime/JSScope.cpp
Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp
Source/JavaScriptCore/runtime/JSSegmentedVariableObject.h
Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp
Source/JavaScriptCore/runtime/JSSymbolTableObject.h
Source/JavaScriptCore/runtime/Structure.cpp
Source/JavaScriptCore/runtime/Structure.h
Source/JavaScriptCore/runtime/SymbolTable.h

index bbf41a0..3c44516 100644 (file)
@@ -1,3 +1,128 @@
+2013-05-21  Filip Pizlo  <fpizlo@apple.com>
+
+        fourthTier: should use ConcurrentJITLock[er] directly and not through typedef
+        https://bugs.webkit.org/show_bug.cgi?id=116561
+
+        Rubber stamped by Geoffrey Garen.
+
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * bytecode/ArrayProfile.cpp:
+        (JSC::ArrayProfile::computeUpdatedPrediction):
+        (JSC::ArrayProfile::briefDescription):
+        * bytecode/ArrayProfile.h:
+        (ArrayProfile):
+        (JSC::ArrayProfile::expectedStructure):
+        (JSC::ArrayProfile::structureIsPolymorphic):
+        (JSC::ArrayProfile::hasDefiniteStructure):
+        (JSC::ArrayProfile::observedArrayModes):
+        (JSC::ArrayProfile::mayInterceptIndexedAccesses):
+        (JSC::ArrayProfile::mayStoreToHole):
+        (JSC::ArrayProfile::outOfBounds):
+        (JSC::ArrayProfile::usesOriginalArrayStructures):
+        * bytecode/CallLinkStatus.cpp:
+        (JSC::CallLinkStatus::computeFor):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::dumpValueProfiling):
+        (JSC::CodeBlock::dumpArrayProfiling):
+        (JSC::CodeBlock::updateAllPredictionsAndCountLiveness):
+        (JSC::CodeBlock::updateAllArrayPredictions):
+        (JSC::CodeBlock::nameForRegister):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):
+        (CodeBlock):
+        * bytecode/CodeBlockLock.h: Removed.
+        * bytecode/GetByIdStatus.cpp:
+        (JSC::GetByIdStatus::computeFor):
+        * bytecode/LazyOperandValueProfile.cpp:
+        (JSC::CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions):
+        (JSC::CompressedLazyOperandValueProfileHolder::add):
+        (JSC::LazyOperandValueProfileParser::initialize):
+        (JSC::LazyOperandValueProfileParser::prediction):
+        * bytecode/LazyOperandValueProfile.h:
+        (CompressedLazyOperandValueProfileHolder):
+        (LazyOperandValueProfileParser):
+        * bytecode/MethodOfGettingAValueProfile.cpp:
+        (JSC::MethodOfGettingAValueProfile::getSpecFailBucket):
+        * bytecode/PutByIdStatus.cpp:
+        (JSC::PutByIdStatus::computeFor):
+        * bytecode/ResolveGlobalStatus.cpp:
+        (JSC::ResolveGlobalStatus::computeFor):
+        * bytecode/ValueProfile.h:
+        (JSC::ValueProfileBase::briefDescription):
+        (JSC::ValueProfileBase::computeUpdatedPrediction):
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::addVar):
+        * dfg/DFGArrayMode.cpp:
+        (JSC::DFG::ArrayMode::fromObserved):
+        * dfg/DFGArrayMode.h:
+        (ArrayMode):
+        (JSC::DFG::ArrayMode::withProfile):
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
+        (JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
+        (JSC::DFG::ByteCodeParser::getArrayMode):
+        (JSC::DFG::ByteCodeParser::getArrayModeAndEmitChecks):
+        (JSC::DFG::ByteCodeParser::parseResolveOperations):
+        (JSC::DFG::ByteCodeParser::parseBlock):
+        (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
+        * dfg/DFGFixupPhase.cpp:
+        (JSC::DFG::FixupPhase::fixupNode):
+        * dfg/DFGPredictionInjectionPhase.cpp:
+        (JSC::DFG::PredictionInjectionPhase::run):
+        * jit/JITInlines.h:
+        (JSC::JIT::chooseArrayMode):
+        * jit/JITStubs.cpp:
+        (JSC::tryCachePutByID):
+        (JSC::tryCacheGetByID):
+        (JSC::DEFINE_STUB_FUNCTION):
+        (JSC::lazyLinkFor):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        (JSC::LLInt::setUpCall):
+        * profiler/ProfilerBytecodeSequence.cpp:
+        (JSC::Profiler::BytecodeSequence::BytecodeSequence):
+        * runtime/Executable.cpp:
+        (JSC::ProgramExecutable::addGlobalVar):
+        * runtime/JSActivation.cpp:
+        (JSC::JSActivation::getOwnNonIndexPropertyNames):
+        (JSC::JSActivation::symbolTablePutWithAttributes):
+        * runtime/JSScope.cpp:
+        (JSC::JSScope::resolveContainingScopeInternal):
+        (JSC::JSScope::resolvePut):
+        * runtime/JSSegmentedVariableObject.cpp:
+        (JSC::JSSegmentedVariableObject::findRegisterIndex):
+        (JSC::JSSegmentedVariableObject::addRegisters):
+        * runtime/JSSegmentedVariableObject.h:
+        (JSSegmentedVariableObject):
+        * runtime/JSSymbolTableObject.cpp:
+        (JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
+        * runtime/JSSymbolTableObject.h:
+        (JSC::symbolTableGet):
+        (JSC::symbolTablePut):
+        (JSC::symbolTablePutWithAttributes):
+        * runtime/Structure.cpp:
+        (JSC::Structure::materializePropertyMap):
+        (JSC::Structure::addPropertyTransitionToExistingStructureConcurrently):
+        (JSC::Structure::addPropertyTransition):
+        (JSC::Structure::takePropertyTableOrCloneIfPinned):
+        (JSC::Structure::nonPropertyTransition):
+        (JSC::Structure::putSpecificValue):
+        (JSC::Structure::remove):
+        (JSC::Structure::createPropertyMap):
+        * runtime/Structure.h:
+        (Structure):
+        * runtime/SymbolTable.h:
+        (SymbolTable):
+        (JSC::SymbolTable::find):
+        (JSC::SymbolTable::get):
+        (JSC::SymbolTable::inlineGet):
+        (JSC::SymbolTable::begin):
+        (JSC::SymbolTable::end):
+        (JSC::SymbolTable::size):
+        (JSC::SymbolTable::add):
+        (JSC::SymbolTable::set):
+        (JSC::SymbolTable::contains):
+
 2013-05-20  Filip Pizlo  <fpizlo@apple.com>
 
         fourthTier: DFG should be able to run on a separate thread
index 53fbc02..3f80cff 100644 (file)
@@ -73,7 +73,6 @@
                0F0B83B914BCF95F00885B4F /* CallReturnOffsetToBytecodeOffset.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0B83B814BCF95B00885B4F /* CallReturnOffsetToBytecodeOffset.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F0CD4C215F1A6070032F1C0 /* PutDirectIndexMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0CD4C015F1A6040032F1C0 /* PutDirectIndexMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F0CD4C415F6B6BB0032F1C0 /* SparseArrayValueMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F0CD4C315F6B6B50032F1C0 /* SparseArrayValueMap.cpp */; };
-               0F0D85B21723455400338210 /* CodeBlockLock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0D85B11723455100338210 /* CodeBlockLock.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F0FC45A14BD15F500B81154 /* LLIntCallLinkInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0FC45814BD15F100B81154 /* LLIntCallLinkInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F136D4D174AD69E0075B354 /* DeferGC.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F136D4B174AD69B0075B354 /* DeferGC.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F13912916771C33009CCB07 /* ProfilerBytecodeSequence.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F13912416771C30009CCB07 /* ProfilerBytecodeSequence.cpp */; };
                0F0B83B814BCF95B00885B4F /* CallReturnOffsetToBytecodeOffset.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CallReturnOffsetToBytecodeOffset.h; sourceTree = "<group>"; };
                0F0CD4C015F1A6040032F1C0 /* PutDirectIndexMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PutDirectIndexMode.h; sourceTree = "<group>"; };
                0F0CD4C315F6B6B50032F1C0 /* SparseArrayValueMap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SparseArrayValueMap.cpp; sourceTree = "<group>"; };
-               0F0D85B11723455100338210 /* CodeBlockLock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CodeBlockLock.h; sourceTree = "<group>"; };
                0F0FC45814BD15F100B81154 /* LLIntCallLinkInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LLIntCallLinkInfo.h; sourceTree = "<group>"; };
                0F136D4B174AD69B0075B354 /* DeferGC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeferGC.h; sourceTree = "<group>"; };
                0F13912416771C30009CCB07 /* ProfilerBytecodeSequence.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ProfilerBytecodeSequence.cpp; path = profiler/ProfilerBytecodeSequence.cpp; sourceTree = "<group>"; };
                                969A07910ED1D3AE00F1F681 /* CodeBlock.h */,
                                0F8F943D1667632D00D61971 /* CodeBlockHash.cpp */,
                                0F8F943E1667632D00D61971 /* CodeBlockHash.h */,
-                               0F0D85B11723455100338210 /* CodeBlockLock.h */,
                                0F96EBB116676EF4008BADE3 /* CodeBlockWithJITType.h */,
                                0F8F9445166764EE00D61971 /* CodeOrigin.cpp */,
                                0FBD7E671447998F00481315 /* CodeOrigin.h */,
index 9f6b935..ab6a6f4 100644 (file)
@@ -74,7 +74,7 @@ void dumpArrayModes(PrintStream& out, ArrayModes arrayModes)
         out.print("ArrayWithSlowPutArrayStorage");
 }
 
-void ArrayProfile::computeUpdatedPrediction(const CodeBlockLocker& locker, CodeBlock* codeBlock, OperationInProgress operation)
+void ArrayProfile::computeUpdatedPrediction(const ConcurrentJITLocker& locker, CodeBlock* codeBlock, OperationInProgress operation)
 {
     if (m_lastSeenStructure) {
         m_observedArrayModes |= arrayModeFromStructure(m_lastSeenStructure);
@@ -100,7 +100,7 @@ void ArrayProfile::computeUpdatedPrediction(const CodeBlockLocker& locker, CodeB
         m_expectedStructure = polymorphicStructure();
 }
 
-CString ArrayProfile::briefDescription(const CodeBlockLocker& locker, CodeBlock* codeBlock)
+CString ArrayProfile::briefDescription(const ConcurrentJITLocker& locker, CodeBlock* codeBlock)
 {
     computeUpdatedPrediction(locker, codeBlock);
     
index d2c754b..dbc0ce2 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef ArrayProfile_h
 #define ArrayProfile_h
 
-#include "CodeBlockLock.h"
+#include "ConcurrentJITLock.h"
 #include "JSArray.h"
 #include "Structure.h"
 #include <wtf/HashMap.h>
@@ -164,31 +164,31 @@ public:
         m_lastSeenStructure = structure;
     }
     
-    void computeUpdatedPrediction(const CodeBlockLocker&, CodeBlock*, OperationInProgress = NoOperation);
+    void computeUpdatedPrediction(const ConcurrentJITLocker&, CodeBlock*, OperationInProgress = NoOperation);
     
-    Structure* expectedStructure(const CodeBlockLocker& locker) const
+    Structure* expectedStructure(const ConcurrentJITLocker& locker) const
     {
         if (structureIsPolymorphic(locker))
             return 0;
         return m_expectedStructure;
     }
-    bool structureIsPolymorphic(const CodeBlockLocker&) const
+    bool structureIsPolymorphic(const ConcurrentJITLocker&) const
     {
         return m_expectedStructure == polymorphicStructure();
     }
-    bool hasDefiniteStructure(const CodeBlockLocker& locker) const
+    bool hasDefiniteStructure(const ConcurrentJITLocker& locker) const
     {
         return !structureIsPolymorphic(locker) && m_expectedStructure;
     }
-    ArrayModes observedArrayModes(const CodeBlockLocker&) const { return m_observedArrayModes; }
-    bool mayInterceptIndexedAccesses(const CodeBlockLocker&) const { return m_mayInterceptIndexedAccesses; }
+    ArrayModes observedArrayModes(const ConcurrentJITLocker&) const { return m_observedArrayModes; }
+    bool mayInterceptIndexedAccesses(const ConcurrentJITLocker&) const { return m_mayInterceptIndexedAccesses; }
     
-    bool mayStoreToHole(const CodeBlockLocker&) const { return m_mayStoreToHole; }
-    bool outOfBounds(const CodeBlockLocker&) const { return m_outOfBounds; }
+    bool mayStoreToHole(const ConcurrentJITLocker&) const { return m_mayStoreToHole; }
+    bool outOfBounds(const ConcurrentJITLocker&) const { return m_outOfBounds; }
     
-    bool usesOriginalArrayStructures(const CodeBlockLocker&) const { return m_usesOriginalArrayStructures; }
+    bool usesOriginalArrayStructures(const ConcurrentJITLocker&) const { return m_usesOriginalArrayStructures; }
     
-    CString briefDescription(const CodeBlockLocker&, CodeBlock*);
+    CString briefDescription(const ConcurrentJITLocker&, CodeBlock*);
     
 private:
     friend class LLIntOffsetsExtractor;
index bfbc10b..4cf447f 100644 (file)
@@ -97,7 +97,7 @@ CallLinkStatus CallLinkStatus::computeFromLLInt(CodeBlock* profiledBlock, unsign
 
 CallLinkStatus CallLinkStatus::computeFor(CodeBlock* profiledBlock, unsigned bytecodeIndex)
 {
-    CodeBlockLocker locker(profiledBlock->m_lock);
+    ConcurrentJITLocker locker(profiledBlock->m_lock);
     
     UNUSED_PARAM(profiledBlock);
     UNUSED_PARAM(bytecodeIndex);
index 198b7d5..6ff682f 100644 (file)
@@ -637,7 +637,7 @@ void CodeBlock::beginDumpProfiling(PrintStream& out, bool& hasPrintedProfiling)
 
 void CodeBlock::dumpValueProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)
 {
-    CodeBlockLocker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     ++it;
 #if ENABLE(VALUE_PROFILER)
@@ -654,7 +654,7 @@ void CodeBlock::dumpValueProfiling(PrintStream& out, const Instruction*& it, boo
 
 void CodeBlock::dumpArrayProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)
 {
-    CodeBlockLocker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     ++it;
 #if ENABLE(VALUE_PROFILER)
@@ -3234,7 +3234,7 @@ ArrayProfile* CodeBlock::getOrAddArrayProfile(unsigned bytecodeOffset)
 void CodeBlock::updateAllPredictionsAndCountLiveness(
     OperationInProgress operation, unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles)
 {
-    CodeBlockLocker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     numberOfLiveNonArgumentValueProfiles = 0;
     numberOfSamplesInProfiles = 0; // If this divided by ValueProfile::numberOfBuckets equals numberOfValueProfiles() then value profiles are full.
@@ -3266,7 +3266,7 @@ void CodeBlock::updateAllValueProfilePredictions(OperationInProgress operation)
 
 void CodeBlock::updateAllArrayPredictions(OperationInProgress operation)
 {
-    CodeBlockLocker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     for (unsigned i = m_arrayProfiles.size(); i--;)
         m_arrayProfiles[i].computeUpdatedPrediction(locker, this, operation);
@@ -3462,7 +3462,7 @@ bool CodeBlock::usesOpcode(OpcodeID opcodeID)
 
 String CodeBlock::nameForRegister(int registerNumber)
 {
-    SymbolTable::Locker locker(symbolTable()->m_lock);
+    ConcurrentJITLocker locker(symbolTable()->m_lock);
     SymbolTable::Map::iterator end = symbolTable()->end(locker);
     for (SymbolTable::Map::iterator ptr = symbolTable()->begin(locker); ptr != end; ++ptr) {
         if (ptr->value.getIndex() == registerNumber) {
index b4ff38e..cae12ca 100644 (file)
@@ -36,7 +36,7 @@
 #include "CallLinkInfo.h"
 #include "CallReturnOffsetToBytecodeOffset.h"
 #include "CodeBlockHash.h"
-#include "CodeBlockLock.h"
+#include "ConcurrentJITLock.h"
 #include "CodeOrigin.h"
 #include "CodeType.h"
 #include "CompactJITCodeMap.h"
@@ -448,7 +448,7 @@ class CodeBlock : public ThreadSafeRefCounted<CodeBlock>, public UnconditionalFi
                                                                                                               bytecodeOffset].u.opcode)) - 1].u.profile == result);
             return result;
         }
-        SpeculatedType valueProfilePredictionForBytecodeOffset(const CodeBlockLocker& locker, int bytecodeOffset)
+        SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJITLocker& locker, int bytecodeOffset)
         {
             return valueProfileForBytecodeOffset(bytecodeOffset)->computeUpdatedPrediction(locker);
         }
@@ -905,7 +905,7 @@ class CodeBlock : public ThreadSafeRefCounted<CodeBlock>, public UnconditionalFi
         // 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.
-        CodeBlockLock m_lock;
+        ConcurrentJITLock m_lock;
 
     protected:
 #if ENABLE(JIT)
diff --git a/Source/JavaScriptCore/bytecode/CodeBlockLock.h b/Source/JavaScriptCore/bytecode/CodeBlockLock.h
deleted file mode 100644 (file)
index 4fc2656..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#ifndef CodeBlockLock_h
-#define CodeBlockLock_h
-
-#include "ConcurrentJITLock.h"
-
-namespace JSC {
-
-typedef ConcurrentJITLock CodeBlockLock;
-typedef ConcurrentJITLocker CodeBlockLocker;
-
-} // namespace JSC
-
-#endif // CodeBlockLock_h
-
index 3a8c700..6ef464d 100644 (file)
@@ -107,7 +107,7 @@ void GetByIdStatus::computeForChain(GetByIdStatus& result, CodeBlock* profiledBl
 
 GetByIdStatus GetByIdStatus::computeFor(CodeBlock* profiledBlock, unsigned bytecodeIndex, StringImpl* uid)
 {
-    CodeBlockLocker locker(profiledBlock->m_lock);
+    ConcurrentJITLocker locker(profiledBlock->m_lock);
     
     UNUSED_PARAM(profiledBlock);
     UNUSED_PARAM(bytecodeIndex);
index ea9534b..127c226 100644 (file)
@@ -35,7 +35,7 @@ namespace JSC {
 CompressedLazyOperandValueProfileHolder::CompressedLazyOperandValueProfileHolder() { }
 CompressedLazyOperandValueProfileHolder::~CompressedLazyOperandValueProfileHolder() { }
 
-void CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions(const CodeBlockLocker& locker, OperationInProgress operation)
+void CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions(const ConcurrentJITLocker& locker, OperationInProgress operation)
 {
     if (!m_data)
         return;
@@ -45,7 +45,7 @@ void CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions(const Co
 }
 
 LazyOperandValueProfile* CompressedLazyOperandValueProfileHolder::add(
-    const CodeBlockLocker&, const LazyOperandValueProfileKey& key)
+    const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key)
 {
     if (!m_data)
         m_data = adoptPtr(new LazyOperandValueProfile::List());
@@ -64,7 +64,7 @@ LazyOperandValueProfileParser::LazyOperandValueProfileParser() { }
 LazyOperandValueProfileParser::~LazyOperandValueProfileParser() { }
 
 void LazyOperandValueProfileParser::initialize(
-    const CodeBlockLocker&, CompressedLazyOperandValueProfileHolder& holder)
+    const ConcurrentJITLocker&, CompressedLazyOperandValueProfileHolder& holder)
 {
     ASSERT(m_map.isEmpty());
     
@@ -89,7 +89,7 @@ LazyOperandValueProfile* LazyOperandValueProfileParser::getIfPresent(
 }
 
 SpeculatedType LazyOperandValueProfileParser::prediction(
-    const CodeBlockLocker& locker, const LazyOperandValueProfileKey& key) const
+    const ConcurrentJITLocker& locker, const LazyOperandValueProfileKey& key) const
 {
     LazyOperandValueProfile* profile = getIfPresent(key);
     if (!profile)
index c04b47d..9b95fc5 100644 (file)
@@ -30,7 +30,7 @@
 
 #if ENABLE(VALUE_PROFILER)
 
-#include "CodeBlockLock.h"
+#include "ConcurrentJITLock.h"
 #include "ValueProfile.h"
 #include <wtf/HashMap.h>
 #include <wtf/Noncopyable.h>
@@ -156,10 +156,10 @@ public:
     CompressedLazyOperandValueProfileHolder();
     ~CompressedLazyOperandValueProfileHolder();
     
-    void computeUpdatedPredictions(const CodeBlockLocker&, OperationInProgress);
+    void computeUpdatedPredictions(const ConcurrentJITLocker&, OperationInProgress);
     
     LazyOperandValueProfile* add(
-        const CodeBlockLocker&, const LazyOperandValueProfileKey& key);
+        const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key);
     
 private:
     friend class LazyOperandValueProfileParser;
@@ -173,13 +173,13 @@ public:
     ~LazyOperandValueProfileParser();
     
     void initialize(
-        const CodeBlockLocker&, CompressedLazyOperandValueProfileHolder& holder);
+        const ConcurrentJITLocker&, CompressedLazyOperandValueProfileHolder& holder);
     
     LazyOperandValueProfile* getIfPresent(
         const LazyOperandValueProfileKey& key) const;
     
     SpeculatedType prediction(
-        const CodeBlockLocker&, const LazyOperandValueProfileKey& key) const;
+        const ConcurrentJITLocker&, const LazyOperandValueProfileKey& key) const;
 private:
     HashMap<LazyOperandValueProfileKey, LazyOperandValueProfile*> m_map;
 };
index 3ebc525..1380bf8 100644 (file)
@@ -55,7 +55,7 @@ EncodedJSValue* MethodOfGettingAValueProfile::getSpecFailBucket(unsigned index)
     case LazyOperand: {
         LazyOperandValueProfileKey key(u.lazyOperand.bytecodeOffset, u.lazyOperand.operand);
         
-        CodeBlockLocker locker(u.lazyOperand.codeBlock->m_lock);
+        ConcurrentJITLocker locker(u.lazyOperand.codeBlock->m_lock);
         LazyOperandValueProfile* profile =
             u.lazyOperand.codeBlock->lazyOperandValueProfiles().add(locker, key);
         return profile->specFailBucket(index);
index b50ff19..68664aa 100644 (file)
@@ -83,7 +83,7 @@ PutByIdStatus PutByIdStatus::computeFromLLInt(CodeBlock* profiledBlock, unsigned
 
 PutByIdStatus PutByIdStatus::computeFor(CodeBlock* profiledBlock, unsigned bytecodeIndex, StringImpl* uid)
 {
-    CodeBlockLocker locker(profiledBlock->m_lock);
+    ConcurrentJITLocker locker(profiledBlock->m_lock);
     
     UNUSED_PARAM(profiledBlock);
     UNUSED_PARAM(bytecodeIndex);
index 7c07708..884fc57 100644 (file)
@@ -48,7 +48,7 @@ static ResolveGlobalStatus computeForStructure(CodeBlock* codeBlock, Structure*
 
 ResolveGlobalStatus ResolveGlobalStatus::computeFor(CodeBlock* codeBlock, int, ResolveOperation* operation, StringImpl* uid)
 {
-    CodeBlockLocker locker(codeBlock->m_lock);
+    ConcurrentJITLocker locker(codeBlock->m_lock);
     
     ASSERT(operation->m_operation == ResolveOperation::GetAndReturnGlobalProperty);
     if (!operation->m_structure)
index 08a8fbd..e41341d 100644 (file)
@@ -33,7 +33,7 @@
 
 #if ENABLE(VALUE_PROFILER)
 
-#include "CodeBlockLock.h"
+#include "ConcurrentJITLock.h"
 #include "Heap.h"
 #include "JSArray.h"
 #include "SpeculatedType.h"
@@ -112,7 +112,7 @@ struct ValueProfileBase {
         return false;
     }
     
-    CString briefDescription(const CodeBlockLocker& locker)
+    CString briefDescription(const ConcurrentJITLocker& locker)
     {
         computeUpdatedPrediction(locker);
         
@@ -150,7 +150,7 @@ struct ValueProfileBase {
     
     // Updates the prediction and returns the new one. Never call this from any thread
     // that isn't executing the code.
-    SpeculatedType computeUpdatedPrediction(const CodeBlockLocker&, OperationInProgress operation = NoOperation)
+    SpeculatedType computeUpdatedPrediction(const ConcurrentJITLocker&, OperationInProgress operation = NoOperation)
     {
         for (unsigned i = 0; i < totalNumberOfBuckets; ++i) {
             JSValue value = JSValue::decode(m_buckets[i]);
index dfa565a..2da5eee 100644 (file)
@@ -137,7 +137,7 @@ ParserError BytecodeGenerator::generate()
 
 bool BytecodeGenerator::addVar(const Identifier& ident, bool isConstant, RegisterID*& r0)
 {
-    SymbolTable::Locker locker(symbolTable().m_lock);
+    ConcurrentJITLocker locker(symbolTable().m_lock);
     int index = m_calleeRegisters.size();
     SymbolTableEntry newEntry(index, isConstant ? ReadOnly : 0);
     SymbolTable::Map::AddResult result = symbolTable().add(locker, ident.impl(), newEntry);
index d297bde..6c43a3b 100644 (file)
@@ -34,7 +34,7 @@
 
 namespace JSC { namespace DFG {
 
-ArrayMode ArrayMode::fromObserved(const CodeBlockLocker& locker, ArrayProfile* profile, Array::Action action, bool makeSafe)
+ArrayMode ArrayMode::fromObserved(const ConcurrentJITLocker& locker, ArrayProfile* profile, Array::Action action, bool makeSafe)
 {
     ArrayModes observed = profile->observedArrayModes(locker);
     switch (observed) {
index ee335da..81c2743 100644 (file)
@@ -150,14 +150,14 @@ public:
         return ArrayMode(word);
     }
     
-    static ArrayMode fromObserved(const CodeBlockLocker&, ArrayProfile*, Array::Action, bool makeSafe);
+    static ArrayMode fromObserved(const ConcurrentJITLocker&, ArrayProfile*, Array::Action, bool makeSafe);
     
     ArrayMode withSpeculation(Array::Speculation speculation) const
     {
         return ArrayMode(type(), arrayClass(), speculation, conversion());
     }
     
-    ArrayMode withProfile(const CodeBlockLocker& locker, ArrayProfile* profile, bool makeSafe) const
+    ArrayMode withProfile(const ConcurrentJITLocker& locker, ArrayProfile* profile, bool makeSafe) const
     {
         Array::Speculation mySpeculation;
         Array::Class myArrayClass;
index f550b97..ab1c28d 100644 (file)
@@ -264,7 +264,7 @@ private:
     {
         ASSERT(node->op() == GetLocal);
         ASSERT(node->codeOrigin.bytecodeIndex == m_currentIndex);
-        CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
         LazyOperandValueProfileKey key(m_currentIndex, node->local());
         SpeculatedType prediction = m_inlineStackTop->m_lazyOperands.prediction(locker, key);
 #if DFG_ENABLE(DEBUG_VERBOSE)
@@ -810,7 +810,7 @@ private:
     
     SpeculatedType getPredictionWithoutOSRExit(unsigned bytecodeIndex)
     {
-        CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
         return m_inlineStackTop->m_profiledBlock->valueProfilePredictionForBytecodeOffset(locker, bytecodeIndex);
     }
 
@@ -839,7 +839,7 @@ private:
     
     ArrayMode getArrayMode(ArrayProfile* profile, Array::Action action)
     {
-        CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
         profile->computeUpdatedPrediction(locker, m_inlineStackTop->m_profiledBlock);
         return ArrayMode::fromObserved(locker, profile, action, false);
     }
@@ -851,7 +851,7 @@ private:
     
     ArrayMode getArrayModeAndEmitChecks(ArrayProfile* profile, Array::Action action, Node* base)
     {
-        CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
         
         profile->computeUpdatedPrediction(locker, m_inlineStackTop->m_profiledBlock);
         
@@ -1797,7 +1797,7 @@ Node* ByteCodeParser::getScope(bool skipTop, unsigned skipCount)
 bool ByteCodeParser::parseResolveOperations(SpeculatedType prediction, unsigned identifier, ResolveOperations* resolveOperations, PutToBaseOperation* putToBaseOperation, Node** base, Node** value)
 {
     {
-        CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
      
         if (!resolveOperations->m_ready) {
             addToGraph(ForceOSRExit);
@@ -2035,7 +2035,7 @@ bool ByteCodeParser::parseBlock(unsigned limit)
         case op_to_this: {
             Node* op1 = getThis();
             if (op1->op() != ToThis) {
-                CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+                ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
                 ValueProfile* profile =
                     m_inlineStackTop->m_profiledBlock->valueProfileForBytecodeOffset(m_currentProfilingIndex);
                 profile->computeUpdatedPrediction(locker);
@@ -2136,7 +2136,7 @@ bool ByteCodeParser::parseBlock(unsigned limit)
         }
             
         case op_get_callee: {
-            CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+            ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
             ValueProfile* profile = currentInstruction[2].u.profile;
             profile->computeUpdatedPrediction(locker);
             if (profile->m_singletonValueIsTop
@@ -3174,7 +3174,7 @@ bool ByteCodeParser::parseBlock(unsigned limit)
             PutToBaseOperation* putToBase = currentInstruction[4].u.putToBaseOperation;
             
             {
-                CodeBlockLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
+                ConcurrentJITLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
                 
                 if (!putToBase->m_ready) {
                     addToGraph(ForceOSRExit);
@@ -3505,7 +3505,7 @@ ByteCodeParser::InlineStackEntry::InlineStackEntry(
     , m_caller(byteCodeParser->m_inlineStackTop)
 {
     {
-        CodeBlockLocker locker(m_profiledBlock->m_lock);
+        ConcurrentJITLocker locker(m_profiledBlock->m_lock);
         m_lazyOperands.initialize(locker, m_profiledBlock->lazyOperandValueProfiles());
     }
     
index 31af5af..a96194c 100644 (file)
@@ -701,7 +701,7 @@ private:
                 profiledBlock->getArrayProfile(node->codeOrigin.bytecodeIndex);
             ArrayMode arrayMode = ArrayMode(Array::SelectUsingPredictions);
             if (arrayProfile) {
-                CodeBlockLocker locker(profiledBlock->m_lock);
+                ConcurrentJITLocker locker(profiledBlock->m_lock);
                 arrayProfile->computeUpdatedPrediction(locker, profiledBlock);
                 arrayMode = ArrayMode::fromObserved(locker, arrayProfile, Array::Read, false);
                 arrayMode = arrayMode.refine(node->child1()->prediction(), node->prediction());
index 65f9421..75db08b 100644 (file)
@@ -49,7 +49,7 @@ public:
         
         ASSERT(codeBlock()->numParameters() >= 1);
         {
-            CodeBlockLocker locker(profiledBlock()->m_lock);
+            ConcurrentJITLocker locker(profiledBlock()->m_lock);
             
             for (size_t arg = 0; arg < static_cast<size_t>(codeBlock()->numParameters()); ++arg) {
                 ValueProfile* profile = profiledBlock()->valueProfileForArgument(arg);
index cfc0abb..ce07286 100644 (file)
@@ -437,7 +437,7 @@ static inline bool arrayProfileSaw(ArrayModes arrayModes, IndexingType capabilit
 inline JITArrayMode JIT::chooseArrayMode(ArrayProfile* profile)
 {
 #if ENABLE(VALUE_PROFILER)
-    CodeBlockLocker locker(m_codeBlock->m_lock);
+    ConcurrentJITLocker locker(m_codeBlock->m_lock);
     profile->computeUpdatedPrediction(locker, m_codeBlock);
     ArrayModes arrayModes = profile->observedArrayModes(locker);
     if (arrayProfileSaw(arrayModes, DoubleShape))
index 75d1ddb..ade42bf 100644 (file)
@@ -116,7 +116,7 @@ void performPlatformSpecificJITAssertions(VM* vm)
 
 NEVER_INLINE static void tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, ReturnAddressPtr returnAddress, JSValue baseValue, const PutPropertySlot& slot, StructureStubInfo* stubInfo, bool direct)
 {
-    CodeBlockLocker locker(codeBlock->m_lock);
+    ConcurrentJITLocker locker(codeBlock->m_lock);
     
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
 
@@ -172,7 +172,7 @@ NEVER_INLINE static void tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBl
 
 NEVER_INLINE static void tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, ReturnAddressPtr returnAddress, JSValue baseValue, const Identifier& propertyName, const PropertySlot& slot, StructureStubInfo* stubInfo)
 {
-    CodeBlockLocker locker(codeBlock->m_lock);
+    ConcurrentJITLocker locker(codeBlock->m_lock);
     
     // FIXME: Write a test that proves we need to check for recursion here just
     // like the interpreter does, then add a check for recursion.
@@ -709,7 +709,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_self_fail)
 
     CHECK_FOR_EXCEPTION();
 
-    CodeBlockLocker locker(codeBlock->m_lock);
+    ConcurrentJITLocker locker(codeBlock->m_lock);
     
     if (baseValue.isCell()
         && slot.isCacheable()
@@ -825,7 +825,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
         return JSValue::encode(result);
     }
 
-    CodeBlockLocker locker(codeBlock->m_lock);
+    ConcurrentJITLocker locker(codeBlock->m_lock);
     
     Structure* structure = baseValue.asCell()->structure();
 
@@ -1337,7 +1337,7 @@ inline void* lazyLinkFor(CallFrame* callFrame, CodeSpecializationKind kind)
             codePtr = functionExecutable->generatedJITCodeFor(kind)->addressForCall();
     }
 
-    CodeBlockLocker locker(callFrame->callerFrame()->codeBlock()->m_lock);
+    ConcurrentJITLocker locker(callFrame->callerFrame()->codeBlock()->m_lock);
     if (!callLinkInfo->seenOnce())
         callLinkInfo->setSeen();
     else
@@ -1413,7 +1413,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkClosureCall)
     
     if (shouldLink) {
         ASSERT(codePtr);
-        CodeBlockLocker locker(callerCodeBlock->m_lock);
+        ConcurrentJITLocker locker(callerCodeBlock->m_lock);
         JIT::compileClosureCall(vm, callLinkInfo, callerCodeBlock, calleeCodeBlock, structure, executable, codePtr);
         callLinkInfo->hasSeenClosure = true;
     } else
@@ -1561,7 +1561,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve)
     JSValue result = JSScope::resolve(callFrame, stackFrame.args[0].identifier(), operations);
     
     if (willReify) {
-        CodeBlockLocker locker(callFrame->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(callFrame->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     
@@ -1581,7 +1581,7 @@ DEFINE_STUB_FUNCTION(void, op_put_to_base)
     JSScope::resolvePut(callFrame, base, stackFrame.args[1].identifier(), value, operation);
     
     if (firstTime) {
-        CodeBlockLocker locker(callFrame->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(callFrame->codeBlock()->m_lock);
         operation->m_ready = true;
     }
 
@@ -1919,7 +1919,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_base)
     JSValue result = JSScope::resolveBase(stackFrame.callFrame, stackFrame.args[0].identifier(), false, operations, stackFrame.args[2].putToBaseOperation());
     
     if (willReify) {
-        CodeBlockLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     
@@ -1936,7 +1936,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_base_strict_put)
     if (JSValue result = JSScope::resolveBase(stackFrame.callFrame, stackFrame.args[0].identifier(), true, operations, stackFrame.args[2].putToBaseOperation())) {
         
         if (willReify) {
-            CodeBlockLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
+            ConcurrentJITLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
             operations->m_ready = true;
         }
         
@@ -2213,7 +2213,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_with_base)
     bool willReify = operations->isEmpty();
     JSValue result = JSScope::resolveWithBase(callFrame, stackFrame.args[0].identifier(), &callFrame->registers()[stackFrame.args[1].int32()], operations, stackFrame.args[3].putToBaseOperation());
     if (willReify) {
-        CodeBlockLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     CHECK_FOR_EXCEPTION_AT_END();
@@ -2229,7 +2229,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_with_this)
     bool willReify = operations->isEmpty();
     JSValue result = JSScope::resolveWithThis(callFrame, stackFrame.args[0].identifier(), &callFrame->registers()[stackFrame.args[1].int32()], operations);
     if (willReify) {
-        CodeBlockLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(stackFrame.callFrame->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     CHECK_FOR_EXCEPTION_AT_END();
index d58e8e4..c7fa830 100644 (file)
@@ -802,7 +802,7 @@ LLINT_SLOW_PATH_DECL(slow_path_resolve)
     }
     
     {
-        CodeBlockLocker locker(exec->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     
@@ -824,7 +824,7 @@ LLINT_SLOW_PATH_DECL(slow_path_put_to_base)
     }
 
     {
-        CodeBlockLocker locker(exec->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
         operation->m_ready = true;
     }
     
@@ -868,7 +868,7 @@ LLINT_SLOW_PATH_DECL(slow_path_resolve_base)
     }
     
     {
-        CodeBlockLocker locker(exec->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     
@@ -883,7 +883,7 @@ LLINT_SLOW_PATH_DECL(slow_path_resolve_with_base)
     bool willReify = operations->isEmpty();
     JSValue result = JSScope::resolveWithBase(exec, exec->codeBlock()->identifier(pc[3].u.operand), &LLINT_OP(1), operations, pc[5].u.putToBaseOperation);
     if (willReify) {
-        CodeBlockLocker locker(exec->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     LLINT_CHECK_EXCEPTION();
@@ -899,7 +899,7 @@ LLINT_SLOW_PATH_DECL(slow_path_resolve_with_this)
     bool willReify = operations->isEmpty();
     JSValue result = JSScope::resolveWithThis(exec, exec->codeBlock()->identifier(pc[3].u.operand), &LLINT_OP(1), operations);
     if (willReify) {
-        CodeBlockLocker locker(exec->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(exec->codeBlock()->m_lock);
         operations->m_ready = true;
     }
     LLINT_CHECK_EXCEPTION();
@@ -939,7 +939,7 @@ LLINT_SLOW_PATH_DECL(slow_path_get_by_id)
         
         if (!structure->isUncacheableDictionary()
             && !structure->typeInfo().prohibitsPropertyCaching()) {
-            CodeBlockLocker locker(codeBlock->m_lock);
+            ConcurrentJITLocker locker(codeBlock->m_lock);
             
             pc[4].u.structure.set(
                 vm, codeBlock->ownerExecutable(), structure);
@@ -1006,7 +1006,7 @@ LLINT_SLOW_PATH_DECL(slow_path_put_by_id)
             && baseCell == slot.base()) {
             
             if (slot.type() == PutPropertySlot::NewProperty) {
-                CodeBlockLocker locker(codeBlock->m_lock);
+                ConcurrentJITLocker locker(codeBlock->m_lock);
             
                 if (!structure->isDictionary() && structure->previousID()->outOfLineCapacity() == structure->outOfLineCapacity()) {
                     ASSERT(structure->previousID()->transitionWatchpointSetHasBeenInvalidated());
@@ -1435,7 +1435,7 @@ inline SlowPathReturnType setUpCall(ExecState* execCallee, Instruction* pc, Code
     if (!LLINT_ALWAYS_ACCESS_SLOW && callLinkInfo) {
         ExecState* execCaller = execCallee->callerFrame();
 
-        CodeBlockLocker locker(execCaller->codeBlock()->m_lock);
+        ConcurrentJITLocker locker(execCaller->codeBlock()->m_lock);
         
         if (callLinkInfo->isOnList())
             callLinkInfo->remove();
index 45f0213..993e168 100644 (file)
@@ -40,7 +40,7 @@ BytecodeSequence::BytecodeSequence(CodeBlock* codeBlock)
     
 #if ENABLE(VALUE_PROFILER)
     for (unsigned i = 0; i < codeBlock->numberOfArgumentValueProfiles(); ++i) {
-        CodeBlockLocker locker(codeBlock->m_lock);
+        ConcurrentJITLocker locker(codeBlock->m_lock);
         CString description = codeBlock->valueProfileForArgument(i)->briefDescription(locker);
         if (!description.length())
             continue;
index c2488e4..eedd945 100644 (file)
@@ -374,7 +374,7 @@ int ProgramExecutable::addGlobalVar(JSGlobalObject* globalObject, const Identifi
     // Try to share the symbolTable if possible
     SharedSymbolTable* symbolTable = globalObject->symbolTable();
     UNUSED_PARAM(functionMode);
-    SymbolTable::Locker locker(symbolTable->m_lock);
+    ConcurrentJITLocker locker(symbolTable->m_lock);
     int index = symbolTable->size(locker);
     SymbolTableEntry newEntry(index, (constantMode == IsConstant) ? ReadOnly : 0);
     if (functionMode == IsFunctionToSpecialize)
index 815758d..76b5cac 100644 (file)
@@ -114,7 +114,7 @@ void JSActivation::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec
         propertyNames.add(exec->propertyNames().arguments);
 
     {
-        SymbolTable::Locker locker(thisObject->symbolTable()->m_lock);
+        ConcurrentJITLocker 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)
@@ -134,7 +134,7 @@ inline bool JSActivation::symbolTablePutWithAttributes(VM& vm, PropertyName prop
     
     WriteBarrierBase<Unknown>* reg;
     {
-        SymbolTable::Locker locker(symbolTable()->m_lock);
+        ConcurrentJITLocker locker(symbolTable()->m_lock);
         SymbolTable::Map::iterator iter = symbolTable()->find(locker, propertyName.publicName());
         if (iter == symbolTable()->end(locker))
             return false;
index 7400ccb..1e50ba8 100644 (file)
@@ -301,7 +301,7 @@ template <JSScope::LookupMode mode, JSScope::ReturnValues returnValues> JSObject
                             operations->append(ResolveOperation::checkForDynamicEntriesBeforeGlobalScope());
 
                         if (putToBaseOperation) {
-                            CodeBlockLocker locker(callFrame->codeBlock()->m_lock);
+                            ConcurrentJITLocker locker(callFrame->codeBlock()->m_lock);
                             
                             putToBaseOperation->m_isDynamic = requiresDynamicChecks;
                             putToBaseOperation->m_kind = PutToBaseOperation::GlobalPropertyPut;
@@ -347,7 +347,7 @@ template <JSScope::LookupMode mode, JSScope::ReturnValues returnValues> JSObject
                         goto fail;
 
                     if (putToBaseOperation) {
-                        CodeBlockLocker locker(callFrame->codeBlock()->m_lock);
+                        ConcurrentJITLocker locker(callFrame->codeBlock()->m_lock);
                         
                         putToBaseOperation->m_kind = entry.isReadOnly() ? PutToBaseOperation::Readonly : PutToBaseOperation::VariablePut;
                         putToBaseOperation->m_structure.set(callFrame->vm(), callFrame->codeBlock()->ownerExecutable(), callFrame->lexicalGlobalObject()->activationStructure());
@@ -611,7 +611,7 @@ void JSScope::resolvePut(CallFrame* callFrame, JSValue base, const Identifier& p
     if (slot.base() != baseObject)
         return;
     ASSERT(!baseObject->hasInlineStorage());
-    CodeBlockLocker locker(callFrame->codeBlock()->m_lock);
+    ConcurrentJITLocker locker(callFrame->codeBlock()->m_lock);
     
     operation->m_structure.set(callFrame->vm(), callFrame->codeBlock()->ownerExecutable(), baseObject->structure());
     setPutPropertyAccessOffset(operation, slot.cachedOffset());
index 3f8c402..ae19da2 100644 (file)
@@ -35,7 +35,7 @@ namespace JSC {
 
 int JSSegmentedVariableObject::findRegisterIndex(void* registerAddress)
 {
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     for (int i = m_registers.size(); i--;) {
         if (&m_registers[i] != registerAddress)
@@ -48,7 +48,7 @@ int JSSegmentedVariableObject::findRegisterIndex(void* registerAddress)
 
 int JSSegmentedVariableObject::addRegisters(int numberOfRegistersToAdd)
 {
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     ASSERT(numberOfRegistersToAdd >= 0);
     
index 1cc7988..002760a 100644 (file)
@@ -92,11 +92,8 @@ protected:
         Base::finishCreation(vm);
     }
     
-    typedef ConcurrentJITLock Lock;
-    typedef ConcurrentJITLocker Locker;
-
     SegmentedVector<WriteBarrier<Unknown>, 16> m_registers;
-    Lock m_lock;
+    ConcurrentJITLock m_lock;
 };
 
 } // namespace JSC
index 65fd098..065ebf4 100644 (file)
@@ -61,7 +61,7 @@ void JSSymbolTableObject::getOwnNonIndexPropertyNames(JSObject* object, ExecStat
 {
     JSSymbolTableObject* thisObject = jsCast<JSSymbolTableObject*>(object);
     {
-        SymbolTable::Locker locker(thisObject->symbolTable()->m_lock);
+        ConcurrentJITLocker 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))
index f4a3b5e..8e3d9f1 100644 (file)
@@ -73,7 +73,7 @@ inline bool symbolTableGet(
     SymbolTableObjectType* object, PropertyName propertyName, PropertySlot& slot)
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::Locker locker(symbolTable.m_lock);
+    ConcurrentJITLocker locker(symbolTable.m_lock);
     SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
     if (iter == symbolTable.end(locker))
         return false;
@@ -88,7 +88,7 @@ inline bool symbolTableGet(
     SymbolTableObjectType* object, PropertyName propertyName, PropertyDescriptor& descriptor)
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::Locker locker(symbolTable.m_lock);
+    ConcurrentJITLocker locker(symbolTable.m_lock);
     SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
     if (iter == symbolTable.end(locker))
         return false;
@@ -105,7 +105,7 @@ inline bool symbolTableGet(
     bool& slotIsWriteable)
 {
     SymbolTable& symbolTable = *object->symbolTable();
-    SymbolTable::Locker locker(symbolTable.m_lock);
+    ConcurrentJITLocker locker(symbolTable.m_lock);
     SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
     if (iter == symbolTable.end(locker))
         return false;
@@ -127,7 +127,7 @@ inline bool symbolTablePut(
     WriteBarrierBase<Unknown>* reg;
     {
         SymbolTable& symbolTable = *object->symbolTable();
-        SymbolTable::Locker locker(symbolTable.m_lock);
+        ConcurrentJITLocker locker(symbolTable.m_lock);
         SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
         if (iter == symbolTable.end(locker))
             return false;
@@ -160,7 +160,7 @@ inline bool symbolTablePutWithAttributes(
     WriteBarrierBase<Unknown>* reg;
     {
         SymbolTable& symbolTable = *object->symbolTable();
-        SymbolTable::Locker locker(symbolTable.m_lock);
+        ConcurrentJITLocker locker(symbolTable.m_lock);
         SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.publicName());
         if (iter == symbolTable.end(locker))
             return false;
index 20f05f5..8c49a26 100644 (file)
@@ -278,7 +278,7 @@ void Structure::materializePropertyMap(VM& vm)
     // 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.
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     if (!table)
         createPropertyMap(locker, vm, numberOfSlotsForLastOffset(m_offset, m_inlineCapacity));
     else
@@ -346,7 +346,7 @@ Structure* Structure::addPropertyTransitionToExistingStructure(Structure* struct
 
 Structure* Structure::addPropertyTransitionToExistingStructureConcurrently(Structure* structure, StringImpl* uid, unsigned attributes, JSCell* specificValue, PropertyOffset& offset)
 {
-    Locker locker(structure->m_lock);
+    ConcurrentJITLocker locker(structure->m_lock);
     return addPropertyTransitionToExistingStructureImpl(structure, uid, attributes, specificValue, offset);
 }
 
@@ -418,7 +418,7 @@ Structure* Structure::addPropertyTransition(VM& vm, Structure* structure, Proper
 
     checkOffset(transition->m_offset, transition->inlineCapacity());
     {
-        Locker locker(structure->m_lock);
+        ConcurrentJITLocker locker(structure->m_lock);
         structure->m_transitionTable.add(vm, transition);
     }
     transition->checkOffsetConsistency();
@@ -584,7 +584,7 @@ PropertyTable* Structure::takePropertyTableOrCloneIfPinned(VM& vm, Structure* ow
     // Hold the lock while stealing the table - so that getConcurrently() on another thread
     // will either have to bypass this structure, or will get to use the property table
     // before it is stolen.
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     PropertyTable* takenPropertyTable = propertyTable().get();
     propertyTable().clear();
     return takenPropertyTable;
@@ -620,7 +620,7 @@ Structure* Structure::nonPropertyTransition(VM& vm, Structure* structure, NonPro
     checkOffset(transition->m_offset, transition->inlineCapacity());
     
     {
-        Locker locker(structure->m_lock);
+        ConcurrentJITLocker locker(structure->m_lock);
         structure->m_transitionTable.add(vm, transition);
     }
     transition->checkOffsetConsistency();
@@ -868,7 +868,7 @@ void Structure::despecifyAllFunctions(VM& vm)
 
 PropertyOffset Structure::putSpecificValue(VM& vm, PropertyName propertyName, unsigned attributes, JSCell* specificValue)
 {
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     ASSERT(!JSC::isValidOffset(get(vm, propertyName)));
 
@@ -891,7 +891,7 @@ PropertyOffset Structure::putSpecificValue(VM& vm, PropertyName propertyName, un
 
 PropertyOffset Structure::remove(PropertyName propertyName)
 {
-    Locker locker(m_lock);
+    ConcurrentJITLocker locker(m_lock);
     
     checkConsistency();
 
@@ -913,7 +913,7 @@ PropertyOffset Structure::remove(PropertyName propertyName)
     return offset;
 }
 
-void Structure::createPropertyMap(const Locker&, VM& vm, unsigned capacity)
+void Structure::createPropertyMap(const ConcurrentJITLocker&, VM& vm, unsigned capacity)
 {
     ASSERT(!propertyTable());
 
index 4c4b05c..d4e347e 100644 (file)
@@ -72,9 +72,6 @@ public:
 
     typedef JSCell Base;
     
-    typedef ConcurrentJITLock Lock;
-    typedef ConcurrentJITLocker Locker;
-
     static Structure* create(VM&, JSGlobalObject*, JSValue prototype, const TypeInfo&, const ClassInfo*, IndexingType = NonArray, unsigned inlineCapacity = 0);
 
 protected:
@@ -388,7 +385,7 @@ private:
     PropertyOffset putSpecificValue(VM&, PropertyName, unsigned attributes, JSCell* specificValue);
     PropertyOffset remove(PropertyName);
 
-    void createPropertyMap(const Locker&, VM&, unsigned keyCount = 0);
+    void createPropertyMap(const ConcurrentJITLocker&, VM&, unsigned keyCount = 0);
     void checkConsistency();
 
     bool despecifyFunction(VM&, PropertyName);
@@ -490,7 +487,7 @@ private:
     IndexingType m_indexingType;
     uint8_t m_inlineCapacity;
     
-    Lock m_lock;
+    ConcurrentJITLock m_lock;
     
     unsigned m_dictionaryKind : 2;
     bool m_isPinnedPropertyTable : 1;
index d0ea334..6fcc081 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007, 2008, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -343,91 +343,89 @@ struct SymbolTableIndexHashTraits : HashTraits<SymbolTableEntry> {
 class SymbolTable {
 public:
     typedef HashMap<RefPtr<StringImpl>, SymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<StringImpl> >, SymbolTableIndexHashTraits> Map;
-    typedef ConcurrentJITLock Lock;
-    typedef ConcurrentJITLocker Locker;
 
     JS_EXPORT_PRIVATE SymbolTable();
     JS_EXPORT_PRIVATE ~SymbolTable();
     
     // You must hold the lock until after you're done with the iterator.
-    Map::iterator find(const Locker&, StringImpl* key)
+    Map::iterator find(const ConcurrentJITLocker&, StringImpl* key)
     {
         return m_map.find(key);
     }
     
-    SymbolTableEntry get(const Locker&, StringImpl* key)
+    SymbolTableEntry get(const ConcurrentJITLocker&, StringImpl* key)
     {
         return m_map.get(key);
     }
     
     SymbolTableEntry get(StringImpl* key)
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         return get(locker, key);
     }
     
-    SymbolTableEntry inlineGet(const Locker&, StringImpl* key)
+    SymbolTableEntry inlineGet(const ConcurrentJITLocker&, StringImpl* key)
     {
         return m_map.inlineGet(key);
     }
     
     SymbolTableEntry inlineGet(StringImpl* key)
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         return inlineGet(locker, key);
     }
     
-    Map::iterator begin(const Locker&)
+    Map::iterator begin(const ConcurrentJITLocker&)
     {
         return m_map.begin();
     }
     
-    Map::iterator end(const Locker&)
+    Map::iterator end(const ConcurrentJITLocker&)
     {
         return m_map.end();
     }
     
-    size_t size(const Locker&) const
+    size_t size(const ConcurrentJITLocker&) const
     {
         return m_map.size();
     }
     
     size_t size() const
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         return size(locker);
     }
     
-    Map::AddResult add(const Locker&, StringImpl* key, const SymbolTableEntry& entry)
+    Map::AddResult add(const ConcurrentJITLocker&, StringImpl* key, const SymbolTableEntry& entry)
     {
         return m_map.add(key, entry);
     }
     
     void add(StringImpl* key, const SymbolTableEntry& entry)
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         add(locker, key, entry);
     }
     
-    Map::AddResult set(const Locker&, StringImpl* key, const SymbolTableEntry& entry)
+    Map::AddResult set(const ConcurrentJITLocker&, StringImpl* key, const SymbolTableEntry& entry)
     {
         return m_map.set(key, entry);
     }
     
     void set(StringImpl* key, const SymbolTableEntry& entry)
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         set(locker, key, entry);
     }
     
-    bool contains(const Locker&, StringImpl* key)
+    bool contains(const ConcurrentJITLocker&, StringImpl* key)
     {
         return m_map.contains(key);
     }
     
     bool contains(StringImpl* key)
     {
-        Locker locker(m_lock);
+        ConcurrentJITLocker locker(m_lock);
         return contains(locker, key);
     }