Use const AbstractLocker& (instead of const LockHolder&) in more places.

Mark Lam · Mark Lam · commit 6c55e201bb7c · 2017-03-09T21:05:41.000Z
https://bugs.webkit.org/show_bug.cgi?id=169424 Reviewed by Filip Pizlo. Source/JavaScriptCore: * heap/CodeBlockSet.cpp: (JSC::CodeBlockSet::promoteYoungCodeBlocks): * heap/CodeBlockSet.h: * heap/CodeBlockSetInlines.h: (JSC::CodeBlockSet::mark): * heap/ConservativeRoots.cpp: (JSC::CompositeMarkHook::CompositeMarkHook): * heap/MachineStackMarker.cpp: (JSC::MachineThreads::tryCopyOtherThreadStacks): * heap/MachineStackMarker.h: * profiler/ProfilerDatabase.cpp: (JSC::Profiler::Database::ensureBytecodesFor): * profiler/ProfilerDatabase.h: * runtime/SamplingProfiler.cpp: (JSC::FrameWalker::FrameWalker): (JSC::CFrameWalker::CFrameWalker): (JSC::SamplingProfiler::createThreadIfNecessary): (JSC::SamplingProfiler::takeSample): (JSC::SamplingProfiler::start): (JSC::SamplingProfiler::pause): (JSC::SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread): (JSC::SamplingProfiler::clearData): (JSC::SamplingProfiler::releaseStackTraces): * runtime/SamplingProfiler.h: (JSC::SamplingProfiler::setStopWatch): * wasm/WasmMemory.cpp: (JSC::Wasm::availableFastMemories): (JSC::Wasm::activeFastMemories): (JSC::Wasm::viewActiveFastMemories): * wasm/WasmMemory.h: Source/WTF: * wtf/RunLoop.h: * wtf/generic/RunLoopGeneric.cpp: (WTF::RunLoop::wakeUp): (WTF::RunLoop::schedule): Canonical link: https://commits.webkit.org/186414@main git-svn-id: https://svn.webkit.org/repository/webkit/trunk@213657 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,41 @@
+2017-03-09  Mark Lam  <mark.lam@apple.com>
+
+        Use const AbstractLocker& (instead of const LockHolder&) in more places.
+        https://bugs.webkit.org/show_bug.cgi?id=169424
+
+        Reviewed by Filip Pizlo.
+
+        * heap/CodeBlockSet.cpp:
+        (JSC::CodeBlockSet::promoteYoungCodeBlocks):
+        * heap/CodeBlockSet.h:
+        * heap/CodeBlockSetInlines.h:
+        (JSC::CodeBlockSet::mark):
+        * heap/ConservativeRoots.cpp:
+        (JSC::CompositeMarkHook::CompositeMarkHook):
+        * heap/MachineStackMarker.cpp:
+        (JSC::MachineThreads::tryCopyOtherThreadStacks):
+        * heap/MachineStackMarker.h:
+        * profiler/ProfilerDatabase.cpp:
+        (JSC::Profiler::Database::ensureBytecodesFor):
+        * profiler/ProfilerDatabase.h:
+        * runtime/SamplingProfiler.cpp:
+        (JSC::FrameWalker::FrameWalker):
+        (JSC::CFrameWalker::CFrameWalker):
+        (JSC::SamplingProfiler::createThreadIfNecessary):
+        (JSC::SamplingProfiler::takeSample):
+        (JSC::SamplingProfiler::start):
+        (JSC::SamplingProfiler::pause):
+        (JSC::SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread):
+        (JSC::SamplingProfiler::clearData):
+        (JSC::SamplingProfiler::releaseStackTraces):
+        * runtime/SamplingProfiler.h:
+        (JSC::SamplingProfiler::setStopWatch):
+        * wasm/WasmMemory.cpp:
+        (JSC::Wasm::availableFastMemories):
+        (JSC::Wasm::activeFastMemories):
+        (JSC::Wasm::viewActiveFastMemories):
+        * wasm/WasmMemory.h:
+
 2017-03-09  Saam Barati  <sbarati@apple.com>
 
         WebAssembly: Make the Unity AngryBots demo run
diff --git a/Source/JavaScriptCore/heap/CodeBlockSet.cpp b/Source/JavaScriptCore/heap/CodeBlockSet.cpp
@@ -47,7 +47,7 @@ void CodeBlockSet::add(CodeBlock* codeBlock)
     ASSERT_UNUSED(isNewEntry, isNewEntry);
 }
 
-void CodeBlockSet::promoteYoungCodeBlocks(const LockHolder&)
+void CodeBlockSet::promoteYoungCodeBlocks(const AbstractLocker&)
 {
     ASSERT(m_lock.isLocked());
     m_oldCodeBlocks.add(m_newCodeBlocks.begin(), m_newCodeBlocks.end());
diff --git a/Source/JavaScriptCore/heap/CodeBlockSet.h b/Source/JavaScriptCore/heap/CodeBlockSet.h
@@ -62,9 +62,9 @@ class CodeBlockSet {
     // Mark a pointer that may be a CodeBlock that belongs to the set of DFG
     // blocks. This is defined in CodeBlock.h.
 private:
-    void mark(const LockHolder&, CodeBlock* candidateCodeBlock);
+    void mark(const AbstractLocker&, CodeBlock* candidateCodeBlock);
 public:
-    void mark(const LockHolder&, void* candidateCodeBlock);
+    void mark(const AbstractLocker&, void* candidateCodeBlock);
     
     // Delete all code blocks that are only referenced by this set (i.e. owned
     // by this set), and that have not been marked.
@@ -86,7 +86,7 @@ class CodeBlockSet {
     void dump(PrintStream&) const;
 
 private:
-    void promoteYoungCodeBlocks(const LockHolder&);
+    void promoteYoungCodeBlocks(const AbstractLocker&);
 
     HashSet<CodeBlock*> m_oldCodeBlocks;
     HashSet<CodeBlock*> m_newCodeBlocks;
diff --git a/Source/JavaScriptCore/heap/CodeBlockSetInlines.h b/Source/JavaScriptCore/heap/CodeBlockSetInlines.h
@@ -33,7 +33,7 @@
 
 namespace JSC {
 
-inline void CodeBlockSet::mark(const LockHolder& locker, void* candidateCodeBlock)
+inline void CodeBlockSet::mark(const AbstractLocker& locker, void* candidateCodeBlock)
 {
     ASSERT(m_lock.isLocked());
     // We have to check for 0 and -1 because those are used by the HashMap as markers.
@@ -52,7 +52,7 @@ inline void CodeBlockSet::mark(const LockHolder& locker, void* candidateCodeBloc
     mark(locker, codeBlock);
 }
 
-inline void CodeBlockSet::mark(const LockHolder&, CodeBlock* codeBlock)
+inline void CodeBlockSet::mark(const AbstractLocker&, CodeBlock* codeBlock)
 {
     if (!codeBlock)
         return;
diff --git a/Source/JavaScriptCore/heap/ConservativeRoots.cpp b/Source/JavaScriptCore/heap/ConservativeRoots.cpp
@@ -117,7 +117,7 @@ void ConservativeRoots::add(void* begin, void* end, JITStubRoutineSet& jitStubRo
 
 class CompositeMarkHook {
 public:
-    CompositeMarkHook(JITStubRoutineSet& stubRoutines, CodeBlockSet& codeBlocks, const LockHolder& locker)
+    CompositeMarkHook(JITStubRoutineSet& stubRoutines, CodeBlockSet& codeBlocks, const AbstractLocker& locker)
         : m_stubRoutines(stubRoutines)
         , m_codeBlocks(codeBlocks)
         , m_codeBlocksLocker(locker)
@@ -133,7 +133,7 @@ class CompositeMarkHook {
 private:
     JITStubRoutineSet& m_stubRoutines;
     CodeBlockSet& m_codeBlocks;
-    const LockHolder& m_codeBlocksLocker;
+    const AbstractLocker& m_codeBlocksLocker;
 };
 
 void ConservativeRoots::add(
diff --git a/Source/JavaScriptCore/heap/MachineStackMarker.cpp b/Source/JavaScriptCore/heap/MachineStackMarker.cpp
@@ -928,7 +928,7 @@ void MachineThreads::tryCopyOtherThreadStack(Thread* thread, void* buffer, size_
     thread->freeRegisters(registers);
 }
 
-bool MachineThreads::tryCopyOtherThreadStacks(LockHolder&, void* buffer, size_t capacity, size_t* size)
+bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker&, void* buffer, size_t capacity, size_t* size)
 {
     // Prevent two VMs from suspending each other's threads at the same time,
     // which can cause deadlock: <rdar://problem/20300842>.
diff --git a/Source/JavaScriptCore/heap/MachineStackMarker.h b/Source/JavaScriptCore/heap/MachineStackMarker.h
@@ -142,7 +142,7 @@ class MachineThreads {
     void gatherFromCurrentThread(ConservativeRoots&, JITStubRoutineSet&, CodeBlockSet&, CurrentThreadState&);
 
     void tryCopyOtherThreadStack(Thread*, void*, size_t capacity, size_t*);
-    bool tryCopyOtherThreadStacks(LockHolder&, void*, size_t capacity, size_t*);
+    bool tryCopyOtherThreadStacks(const AbstractLocker&, void*, size_t capacity, size_t*);
 
     static void THREAD_SPECIFIC_CALL removeThread(void*);
 
diff --git a/Source/JavaScriptCore/profiler/ProfilerDatabase.cpp b/Source/JavaScriptCore/profiler/ProfilerDatabase.cpp
@@ -62,7 +62,7 @@ Bytecodes* Database::ensureBytecodesFor(CodeBlock* codeBlock)
     return ensureBytecodesFor(locker, codeBlock);
 }
 
-Bytecodes* Database::ensureBytecodesFor(const LockHolder&, CodeBlock* codeBlock)
+Bytecodes* Database::ensureBytecodesFor(const AbstractLocker&, CodeBlock* codeBlock)
 {
     codeBlock = codeBlock->baselineAlternative();
     
diff --git a/Source/JavaScriptCore/profiler/ProfilerDatabase.h b/Source/JavaScriptCore/profiler/ProfilerDatabase.h
@@ -72,7 +72,7 @@ class Database {
     JS_EXPORT_PRIVATE void logEvent(CodeBlock* codeBlock, const char* summary, const CString& detail);
     
 private:
-    Bytecodes* ensureBytecodesFor(const LockHolder&, CodeBlock*);
+    Bytecodes* ensureBytecodesFor(const AbstractLocker&, CodeBlock*);
     
     void addDatabaseToAtExit();
     void removeDatabaseFromAtExit();
diff --git a/Source/JavaScriptCore/runtime/SamplingProfiler.cpp b/Source/JavaScriptCore/runtime/SamplingProfiler.cpp
@@ -81,7 +81,7 @@ ALWAYS_INLINE static void reportStats()
 
 class FrameWalker {
 public:
-    FrameWalker(VM& vm, ExecState* callFrame, const LockHolder& codeBlockSetLocker, const LockHolder& machineThreadsLocker)
+    FrameWalker(VM& vm, ExecState* callFrame, const AbstractLocker& codeBlockSetLocker, const AbstractLocker& machineThreadsLocker)
         : m_vm(vm)
         , m_callFrame(callFrame)
         , m_vmEntryFrame(vm.topVMEntryFrame)
@@ -190,8 +190,8 @@ class FrameWalker {
     VM& m_vm;
     ExecState* m_callFrame;
     VMEntryFrame* m_vmEntryFrame;
-    const LockHolder& m_codeBlockSetLocker;
-    const LockHolder& m_machineThreadsLocker;
+    const AbstractLocker& m_codeBlockSetLocker;
+    const AbstractLocker& m_machineThreadsLocker;
     bool m_bailingOut { false };
     size_t m_depth { 0 };
 };
@@ -200,7 +200,7 @@ class CFrameWalker : public FrameWalker {
 public:
     typedef FrameWalker Base;
 
-    CFrameWalker(VM& vm, void* machineFrame, ExecState* callFrame, const LockHolder& codeBlockSetLocker, const LockHolder& machineThreadsLocker)
+    CFrameWalker(VM& vm, void* machineFrame, ExecState* callFrame, const AbstractLocker& codeBlockSetLocker, const AbstractLocker& machineThreadsLocker)
         : Base(vm, callFrame, codeBlockSetLocker, machineThreadsLocker)
         , m_machineFrame(machineFrame)
     {
@@ -296,7 +296,7 @@ SamplingProfiler::~SamplingProfiler()
 {
 }
 
-void SamplingProfiler::createThreadIfNecessary(const LockHolder&)
+void SamplingProfiler::createThreadIfNecessary(const AbstractLocker&)
 {
     ASSERT(m_lock.isLocked());
 
@@ -334,7 +334,7 @@ void SamplingProfiler::timerLoop()
     }
 }
 
-void SamplingProfiler::takeSample(const LockHolder&, std::chrono::microseconds& stackTraceProcessingTime)
+void SamplingProfiler::takeSample(const AbstractLocker&, std::chrono::microseconds& stackTraceProcessingTime)
 {
     ASSERT(m_lock.isLocked());
     if (m_vm.entryScope) {
@@ -659,21 +659,21 @@ void SamplingProfiler::start()
     start(locker);
 }
 
-void SamplingProfiler::start(const LockHolder& locker)
+void SamplingProfiler::start(const AbstractLocker& locker)
 {
     ASSERT(m_lock.isLocked());
     m_isPaused = false;
     createThreadIfNecessary(locker);
 }
 
-void SamplingProfiler::pause(const LockHolder&)
+void SamplingProfiler::pause(const AbstractLocker&)
 {
     ASSERT(m_lock.isLocked());
     m_isPaused = true;
     reportStats();
 }
 
-void SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread(const LockHolder&)
+void SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread(const AbstractLocker&)
 {
     ASSERT(m_lock.isLocked());
     m_jscExecutionThread = m_vm.heap.machineThreads().machineThreadForCurrentThread();
@@ -700,7 +700,7 @@ void SamplingProfiler::noticeVMEntry()
     createThreadIfNecessary(locker);
 }
 
-void SamplingProfiler::clearData(const LockHolder&)
+void SamplingProfiler::clearData(const AbstractLocker&)
 {
     ASSERT(m_lock.isLocked());
     m_stackTraces.clear();
@@ -858,7 +858,7 @@ String SamplingProfiler::StackFrame::url()
     return url;
 }
 
-Vector<SamplingProfiler::StackTrace> SamplingProfiler::releaseStackTraces(const LockHolder& locker)
+Vector<SamplingProfiler::StackTrace> SamplingProfiler::releaseStackTraces(const AbstractLocker& locker)
 {
     ASSERT(m_lock.isLocked());
     {
diff --git a/Source/JavaScriptCore/runtime/SamplingProfiler.h b/Source/JavaScriptCore/runtime/SamplingProfiler.h
@@ -166,15 +166,15 @@ class SamplingProfiler : public ThreadSafeRefCounted<SamplingProfiler> {
     Lock& getLock() { return m_lock; }
     void setTimingInterval(std::chrono::microseconds interval) { m_timingInterval = interval; }
     JS_EXPORT_PRIVATE void start();
-    void start(const LockHolder&);
-    Vector<StackTrace> releaseStackTraces(const LockHolder&);
+    void start(const AbstractLocker&);
+    Vector<StackTrace> releaseStackTraces(const AbstractLocker&);
     JS_EXPORT_PRIVATE String stackTracesAsJSON();
     JS_EXPORT_PRIVATE void noticeCurrentThreadAsJSCExecutionThread();
-    void noticeCurrentThreadAsJSCExecutionThread(const LockHolder&);
+    void noticeCurrentThreadAsJSCExecutionThread(const AbstractLocker&);
     void processUnverifiedStackTraces(); // You should call this only after acquiring the lock.
-    void setStopWatch(const LockHolder&, Ref<Stopwatch>&& stopwatch) { m_stopwatch = WTFMove(stopwatch); }
-    void pause(const LockHolder&);
-    void clearData(const LockHolder&);
+    void setStopWatch(const AbstractLocker&, Ref<Stopwatch>&& stopwatch) { m_stopwatch = WTFMove(stopwatch); }
+    void pause(const AbstractLocker&);
+    void clearData(const AbstractLocker&);
 
     // Used for debugging in the JSC shell/DRT.
     void registerForReportAtExit();
@@ -185,9 +185,9 @@ class SamplingProfiler : public ThreadSafeRefCounted<SamplingProfiler> {
     JS_EXPORT_PRIVATE void reportTopBytecodes(PrintStream&);
 
 private:
-    void createThreadIfNecessary(const LockHolder&);
+    void createThreadIfNecessary(const AbstractLocker&);
     void timerLoop();
-    void takeSample(const LockHolder&, std::chrono::microseconds& stackTraceProcessingTime);
+    void takeSample(const AbstractLocker&, std::chrono::microseconds& stackTraceProcessingTime);
 
     VM& m_vm;
     RefPtr<Stopwatch> m_stopwatch;
diff --git a/Source/JavaScriptCore/wasm/WasmMemory.cpp b/Source/JavaScriptCore/wasm/WasmMemory.cpp
@@ -68,19 +68,19 @@ Memory::Mode Memory::lastAllocatedMode()
 static const unsigned maxFastMemories = 4;
 static unsigned allocatedFastMemories { 0 };
 StaticLock memoryLock;
-inline Deque<void*, maxFastMemories>& availableFastMemories(const LockHolder&)
+inline Deque<void*, maxFastMemories>& availableFastMemories(const AbstractLocker&)
 {
     static NeverDestroyed<Deque<void*, maxFastMemories>> availableFastMemories;
     return availableFastMemories;
 }
 
-inline HashSet<void*>& activeFastMemories(const LockHolder&)
+inline HashSet<void*>& activeFastMemories(const AbstractLocker&)
 {
     static NeverDestroyed<HashSet<void*>> activeFastMemories;
     return activeFastMemories;
 }
 
-const HashSet<void*>& viewActiveFastMemories(const LockHolder& locker)
+const HashSet<void*>& viewActiveFastMemories(const AbstractLocker& locker)
 {
     return activeFastMemories(locker);
 }
diff --git a/Source/JavaScriptCore/wasm/WasmMemory.h b/Source/JavaScriptCore/wasm/WasmMemory.h
@@ -98,7 +98,7 @@ static_assert(sizeof(uint64_t) == sizeof(size_t), "We rely on allowing the maxim
 
 const size_t fastMemoryMappedBytes = (static_cast<size_t>(std::numeric_limits<uint32_t>::max()) + 1) * 2; // pointer max + offset max. This is all we need since a load straddling readable memory will trap.
 extern StaticLock memoryLock;
-const HashSet<void*>& viewActiveFastMemories(const LockHolder&);
+const HashSet<void*>& viewActiveFastMemories(const AbstractLocker&);
 
 } } // namespace JSC::Wasm
 
diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
@@ -1,3 +1,15 @@
+2017-03-09  Mark Lam  <mark.lam@apple.com>
+
+        Use const AbstractLocker& (instead of const LockHolder&) in more places.
+        https://bugs.webkit.org/show_bug.cgi?id=169424
+
+        Reviewed by Filip Pizlo.
+
+        * wtf/RunLoop.h:
+        * wtf/generic/RunLoopGeneric.cpp:
+        (WTF::RunLoop::wakeUp):
+        (WTF::RunLoop::schedule):
+
 2017-03-09  Mark Lam  <mark.lam@apple.com>
 
         Make the VM Traps mechanism non-polling for the DFG and FTL.
diff --git a/Source/WTF/wtf/RunLoop.h b/Source/WTF/wtf/RunLoop.h
@@ -167,8 +167,8 @@ class RunLoop : public FunctionDispatcher {
     GRefPtr<GSource> m_source;
 #elif USE(GENERIC_EVENT_LOOP)
     void schedule(RefPtr<TimerBase::ScheduledTask>&&);
-    void schedule(const LockHolder&, RefPtr<TimerBase::ScheduledTask>&&);
-    void wakeUp(const LockHolder&);
+    void schedule(const AbstractLocker&, RefPtr<TimerBase::ScheduledTask>&&);
+    void wakeUp(const AbstractLocker&);
     void scheduleAndWakeUp(RefPtr<TimerBase::ScheduledTask>);
 
     enum class RunMode {
diff --git a/Source/WTF/wtf/generic/RunLoopGeneric.cpp b/Source/WTF/wtf/generic/RunLoopGeneric.cpp
@@ -206,7 +206,7 @@ void RunLoop::stop()
     }
 }
 
-void RunLoop::wakeUp(const LockHolder&)
+void RunLoop::wakeUp(const AbstractLocker&)
 {
     m_pendingTasks = true;
     m_readyToRun.notifyOne();
@@ -218,7 +218,7 @@ void RunLoop::wakeUp()
     wakeUp(locker);
 }
 
-void RunLoop::schedule(const LockHolder&, RefPtr<TimerBase::ScheduledTask>&& task)
+void RunLoop::schedule(const AbstractLocker&, RefPtr<TimerBase::ScheduledTask>&& task)
 {
     m_schedules.append(WTFMove(task));
     std::push_heap(m_schedules.begin(), m_schedules.end(), TimerBase::ScheduledTask::EarliestSchedule());

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ void CodeBlockSet::add(CodeBlock* codeBlock)`
`47`	`47`	`ASSERT_UNUSED(isNewEntry, isNewEntry);`
`48`	`48`	`}`
`49`	`49`
`50`		`-void CodeBlockSet::promoteYoungCodeBlocks(const LockHolder&)`
	`50`	`+void CodeBlockSet::promoteYoungCodeBlocks(const AbstractLocker&)`
`51`	`51`	`{`
`52`	`52`	`ASSERT(m_lock.isLocked());`
`53`	`53`	`m_oldCodeBlocks.add(m_newCodeBlocks.begin(), m_newCodeBlocks.end());`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@`
`33`	`33`
`34`	`34`	`namespace JSC {`
`35`	`35`
`36`		`-inline void CodeBlockSet::mark(const LockHolder& locker, void* candidateCodeBlock)`
	`36`	`+inline void CodeBlockSet::mark(const AbstractLocker& locker, void* candidateCodeBlock)`
`37`	`37`	`{`
`38`	`38`	`ASSERT(m_lock.isLocked());`
`39`	`39`	`// We have to check for 0 and -1 because those are used by the HashMap as markers.`
`@@ -52,7 +52,7 @@ inline void CodeBlockSet::mark(const LockHolder& locker, void* candidateCodeBloc`
`52`	`52`	`mark(locker, codeBlock);`
`53`	`53`	`}`
`54`	`54`
`55`		`-inline void CodeBlockSet::mark(const LockHolder&, CodeBlock* codeBlock)`
	`55`	`+inline void CodeBlockSet::mark(const AbstractLocker&, CodeBlock* codeBlock)`
`56`	`56`	`{`
`57`	`57`	`if (!codeBlock)`
`58`	`58`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -928,7 +928,7 @@ void MachineThreads::tryCopyOtherThreadStack(Thread* thread, void* buffer, size_`
`928`	`928`	`thread->freeRegisters(registers);`
`929`	`929`	`}`
`930`	`930`
`931`		`-bool MachineThreads::tryCopyOtherThreadStacks(LockHolder&, void* buffer, size_t capacity, size_t* size)`
	`931`	`+bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker&, void* buffer, size_t capacity, size_t* size)`
`932`	`932`	`{`
`933`	`933`	`// Prevent two VMs from suspending each other's threads at the same time,`
`934`	`934`	`// which can cause deadlock: <rdar://problem/20300842>.`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ Bytecodes* Database::ensureBytecodesFor(CodeBlock* codeBlock)`
`62`	`62`	`return ensureBytecodesFor(locker, codeBlock);`
`63`	`63`	`}`
`64`	`64`
`65`		`-Bytecodes* Database::ensureBytecodesFor(const LockHolder&, CodeBlock* codeBlock)`
	`65`	`+Bytecodes* Database::ensureBytecodesFor(const AbstractLocker&, CodeBlock* codeBlock)`
`66`	`66`	`{`
`67`	`67`	`codeBlock = codeBlock->baselineAlternative();`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ ALWAYS_INLINE static void reportStats()`
`81`	`81`
`82`	`82`	`class FrameWalker {`
`83`	`83`	`public:`
`84`		`- FrameWalker(VM& vm, ExecState* callFrame, const LockHolder& codeBlockSetLocker, const LockHolder& machineThreadsLocker)`
	`84`	`+ FrameWalker(VM& vm, ExecState* callFrame, const AbstractLocker& codeBlockSetLocker, const AbstractLocker& machineThreadsLocker)`
`85`	`85`	`: m_vm(vm)`
`86`	`86`	`, m_callFrame(callFrame)`
`87`	`87`	`, m_vmEntryFrame(vm.topVMEntryFrame)`
`@@ -190,8 +190,8 @@ class FrameWalker {`
`190`	`190`	`VM& m_vm;`
`191`	`191`	`ExecState* m_callFrame;`
`192`	`192`	`VMEntryFrame* m_vmEntryFrame;`
`193`		`- const LockHolder& m_codeBlockSetLocker;`
`194`		`- const LockHolder& m_machineThreadsLocker;`
	`193`	`+ const AbstractLocker& m_codeBlockSetLocker;`
	`194`	`+ const AbstractLocker& m_machineThreadsLocker;`
`195`	`195`	`bool m_bailingOut { false };`
`196`	`196`	`size_t m_depth { 0 };`
`197`	`197`	`};`
`@@ -200,7 +200,7 @@ class CFrameWalker : public FrameWalker {`
`200`	`200`	`public:`
`201`	`201`	`typedef FrameWalker Base;`
`202`	`202`
`203`		`- CFrameWalker(VM& vm, void* machineFrame, ExecState* callFrame, const LockHolder& codeBlockSetLocker, const LockHolder& machineThreadsLocker)`
	`203`	`+ CFrameWalker(VM& vm, void* machineFrame, ExecState* callFrame, const AbstractLocker& codeBlockSetLocker, const AbstractLocker& machineThreadsLocker)`
`204`	`204`	`: Base(vm, callFrame, codeBlockSetLocker, machineThreadsLocker)`
`205`	`205`	`, m_machineFrame(machineFrame)`
`206`	`206`	`{`
`@@ -296,7 +296,7 @@ SamplingProfiler::~SamplingProfiler()`
`296`	`296`	`{`
`297`	`297`	`}`
`298`	`298`
`299`		`-void SamplingProfiler::createThreadIfNecessary(const LockHolder&)`
	`299`	`+void SamplingProfiler::createThreadIfNecessary(const AbstractLocker&)`
`300`	`300`	`{`
`301`	`301`	`ASSERT(m_lock.isLocked());`
`302`	`302`
`@@ -334,7 +334,7 @@ void SamplingProfiler::timerLoop()`
`334`	`334`	`}`
`335`	`335`	`}`
`336`	`336`
`337`		`-void SamplingProfiler::takeSample(const LockHolder&, std::chrono::microseconds& stackTraceProcessingTime)`
	`337`	`+void SamplingProfiler::takeSample(const AbstractLocker&, std::chrono::microseconds& stackTraceProcessingTime)`
`338`	`338`	`{`
`339`	`339`	`ASSERT(m_lock.isLocked());`
`340`	`340`	`if (m_vm.entryScope) {`
`@@ -659,21 +659,21 @@ void SamplingProfiler::start()`
`659`	`659`	`start(locker);`
`660`	`660`	`}`
`661`	`661`
`662`		`-void SamplingProfiler::start(const LockHolder& locker)`
	`662`	`+void SamplingProfiler::start(const AbstractLocker& locker)`
`663`	`663`	`{`
`664`	`664`	`ASSERT(m_lock.isLocked());`
`665`	`665`	`m_isPaused = false;`
`666`	`666`	`createThreadIfNecessary(locker);`
`667`	`667`	`}`
`668`	`668`
`669`		`-void SamplingProfiler::pause(const LockHolder&)`
	`669`	`+void SamplingProfiler::pause(const AbstractLocker&)`
`670`	`670`	`{`
`671`	`671`	`ASSERT(m_lock.isLocked());`
`672`	`672`	`m_isPaused = true;`
`673`	`673`	`reportStats();`
`674`	`674`	`}`
`675`	`675`
`676`		`-void SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread(const LockHolder&)`
	`676`	`+void SamplingProfiler::noticeCurrentThreadAsJSCExecutionThread(const AbstractLocker&)`
`677`	`677`	`{`
`678`	`678`	`ASSERT(m_lock.isLocked());`
`679`	`679`	`m_jscExecutionThread = m_vm.heap.machineThreads().machineThreadForCurrentThread();`
`@@ -700,7 +700,7 @@ void SamplingProfiler::noticeVMEntry()`
`700`	`700`	`createThreadIfNecessary(locker);`
`701`	`701`	`}`
`702`	`702`
`703`		`-void SamplingProfiler::clearData(const LockHolder&)`
	`703`	`+void SamplingProfiler::clearData(const AbstractLocker&)`
`704`	`704`	`{`
`705`	`705`	`ASSERT(m_lock.isLocked());`
`706`	`706`	`m_stackTraces.clear();`
`@@ -858,7 +858,7 @@ String SamplingProfiler::StackFrame::url()`
`858`	`858`	`return url;`
`859`	`859`	`}`
`860`	`860`
`861`		`-Vector<SamplingProfiler::StackTrace> SamplingProfiler::releaseStackTraces(const LockHolder& locker)`
	`861`	`+Vector<SamplingProfiler::StackTrace> SamplingProfiler::releaseStackTraces(const AbstractLocker& locker)`
`862`	`862`	`{`
`863`	`863`	`ASSERT(m_lock.isLocked());`
`864`	`864`	`{`