- Add an OSThread structure which is the generic TLS structure for all C++

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 {
 
 // This flag is flipped by platform_win.cc when the process is exiting.
 // TODO(zra): Remove once VM shuts down cleanly.
 bool private_flag_windows_run_tls_destructors = true;
 
 class ThreadStartData {
  public:
-  ThreadStartData(OSThread::ThreadStartFunction function, uword parameter)
-      : function_(function), parameter_(parameter) {}
+  ThreadStartData(const char* name,
+                  OSThread::ThreadStartFunction function,
+                  uword parameter)
+      : name_(name), function_(function), parameter_(parameter) {}
 
+  const char* name() const { return name_; }
   OSThread::ThreadStartFunction function() const { return function_; }
   uword parameter() const { return parameter_; }
 
  private:
+  const char* name_;
   OSThread::ThreadStartFunction function_;
   uword parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadStartData);
 };
 
 
 // Dispatch to the thread start function provided by the caller. This trampoline
 // is used to ensure that the thread is properly destroyed if the thread just
 // exits.
 static unsigned int __stdcall ThreadEntry(void* data_ptr) {
   ThreadStartData* data = reinterpret_cast<ThreadStartData*>(data_ptr);
 
+  const char* name = data->name();
   OSThread::ThreadStartFunction function = data->function();
   uword parameter = data->parameter();
   delete data;
 
   MonitorData::GetMonitorWaitDataForThread();
 
+  // Create new OSThread object and set as TLS for new thread.
+  OSThread* thread = new OSThread();
+  OSThread::SetCurrent(thread);
+  thread->set_name(name);
+
   // Call the supplied thread start function handing it its parameters.
   function(parameter);
 
   // Clean up the monitor wait data for this thread.
   MonitorWaitData::ThreadExit();
 
   return 0;
 }
 
 
-int OSThread::Start(ThreadStartFunction function, uword parameter) {
-  ThreadStartData* start_data = new ThreadStartData(function, parameter);
+int OSThread::Start(const char* name,
+                    ThreadStartFunction function,
+                    uword parameter) {
+  ThreadStartData* start_data = new ThreadStartData(name, function, parameter);
   uint32_t tid;
   uintptr_t thread = _beginthreadex(NULL, OSThread::GetMaxStackSize(),
                                     ThreadEntry, start_data, 0, &tid);
   if (thread == -1L || thread == 0) {
 #ifdef DEBUG
     fprintf(stderr, "_beginthreadex error: %d (%s)\n", errno, strerror(errno));
 #endif
     return errno;
   }
 
@@ skipping 37 matching lines @@
   return ::GetCurrentThreadId();
 }
 
 
 ThreadId OSThread::GetCurrentThreadTraceId() {
   return ::GetCurrentThreadId();
 }
 
 
 ThreadJoinId OSThread::GetCurrentThreadJoinId() {
+  // TODO(zra): Use the thread handle as the join id in order to have a more
+  // reliable join on windows.
   return ::GetCurrentThreadId();
 }
 
 
 void OSThread::Join(ThreadJoinId id) {
   HANDLE handle = OpenThread(SYNCHRONIZE, false, id);
 
   // TODO(zra): OSThread::Start() closes the handle to the thread. Thus, by the
   // time we try to join the thread, its resources may have already been
   // reclaimed, and joining will fail. This can be avoided in a couple of ways.
@@ skipping 556 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)