topcoderKai
diff --git a/‎Source/JavaScriptCore/ChangeLog
+26 b/‎Source/JavaScriptCore/ChangeLog
+26
diff --git a/‎Source/JavaScriptCore/heap/MachineStackMarker.cpp
+3-3 b/‎Source/JavaScriptCore/heap/MachineStackMarker.cpp
+3-3
diff --git a/‎Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
+10-10 b/‎Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
+10-10
diff --git a/‎Source/JavaScriptCore/runtime/ExceptionScope.cpp
+2-2 b/‎Source/JavaScriptCore/runtime/ExceptionScope.cpp
+2-2
diff --git a/‎Source/JavaScriptCore/runtime/JSLock.h
+1-1 b/‎Source/JavaScriptCore/runtime/JSLock.h
+1-1
diff --git a/‎Source/JavaScriptCore/runtime/VM.cpp
+1-1 b/‎Source/JavaScriptCore/runtime/VM.cpp
+1-1
diff --git a/‎Source/JavaScriptCore/runtime/VM.h
+3-3 b/‎Source/JavaScriptCore/runtime/VM.h
+3-3
diff --git a/‎Source/JavaScriptCore/tools/HeapVerifier.cpp
+1-1 b/‎Source/JavaScriptCore/tools/HeapVerifier.cpp
+1-1
diff --git a/‎Source/WTF/ChangeLog
+53 b/‎Source/WTF/ChangeLog
+53
diff --git a/‎Source/WTF/wtf/MainThread.cpp
+5-5 b/‎Source/WTF/wtf/MainThread.cpp
+5-5
diff --git a/‎Source/WTF/wtf/MainThread.h
+4-5 b/‎Source/WTF/wtf/MainThread.h
+4-5
@@ -1,3 +1,29 @@
+2017-12-03  Yusuke Suzuki  <[email protected]>
+
+        WTF shouldn't have both Thread and ThreadIdentifier
+        https://bugs.webkit.org/show_bug.cgi?id=180308
+
+        Reviewed by Darin Adler.
+
+        * heap/MachineStackMarker.cpp:
+        (JSC::MachineThreads::tryCopyOtherThreadStacks):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::llint_trace_operand):
+        (JSC::LLInt::llint_trace_value):
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        (JSC::LLInt::traceFunctionPrologue):
+        * runtime/ExceptionScope.cpp:
+        (JSC::ExceptionScope::unexpectedExceptionMessage):
+        * runtime/JSLock.h:
+        (JSC::JSLock::currentThreadIsHoldingLock):
+        * runtime/VM.cpp:
+        (JSC::VM::throwException):
+        * runtime/VM.h:
+        (JSC::VM::throwingThread const):
+        (JSC::VM::clearException):
+        * tools/HeapVerifier.cpp:
+        (JSC::HeapVerifier::printVerificationHeader):
+
 2017-12-03  Caio Lima  <[email protected]>
 
         Rename DestroyFunc to avoid redefinition on unified build
 
@@ -151,7 +151,7 @@ bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker& locker, void
     {
         unsigned index = 0;
         for (auto& thread : threads) {
-            if (thread.get() != currentThread) {
+            if (thread.ptr() != &currentThread) {
                 auto result = thread->suspend();
                 if (result)
                     isSuspended.set(index);
@@ -160,8 +160,8 @@ bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker& locker, void
                     // These threads will be removed from the ThreadGroup. Thus, we do not do anything here except for reporting.
                     ASSERT(result.error() != KERN_SUCCESS);
                     WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION,
-                        "JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p] id %u.",
-                        result.error(), index, threads.size(), thread.ptr(), thread->id());
+                        "JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p].",
+                        result.error(), index, threads.size(), thread.ptr());
 #endif
                 }
             }
 
@@ -191,8 +191,8 @@ namespace JSC { namespace LLInt {
 extern "C" SlowPathReturnType llint_trace_operand(ExecState* exec, Instruction* pc, int fromWhere, int operand)
 {
     LLINT_BEGIN();
-    dataLogF("<%d> %p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d\n",
-            currentThread(),
+    dataLogF("<%p> %p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d\n",
+            &Thread::current(),
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -215,8 +215,8 @@ extern "C" SlowPathReturnType llint_trace_value(ExecState* exec, Instruction* pc
     } u;
     u.asValue = JSValue::encode(value);
     dataLogF(
-        "<%d> %p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d: %08x:%08x: %s\n",
-        currentThread(),
+        "<%p> %p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d: %08x:%08x: %s\n",
+        &Thread::current(),
         exec->codeBlock(),
         exec,
         static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -232,7 +232,7 @@ extern "C" SlowPathReturnType llint_trace_value(ExecState* exec, Instruction* pc
 
 LLINT_SLOW_PATH_DECL(trace_prologue)
 {
-    dataLogF("<%d> %p / %p: in prologue of ", currentThread(), exec->codeBlock(), exec);
+    dataLogF("<%p> %p / %p: in prologue of ", &Thread::current(), exec->codeBlock(), exec);
     dataLog(*exec->codeBlock(), "\n");
     LLINT_END_IMPL();
 }
@@ -242,7 +242,7 @@ static void traceFunctionPrologue(ExecState* exec, const char* comment, CodeSpec
     JSFunction* callee = jsCast<JSFunction*>(exec->jsCallee());
     FunctionExecutable* executable = callee->jsExecutable();
     CodeBlock* codeBlock = executable->codeBlockFor(kind);
-    dataLogF("<%d> %p / %p: in %s of ", currentThread(), codeBlock, exec, comment);
+    dataLogF("<%p> %p / %p: in %s of ", &Thread::current(), codeBlock, exec, comment);
     dataLog(*codeBlock);
     dataLogF(" function %p, executable %p; numVars = %u, numParameters = %u, numCalleeLocals = %u, caller = %p.\n",
         callee, executable, codeBlock->m_numVars, codeBlock->numParameters(), codeBlock->m_numCalleeLocals, exec->callerFrame());
@@ -275,8 +275,8 @@ LLINT_SLOW_PATH_DECL(trace_arityCheck_for_construct)
 LLINT_SLOW_PATH_DECL(trace)
 {
     OpcodeID opcodeID = Interpreter::getOpcodeID(pc[0].u.opcode);
-    dataLogF("<%d> %p / %p: executing bc#%zu, %s, pc = %p\n",
-            currentThread(),
+    dataLogF("<%p> %p / %p: executing bc#%zu, %s, pc = %p\n",
+            &Thread::current(),
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -294,8 +294,8 @@ LLINT_SLOW_PATH_DECL(trace)
 
 LLINT_SLOW_PATH_DECL(special_trace)
 {
-    dataLogF("<%d> %p / %p: executing special case bc#%zu, op#%u, return PC is %p\n",
-            currentThread(),
+    dataLogF("<%p> %p / %p: executing special case bc#%zu, op#%u, return PC is %p\n",
+            &Thread::current(),
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
 
@@ -55,14 +55,14 @@ CString ExceptionScope::unexpectedExceptionMessage()
 {
     StringPrintStream out;
 
-    out.println("Unexpected exception observed on thread ", currentThread(), " at:");
+    out.println("Unexpected exception observed on thread ", Thread::current(), " at:");
     auto currentStack = StackTrace::captureStackTrace(Options::unexpectedExceptionStackTraceLimit(), 1);
     currentStack->dump(out, "    ");
 
     if (!m_vm.nativeStackTraceOfLastThrow())
         return CString();
 
-    out.println("The exception was thrown from thread ", m_vm.throwingThread(), " at:");
+    out.println("The exception was thrown from thread ", *m_vm.throwingThread(), " at:");
     m_vm.nativeStackTraceOfLastThrow()->dump(out, "    ");
 
     return out.toCString();
 
@@ -98,7 +98,7 @@ class JSLock : public ThreadSafeRefCounted<JSLock> {
             return m_ownerThread;
         return std::nullopt;
     }
-    bool currentThreadIsHoldingLock() { return m_hasOwnerThread && m_ownerThread->id() == currentThread(); }
+    bool currentThreadIsHoldingLock() { return m_hasOwnerThread && m_ownerThread.get() == &Thread::current(); }
 
     void willDestroyVM(VM*);
 
 
@@ -689,7 +689,7 @@ void VM::throwException(ExecState* exec, Exception* exception)
 
 #if ENABLE(EXCEPTION_SCOPE_VERIFICATION)
     m_nativeStackTraceOfLastThrow = StackTrace::captureStackTrace(Options::unexpectedExceptionStackTraceLimit());
-    m_throwingThread = currentThread();
+    m_throwingThread = &Thread::current();
 #endif
 }
 
 
@@ -711,7 +711,7 @@ class VM : public ThreadSafeRefCounted<VM>, public DoublyLinkedListNode<VM> {
 
 #if ENABLE(EXCEPTION_SCOPE_VERIFICATION)
     StackTrace* nativeStackTraceOfLastThrow() const { return m_nativeStackTraceOfLastThrow.get(); }
-    ThreadIdentifier throwingThread() const { return m_throwingThread; }
+    Thread* throwingThread() const { return m_throwingThread.get(); }
 #endif
 
 #if USE(CF)
@@ -754,7 +754,7 @@ class VM : public ThreadSafeRefCounted<VM>, public DoublyLinkedListNode<VM> {
 #if ENABLE(EXCEPTION_SCOPE_VERIFICATION)
         m_needExceptionCheck = false;
         m_nativeStackTraceOfLastThrow = nullptr;
-        m_throwingThread = 0;
+        m_throwingThread = nullptr;
 #endif
         m_exception = nullptr;
     }
@@ -806,7 +806,7 @@ class VM : public ThreadSafeRefCounted<VM>, public DoublyLinkedListNode<VM> {
     mutable bool m_needExceptionCheck { false };
     std::unique_ptr<StackTrace> m_nativeStackTraceOfLastThrow;
     std::unique_ptr<StackTrace> m_nativeStackTraceOfLastSimulatedThrow;
-    ThreadIdentifier m_throwingThread;
+    RefPtr<Thread> m_throwingThread;
 #endif
 
     bool m_failNextNewCodeBlock { false };
 
@@ -143,7 +143,7 @@ void HeapVerifier::printVerificationHeader()
     RELEASE_ASSERT(m_heap->collectionScope());
     CollectionScope scope = currentCycle().scope;
     MonotonicTime gcCycleTimestamp = currentCycle().timestamp;
-    dataLog("Verifying heap in [p", getCurrentProcessID(), ", t", currentThread(), "] vm ",
+    dataLog("Verifying heap in [p", getCurrentProcessID(), ", ", Thread::current(), "] vm ",
         RawPointer(m_heap->vm()), " on ", scope, " GC @ ", gcCycleTimestamp, "\n");
 }
 
 
@@ -1,3 +1,56 @@
+2017-12-03  Yusuke Suzuki  <[email protected]>
+
+        WTF shouldn't have both Thread and ThreadIdentifier
+        https://bugs.webkit.org/show_bug.cgi?id=180308
+
+        Reviewed by Darin Adler.
+
+        We should use a pointer of WTF::Thread instead of ThreadIdentifier.
+
+        One problem is that Windows support library uses WTF::createThread,
+        which returns ThreadIdentifier. So we cannot drop ThreadIdentifier
+        in Windows environment. This patch keeps ThreadIdentifier in Windows.
+
+        * wtf/MainThread.cpp:
+        (WTF::initializeMainThread):
+        (WTF::isMainThread):
+        (WTF::canAccessThreadLocalDataForThread):
+        * wtf/MainThread.h:
+        * wtf/ParkingLot.cpp:
+        (WTF::ParkingLot::parkConditionallyImpl):
+        (WTF::ParkingLot::unparkOne):
+        (WTF::ParkingLot::unparkOneImpl):
+        (WTF::ParkingLot::unparkCount):
+        * wtf/RecursiveLockAdapter.h:
+        (WTF::RecursiveLockAdapter::lock):
+        (WTF::RecursiveLockAdapter::unlock):
+        (WTF::RecursiveLockAdapter::tryLock):
+        * wtf/Threading.cpp:
+        (WTF::Thread::dump const):
+        * wtf/Threading.h:
+        (WTF::Thread::id const):
+        (WTF::Thread::operator==): Deleted.
+        (WTF::Thread::operator!=): Deleted.
+        (WTF::currentThread): Deleted.
+        * wtf/ThreadingPrimitives.h:
+        * wtf/ThreadingPthreads.cpp:
+        (WTF::Thread::waitForCompletion):
+        (WTF::Thread::detach):
+        (WTF::Thread::initializeCurrentTLS):
+        (WTF::Thread::suspend):
+        (WTF::Thread::establishPlatformSpecificHandle):
+        (WTF::Thread::currentID): Deleted.
+        * wtf/ThreadingWin.cpp:
+        (WTF::Thread::waitForCompletion):
+        (WTF::Thread::suspend):
+        (WTF::Thread::currentDying):
+        * wtf/mac/MainThreadMac.mm:
+        (WTF::initializeApplicationUIThread):
+        (WTF::initializeWebThreadPlatform):
+        (WTF::canAccessThreadLocalDataForThread):
+        (WTF::initializeApplicationUIThreadIdentifier): Deleted.
+        (WTF::initializeWebThreadIdentifier): Deleted.
+
 2017-12-03  Darin Adler  <[email protected]>
 
         Add WTF::Hasher, an easier to use replacement for WTF::IntegerHasher
 
@@ -44,7 +44,7 @@ namespace WTF {
 
 static bool callbacksPaused; // This global variable is only accessed from main thread.
 #if !PLATFORM(COCOA)
-static ThreadIdentifier mainThreadIdentifier;
+static Thread* mainThread { nullptr };
 #endif
 
 static StaticLock mainThreadFunctionQueueMutex;
@@ -62,7 +62,7 @@ void initializeMainThread()
     std::call_once(initializeKey, [] {
         initializeThreading();
 #if !PLATFORM(COCOA)
-        mainThreadIdentifier = currentThread();
+        mainThread = &Thread::current();
 #endif
         initializeMainThreadPlatform();
         initializeGCThreads();
@@ -72,7 +72,7 @@ void initializeMainThread()
 #if !PLATFORM(COCOA)
 bool isMainThread()
 {
-    return currentThread() == mainThreadIdentifier;
+    return mainThread == &Thread::current();
 }
 #endif
 
@@ -98,9 +98,9 @@ void initializeWebThread()
 #endif // PLATFORM(COCOA)
 
 #if !USE(WEB_THREAD)
-bool canAccessThreadLocalDataForThread(ThreadIdentifier threadId)
+bool canAccessThreadLocalDataForThread(Thread& thread)
 {
-    return threadId == currentThread();
+    return &thread == &Thread::current();
 }
 #endif
 
 
@@ -39,6 +39,7 @@
 namespace WTF {
 
 class PrintStream;
+class Thread;
 
 // Must be called from the main thread.
 WTF_EXPORT_PRIVATE void initializeMainThread();
@@ -54,14 +55,13 @@ WTF_EXPORT_PRIVATE void setMainThreadCallbacksPaused(bool paused);
 
 WTF_EXPORT_PRIVATE bool isMainThread();
 
-WTF_EXPORT_PRIVATE bool canAccessThreadLocalDataForThread(ThreadIdentifier);
+WTF_EXPORT_PRIVATE bool canAccessThreadLocalDataForThread(Thread&);
 
 #if USE(WEB_THREAD)
 WTF_EXPORT_PRIVATE bool isWebThread();
 WTF_EXPORT_PRIVATE bool isUIThread();
 WTF_EXPORT_PRIVATE void initializeWebThread();
-WTF_EXPORT_PRIVATE void initializeApplicationUIThreadIdentifier();
-WTF_EXPORT_PRIVATE void initializeWebThreadIdentifier();
+WTF_EXPORT_PRIVATE void initializeApplicationUIThread();
 void initializeWebThreadPlatform();
 #else
 inline bool isWebThread() { return isMainThread(); }
@@ -113,8 +113,7 @@ using WTF::callOnWebThreadOrDispatchAsyncOnMainThread;
 #endif
 #if USE(WEB_THREAD)
 using WTF::initializeWebThread;
-using WTF::initializeApplicationUIThreadIdentifier;
-using WTF::initializeWebThreadIdentifier;
+using WTF::initializeApplicationUIThread;
 #endif
 
 #endif // MainThread_h
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker& locker, void`
`151`	`151`	`{`
`152`	`152`	`unsigned index = 0;`
`153`	`153`	`for (auto& thread : threads) {`
`154`		`- if (thread.get() != currentThread) {`
	`154`	`+ if (thread.ptr() != &currentThread) {`
`155`	`155`	`auto result = thread->suspend();`
`156`	`156`	`if (result)`
`157`	`157`	`isSuspended.set(index);`
`@@ -160,8 +160,8 @@ bool MachineThreads::tryCopyOtherThreadStacks(const AbstractLocker& locker, void`
`160`	`160`	`// These threads will be removed from the ThreadGroup. Thus, we do not do anything here except for reporting.`
`161`	`161`	`ASSERT(result.error() != KERN_SUCCESS);`
`162`	`162`	`WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION,`
`163`		`- "JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p] id %u.",`
`164`		`- result.error(), index, threads.size(), thread.ptr(), thread->id());`
	`163`	`+ "JavaScript garbage collection encountered an invalid thread (err 0x%x): Thread [%d/%d: %p].",`
	`164`	`+ result.error(), index, threads.size(), thread.ptr());`
`165`	`165`	`#endif`
`166`	`166`	`}`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ class JSLock : public ThreadSafeRefCounted<JSLock> {`
`98`	`98`	`return m_ownerThread;`
`99`	`99`	`return std::nullopt;`
`100`	`100`	`}`
`101`		`- bool currentThreadIsHoldingLock() { return m_hasOwnerThread && m_ownerThread->id() == currentThread(); }`
	`101`	`+ bool currentThreadIsHoldingLock() { return m_hasOwnerThread && m_ownerThread.get() == &Thread::current(); }`
`102`	`102`
`103`	`103`	`void willDestroyVM(VM*);`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -689,7 +689,7 @@ void VM::throwException(ExecState* exec, Exception* exception)`
`689`	`689`
`690`	`690`	`#if ENABLE(EXCEPTION_SCOPE_VERIFICATION)`
`691`	`691`	`m_nativeStackTraceOfLastThrow = StackTrace::captureStackTrace(Options::unexpectedExceptionStackTraceLimit());`
`692`		`- m_throwingThread = currentThread();`
	`692`	`+ m_throwingThread = &Thread::current();`
`693`	`693`	`#endif`
`694`	`694`	`}`
`695`	`695`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ void HeapVerifier::printVerificationHeader()`
`143`	`143`	`RELEASE_ASSERT(m_heap->collectionScope());`
`144`	`144`	`CollectionScope scope = currentCycle().scope;`
`145`	`145`	`MonotonicTime gcCycleTimestamp = currentCycle().timestamp;`
`146`		`- dataLog("Verifying heap in [p", getCurrentProcessID(), ", t", currentThread(), "] vm ",`
	`146`	`+ dataLog("Verifying heap in [p", getCurrentProcessID(), ", ", Thread::current(), "] vm ",`
`147`	`147`	`RawPointer(m_heap->vm()), " on ", scope, " GC @ ", gcCycleTimestamp, "\n");`
`148`	`148`	`}`
`149`	`149`