Complete support for Windows TLS destructors

runtime/vm/os_thread_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"  // NOLINT
 #if defined(TARGET_OS_WINDOWS)
 
+#include "vm/growable_array.h"
 #include "vm/os_thread.h"
 
 #include <process.h>  // NOLINT
 
 #include "platform/assert.h"
 
 namespace dart {
 
 class ThreadStartData {
  public:
@@ skipping 48 matching lines @@
   // Close the handle, so we don't leak the thread object.
   CloseHandle(reinterpret_cast<HANDLE>(thread));
 
   return 0;
 }
 
 ThreadLocalKey OSThread::kUnsetThreadLocalKey = TLS_OUT_OF_INDEXES;
 ThreadId OSThread::kInvalidThreadId = 0;
 ThreadJoinId OSThread::kInvalidThreadJoinId = 0;
 
-ThreadLocalKey OSThread::CreateThreadLocal(ThreadDestructor unused) {
+ThreadLocalKey OSThread::CreateThreadLocal(ThreadDestructor destructor) {
   ThreadLocalKey key = TlsAlloc();
   if (key == kUnsetThreadLocalKey) {
     FATAL1("TlsAlloc failed %d", GetLastError());
   }
+  ThreadLocalData::AddThreadLocal(key, destructor);
   return key;
 }
 
 
 void OSThread::DeleteThreadLocal(ThreadLocalKey key) {
   ASSERT(key != kUnsetThreadLocalKey);
   BOOL result = TlsFree(key);
   if (!result) {
     FATAL1("TlsFree failed %d", GetLastError());
   }
+  ThreadLocalData::RemoveThreadLocal(key);
 }
 
 
 intptr_t OSThread::GetMaxStackSize() {
   const int kStackSize = (128 * kWordSize * KB);
   return kStackSize;
 }
 
 
 ThreadId OSThread::GetCurrentThreadId() {
@@ skipping 374 matching lines @@
 
 void Monitor::NotifyAll() {
   // If one of the objects in the list of waiters wakes because of a
   // timeout before we signal it, that object will get an extra
   // signal. This will be treated as a spurious wake-up and is OK
   // since all uses of monitors should recheck the condition after a
   // Wait.
   data_.SignalAndRemoveAllWaiters();
 }
 
-// This function is defined in thread.cc.
-extern void ThreadCleanupOnExit();
+
+void ThreadLocalData::AddThreadLocal(ThreadLocalKey key,
+                                     ThreadDestructor destructor) {
+  if (thread_locals_ == NULL) {
+    return;
+  }

[siva, 2015/10/15 22:42:48]

Should this be
ASSERT(thread_locals_ != NULL);

[Cutch, 2015/10/16 16:53:25]

Done.

+  if (destructor == NULL) {
+    // We only care about thread locals with destructors.
+    return;
+  }
+  mutex_->Lock();
+#if defined(DEBUG)
+  // Verify that we aren't added twice.
+  for (intptr_t i = 0; i < thread_locals_->length(); i++) {
+    const ThreadLocalEntry& entry = thread_locals_->At(i);
+    ASSERT(entry.key() != key);
+  }
+#endif
+  // Add to list.
+  thread_locals_->Add(ThreadLocalEntry(key, destructor));
+  mutex_->Unlock();
+}
+
+
+void ThreadLocalData::RemoveThreadLocal(ThreadLocalKey key) {
+  if (thread_locals_ == NULL) {
+    return;
+  }

[siva, 2015/10/15 22:42:48]

Ditto comment.

[Cutch, 2015/10/16 16:53:25]

Done.

+  mutex_->Lock();
+  intptr_t i = 0;
+  for (; i < thread_locals_->length(); i++) {
+    const ThreadLocalEntry& entry = thread_locals_->At(i);
+    if (entry.key() == key) {
+      break;
+    }
+  }
+  if (i == thread_locals_->length()) {
+    // Not found.
+    mutex_->Unlock();
+    return;
+  }
+  thread_locals_->RemoveAt(i);
+  mutex_->Unlock();
+}
+
+
+void ThreadLocalData::RunDestructors() {
+  ASSERT(mutex_ != NULL);
+  mutex_->Lock();
+  ASSERT(thread_locals_ != NULL);
+  for (intptr_t i = 0; i < thread_locals_->length(); i++) {
+    const ThreadLocalEntry& entry = thread_locals_->At(i);
+    void* p = reinterpret_cast<void*>(OSThread::GetThreadLocal(entry.key()));
+    entry.destructor()(p);
+  }
+  mutex_->Unlock();
+}
+
+
+Mutex* ThreadLocalData::mutex_ = NULL;
+MallocGrowableArray<ThreadLocalEntry>* ThreadLocalData::thread_locals_ = NULL;
+
+
+void ThreadLocalData::InitOnce() {
+  mutex_ = new Mutex();
+  thread_locals_ = new MallocGrowableArray<ThreadLocalEntry>();
+}
+
+
+void ThreadLocalData::Shutdown() {
+  if (mutex_ != NULL) {
+    delete mutex_;
+    mutex_ = NULL;
+  }
+  if (thread_locals_ != NULL) {
+    delete thread_locals_;
+    thread_locals_ = NULL;
+  }
+}
+
 
 }  // namespace dart
 
-// NOTE: We still do not respect arbitrary TLS destructors on Windows, but,
-// we do run known TLS cleanup functions. See |OnThreadExit| below for
-// the list of functions that are called.
-
 // The following was adapted from Chromium:
 // src/base/threading/thread_local_storage_win.cc
 
 // Thread Termination Callbacks.
 // Windows doesn't support a per-thread destructor with its
 // TLS primitives.  So, we build it manually by inserting a
 // function to be called on each thread's exit.
 // This magic is from http://www.codeproject.com/threads/tls.asp
 // and it works for VC++ 7.0 and later.
 
@@ skipping 11 matching lines @@
 #pragma comment(linker, "/INCLUDE:__tls_used")
 #pragma comment(linker, "/INCLUDE:_p_thread_callback_dart")
 
 #endif  // _WIN64
 
 // Static callback function to call with each thread termination.
 void NTAPI OnDartThreadExit(PVOID module, DWORD reason, PVOID reserved) {
   // On XP SP0 & SP1, the DLL_PROCESS_ATTACH is never seen. It is sent on SP2+
   // and on W2K and W2K3. So don't assume it is sent.
   if (DLL_THREAD_DETACH == reason || DLL_PROCESS_DETACH == reason) {
-    dart::ThreadCleanupOnExit();
+    dart::ThreadLocalData::RunDestructors();
     dart::MonitorWaitData::ThreadExit();
   }
 }
 
 // .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
 // called automatically by the OS loader code (not the CRT) when the module is
 // loaded and on thread creation. They are NOT called if the module has been
 // loaded by a LoadLibrary() call. It must have implicitly been loaded at
 // process startup.
 // By implicitly loaded, I mean that it is directly referenced by the main EXE
@@ skipping 26 matching lines @@
 #pragma data_seg(".CRT$XLB")
 PIMAGE_TLS_CALLBACK p_thread_callback_dart = OnDartThreadExit;
 
 // Reset the default section.
 #pragma data_seg()
 
 #endif  // _WIN64
 }  // extern "C"
 
 #endif  // defined(TARGET_OS_WINDOWS)