@@ -1,3 +1,81 @@
+2021-05-26  Chris Dumez  <cdumez@apple.com>
+
+        Use UncheckedLock even less in JavaScriptCore
+        https://bugs.webkit.org/show_bug.cgi?id=226278
+
+        Reviewed by Darin Adler.
+
+        Use UncheckedLock even less in JavaScriptCore as it is being phased out in
+        favor of Lock, which supports Clang thread safety analysis.
+
+        * heap/BlockDirectory.h:
+        (JSC::BlockDirectory::WTF_RETURNS_LOCK):
+        * heap/CodeBlockSet.h:
+        (JSC::CodeBlockSet::WTF_RETURNS_LOCK):
+        * heap/Heap.h:
+        * heap/MarkedSpace.h:
+        (JSC::MarkedSpace::directoryLock):
+        * heap/MarkingConstraintSolver.h:
+        * heap/SlotVisitor.cpp:
+        (JSC::SlotVisitor::donateKnownParallel):
+        * heap/SlotVisitor.h:
+        * jit/JITWorklist.cpp:
+        * jit/JITWorklist.h:
+        * jsc.cpp:
+        * profiler/ProfilerDatabase.h:
+        * runtime/DeferredWorkTimer.h:
+        * runtime/VMTraps.cpp:
+        (JSC::VMTraps::invalidateCodeBlocksOnStack):
+        * runtime/VMTraps.h:
+        * tools/FunctionOverrides.cpp:
+        (JSC::FunctionOverrides::FunctionOverrides):
+        (JSC::FunctionOverrides::reinstallOverrides):
+        (JSC::FunctionOverrides::parseOverridesInFile):
+        * tools/FunctionOverrides.h:
+        (JSC::FunctionOverrides::WTF_REQUIRES_LOCK):
+        * tools/VMInspector.cpp:
+        (JSC::ensureIsSafeToLock):
+        (JSC::VMInspector::codeBlockForMachinePC):
+        * wasm/WasmBBQPlan.cpp:
+        (JSC::Wasm::BBQPlan::work):
+        (JSC::Wasm::BBQPlan::compileFunction):
+        (JSC::Wasm::BBQPlan::didCompleteCompilation):
+        * wasm/WasmBBQPlan.h:
+        * wasm/WasmEntryPlan.cpp:
+        (JSC::Wasm::EntryPlan::parseAndValidateModule):
+        (JSC::Wasm::EntryPlan::prepare):
+        (JSC::Wasm::EntryPlan::ThreadCountHolder::~ThreadCountHolder):
+        (JSC::Wasm::EntryPlan::complete):
+        * wasm/WasmEntryPlan.h:
+        (JSC::Wasm::EntryPlan::tryReserveCapacity):
+        * wasm/WasmLLIntPlan.cpp:
+        (JSC::Wasm::LLIntPlan::compileFunction):
+        (JSC::Wasm::LLIntPlan::didCompleteCompilation):
+        (JSC::Wasm::LLIntPlan::completeInStreaming):
+        (JSC::Wasm::LLIntPlan::didFailInStreaming):
+        * wasm/WasmLLIntPlan.h:
+        * wasm/WasmOMGForOSREntryPlan.cpp:
+        (JSC::Wasm::OMGForOSREntryPlan::work):
+        * wasm/WasmOMGForOSREntryPlan.h:
+        * wasm/WasmOMGPlan.cpp:
+        (JSC::Wasm::OMGPlan::work):
+        * wasm/WasmOMGPlan.h:
+        * wasm/WasmPlan.cpp:
+        (JSC::Wasm::Plan::runCompletionTasks):
+        (JSC::Wasm::Plan::tryRemoveContextAndCancelIfLast):
+        (JSC::Wasm::Plan::fail):
+        * wasm/WasmPlan.h:
+        * wasm/WasmStreamingCompiler.cpp:
+        (JSC::Wasm::StreamingCompiler::didCompileFunction):
+        (JSC::Wasm::StreamingCompiler::completeIfNecessary):
+        (JSC::Wasm::StreamingCompiler::didComplete):
+        (JSC::Wasm::StreamingCompiler::finalize):
+        * wasm/WasmStreamingCompiler.h:
+        * wasm/WasmStreamingPlan.cpp:
+        (JSC::Wasm::StreamingPlan::work):
+        * wasm/WasmStreamingPlan.h:
+        * wasm/WasmThunks.h:
+
 2021-05-26  Chris Dumez  <cdumez@apple.com>
 
         Stop using UncheckedLock in WTF::AutomaticThread
 
@@ -93,7 +93,7 @@ class BlockDirectory {
 
     void updatePercentageOfPagedOutPages(WTF::SimpleStats&);
 
-    UncheckedLock& bitvectorLock() { return m_bitvectorLock; }
+    Lock& bitvectorLock() WTF_RETURNS_LOCK(m_bitvectorLock) { return m_bitvectorLock; }
 
 #define BLOCK_DIRECTORY_BIT_ACCESSORS(lowerBitName, capitalBitName)     \
     bool is ## capitalBitName(const AbstractLocker&, size_t index) const { return m_bits.is ## capitalBitName(index); } \
@@ -155,7 +155,7 @@ class BlockDirectory {
     // Mutator uses this to guard resizing the bitvectors. Those things in the GC that may run
     // concurrently to the mutator must lock this when accessing the bitvectors.
     BlockDirectoryBits m_bits;
-    UncheckedLock m_bitvectorLock;
+    Lock m_bitvectorLock;
     Lock m_localAllocatorsLock;
     CellAttributes m_attributes;
 
 
@@ -54,7 +54,7 @@ class CodeBlockSet {
     void clearCurrentlyExecuting();
 
     bool contains(const AbstractLocker&, void* candidateCodeBlock);
-    UncheckedLock& getLock() { return m_lock; }
+    Lock& getLock() WTF_RETURNS_LOCK(m_lock) { return m_lock; }
 
     // This is expected to run only when we're not adding to the set for now. If
     // this needs to run concurrently in the future, we'll need to lock around this.
@@ -78,7 +78,7 @@ class CodeBlockSet {
 private:
     HashSet<CodeBlock*> m_codeBlocks;
     HashSet<CodeBlock*> m_currentlyExecuting;
-    UncheckedLock m_lock;
+    Lock m_lock;
 };
 
 } // namespace JSC
@@ -716,8 +716,8 @@ class Heap {
     Atomic<unsigned> m_worldState;
     bool m_worldIsStopped { false };
     Lock m_visitRaceLock;
-    UncheckedLock m_markingMutex;
-    UncheckedCondition m_markingConditionVariable;
+    Lock m_markingMutex;
+    Condition m_markingConditionVariable;
 
     MonotonicTime m_beforeGC;
     MonotonicTime m_afterGC;
 
@@ -168,7 +168,7 @@ class MarkedSpace {
 
     BlockDirectory* firstDirectory() const { return m_directories.first(); }
 
-    UncheckedLock& directoryLock() { return m_directoryLock; }
+    Lock& directoryLock() { return m_directoryLock; }
     void addBlockDirectory(const AbstractLocker&, BlockDirectory*);
 
     // When this is true it means that we have flipped but the mark bits haven't converged yet.
@@ -214,7 +214,7 @@ class MarkedSpace {
     HeapVersion m_newlyAllocatedVersion { initialVersion };
     bool m_isIterating { false };
     bool m_isMarking { false };
-    UncheckedLock m_directoryLock;
+    Lock m_directoryLock;
     MarkedBlockSet m_blocks;
 
     SentinelLinkedList<WeakSet, BasicRawSentinelNode<WeakSet>> m_activeWeakSets;
 
@@ -95,8 +95,8 @@ class MarkingConstraintSolver {
     BitVector m_executed;
     Deque<TaskWithConstraint, 32> m_toExecuteInParallel;
     Vector<unsigned, 32> m_toExecuteSequentially;
-    UncheckedLock m_lock;
-    UncheckedCondition m_condition;
+    Lock m_lock;
+    Condition m_condition;
     bool m_pickNextIsStillActive { true };
     unsigned m_numThreadsThatMayProduceWork { 0 };
     Vector<VisitCounter, 16> m_visitCounters;
 
@@ -436,9 +436,9 @@ void SlotVisitor::donateKnownParallel(MarkStackArray& from, MarkStackArray& to)
 
     // If we're contending on the lock, be conservative and assume that another
     // thread is already donating.
-    std::unique_lock<UncheckedLock> lock(m_heap.m_markingMutex, std::try_to_lock);
-    if (!lock.owns_lock())
+    if (!m_heap.m_markingMutex.tryLock())
         return;
+    Locker locker { AdoptLock, m_heap.m_markingMutex };
 
     // Otherwise, assume that a thread will go idle soon, and donate.
     from.donateSomeCellsTo(to);
 
@@ -161,7 +161,7 @@ class SlotVisitor final : public AbstractSlotVisitor {
 
     bool mutatorIsStopped() const final { return m_mutatorIsStopped; }
 
-    UncheckedLock& rightToRun() { return m_rightToRun; }
+    Lock& rightToRun() WTF_RETURNS_LOCK(m_rightToRun) { return m_rightToRun; }
 
     void updateMutatorIsStopped(const AbstractLocker&);
     void updateMutatorIsStopped();
@@ -232,7 +232,7 @@ class SlotVisitor final : public AbstractSlotVisitor {
     bool m_mutatorIsStopped { false };
     bool m_canOptimizeForStoppedMutator { false };
     bool m_isInParallelMode { false };
-    UncheckedLock m_rightToRun;
+    Lock m_rightToRun;
 
     // Put padding here to mitigate false sharing between multiple SlotVisitors.
     char padding[64];
 
@@ -109,14 +109,14 @@ size_t JITWorklist::queueLength(const AbstractLocker&) const
     return queueLength;
 }
 
-void JITWorklist::suspendAllThreads()
+void JITWorklist::suspendAllThreads() WTF_IGNORES_THREAD_SAFETY_ANALYSIS
 {
     m_suspensionLock.lock();
     for (unsigned i = m_threads.size(); i--;)
         m_threads[i]->m_rightToRun.lock();
 }
 
-void JITWorklist::resumeAllThreads()
+void JITWorklist::resumeAllThreads() WTF_IGNORES_THREAD_SAFETY_ANALYSIS
 {
     for (unsigned i = m_threads.size(); i--;)
         m_threads[i]->m_rightToRun.unlock();
 
@@ -118,7 +118,7 @@ class JITWorklist {
     // be completed.
     Vector<RefPtr<JITPlan>, 16> m_readyPlans;
 
-    UncheckedLock m_suspensionLock;
+    Lock m_suspensionLock;
     Box<Lock> m_lock;
 
     Ref<AutomaticThreadCondition> m_planEnqueued;
Original file line number	Diff line number	Diff line change
`@@ -109,14 +109,14 @@ size_t JITWorklist::queueLength(const AbstractLocker&) const`
`109`	`109`	`return queueLength;`
`110`	`110`	`}`
`111`	`111`
`112`		`-void JITWorklist::suspendAllThreads()`
	`112`	`+void JITWorklist::suspendAllThreads() WTF_IGNORES_THREAD_SAFETY_ANALYSIS`
`113`	`113`	`{`
`114`	`114`	`m_suspensionLock.lock();`
`115`	`115`	`for (unsigned i = m_threads.size(); i--;)`
`116`	`116`	`m_threads[i]->m_rightToRun.lock();`
`117`	`117`	`}`
`118`	`118`
`119`		`-void JITWorklist::resumeAllThreads()`
	`119`	`+void JITWorklist::resumeAllThreads() WTF_IGNORES_THREAD_SAFETY_ANALYSIS`
`120`	`120`	`{`
`121`	`121`	`for (unsigned i = m_threads.size(); i--;)`
`122`	`122`	`m_threads[i]->m_rightToRun.unlock();`