Remove home-grown thread-local storage wrappers

[labath]

Summary

Use c++11 thread_local variables instead. As far as I am aware, they are
supported by all compilers/targets we care about.

[zturner]

The last time I tried to do this we couldn't because it didn't yet work on iOS. I checked with some Apple people though and they said thread_local support was released last year on all Apple platforms. So hopefully there's no more hurdles to getting this in.

[krytarowski]

Modern BSDs should be fine on popular platforms.

[emaste]

Fine from FreeBSD

[labath]

In D34274#782529, @zturner wrote:

The last time I tried to do this we couldn't because it didn't yet work on iOS. I checked with some Apple people though and they said thread_local support was released last year on all Apple platforms. So hopefully there's no more hurdles to getting this in.

Thanks, I didn't know about the iOS angle. Jim, can you confirm that this is ok?

[jasonmolenda]

We have thread local storage support on all our current darwin platforms.

lldb/trunk/include/lldb/Host/Host.h

public:
   ///
   /// @return
   ///     The thread token for the calling thread in the current process.
   //------------------------------------------------------------------
   static lldb::thread_t GetCurrentThread();
 
   static const char *GetSignalAsCString(int signo);
 
-  typedef void (*ThreadLocalStorageCleanupCallback)(void *p);
-
-  static lldb::thread_key_t
-  ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback);
-
-  static void *ThreadLocalStorageGet(lldb::thread_key_t key);
-
-  static void ThreadLocalStorageSet(lldb::thread_key_t key, void *value);
-
   //------------------------------------------------------------------
   /// Given an address in the current process (the process that
   /// is running the LLDB code), return the name of the module that
   /// it comes from. This can be useful when you need to know the
   /// path to the shared library that your code is running in for
   /// loading resources that are relative to your binary.
   ///
   /// @param[in] host_addr

lldb/trunk/source/Core/Timer.cpp

 
 std::atomic<bool> Timer::g_quiet(true);
 std::atomic<unsigned> Timer::g_display_depth(0);
 static std::mutex &GetFileMutex() {
   static std::mutex *g_file_mutex_ptr = new std::mutex();
   return *g_file_mutex_ptr;
 }
 
-static void ThreadSpecificCleanup(void *p) {
-  delete static_cast<TimerStack *>(p);
-}
-
-static TimerStack *GetTimerStackForCurrentThread() {
-  static lldb::thread_key_t g_key =
-      Host::ThreadLocalStorageCreate(ThreadSpecificCleanup);
-
-  void *timer_stack = Host::ThreadLocalStorageGet(g_key);
-  if (timer_stack == NULL) {
-    Host::ThreadLocalStorageSet(g_key, new TimerStack);
-    timer_stack = Host::ThreadLocalStorageGet(g_key);
-  }
-  return (TimerStack *)timer_stack;
+static TimerStack &GetTimerStackForCurrentThread() {
+  static thread_local TimerStack g_stack;
+  return g_stack;
 }
 
 Timer::Category::Category(const char *cat) : m_name(cat) {
   m_nanos.store(0, std::memory_order_release);
   Category *expected = g_categories;
   do {
     m_next = expected;
   } while (!g_categories.compare_exchange_weak(expected, this));
 }
 
 void Timer::SetQuiet(bool value) { g_quiet = value; }
 
 Timer::Timer(Timer::Category &category, const char *format, ...)
     : m_category(category), m_total_start(std::chrono::steady_clock::now()) {
-  TimerStack *stack = GetTimerStackForCurrentThread();
-  if (!stack)
-    return;
+  TimerStack &stack = GetTimerStackForCurrentThread();
 
-  stack->push_back(this);
-  if (g_quiet && stack->size() <= g_display_depth) {
+  stack.push_back(this);
+  if (g_quiet && stack.size() <= g_display_depth) {
     std::lock_guard<std::mutex> lock(GetFileMutex());
 
     // Indent
-    ::fprintf(stdout, "%*s", int(stack->size() - 1) * TIMER_INDENT_AMOUNT, "");
+    ::fprintf(stdout, "%*s", int(stack.size() - 1) * TIMER_INDENT_AMOUNT, "");
     // Print formatted string
     va_list args;
     va_start(args, format);
     ::vfprintf(stdout, format, args);
     va_end(args);
 
     // Newline
     ::fprintf(stdout, "\n");
   }
 }
 
 Timer::~Timer() {
   using namespace std::chrono;
 
-  TimerStack *stack = GetTimerStackForCurrentThread();
-  if (!stack)
-    return;
-
   auto stop_time = steady_clock::now();
   auto total_dur = stop_time - m_total_start;
   auto timer_dur = total_dur - m_child_duration;
 
-  if (g_quiet && stack->size() <= g_display_depth) {
+  TimerStack &stack = GetTimerStackForCurrentThread();
+  if (g_quiet && stack.size() <= g_display_depth) {
     std::lock_guard<std::mutex> lock(GetFileMutex());
     ::fprintf(stdout, "%*s%.9f sec (%.9f sec)\n",
-              int(stack->size() - 1) * TIMER_INDENT_AMOUNT, "",
+              int(stack.size() - 1) * TIMER_INDENT_AMOUNT, "",
               duration<double>(total_dur).count(),
               duration<double>(timer_dur).count());
   }
 
-  assert(stack->back() == this);
-  stack->pop_back();
-  if (!stack->empty())
-    stack->back()->ChildDuration(total_dur);
+  assert(stack.back() == this);
+  stack.pop_back();
+  if (!stack.empty())
+    stack.back()->ChildDuration(total_dur);
 
   // Keep total results for each category so we can dump results.
   m_category.m_nanos += std::chrono::nanoseconds(timer_dur).count();
 }
 
 void Timer::SetDisplayDepth(uint32_t depth) { g_display_depth = depth; }
 
 /* binary function predicate:

lldb/trunk/source/Host/common/Host.cpp

#endif
   default:
     break;
   }
   return NULL;
 }
 
 #endif
 
-#ifndef _WIN32
-
-lldb::thread_key_t
-Host::ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback) {
-  pthread_key_t key;
-  ::pthread_key_create(&key, callback);
-  return key;
-}
-
-void *Host::ThreadLocalStorageGet(lldb::thread_key_t key) {
-  return ::pthread_getspecific(key);
-}
-
-void Host::ThreadLocalStorageSet(lldb::thread_key_t key, void *value) {
-  ::pthread_setspecific(key, value);
-}
-
-#endif
-
 #if !defined(__APPLE__) // see Host.mm
 
 bool Host::GetBundleDirectory(const FileSpec &file, FileSpec &bundle) {
   bundle.Clear();
   return false;
 }
 
 bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }

lldb/trunk/source/Host/windows/Host.cpp

void GetProcessExecutableAndTriple(const AutoHandle &handle,
   // TODO(zturner): Add the ability to get the process user name.
 }
 }
 
 lldb::thread_t Host::GetCurrentThread() {
   return lldb::thread_t(::GetCurrentThread());
 }
 
-lldb::thread_key_t
-Host::ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback) {
-  return TlsAlloc();
-}
-
-void *Host::ThreadLocalStorageGet(lldb::thread_key_t key) {
-  return ::TlsGetValue(key);
-}
-
-void Host::ThreadLocalStorageSet(lldb::thread_key_t key, void *value) {
-  ::TlsSetValue(key, value);
-}
-
 void Host::Kill(lldb::pid_t pid, int signo) {
   TerminateProcess((HANDLE)pid, 1);
 }
 
 const char *Host::GetSignalAsCString(int signo) { return NULL; }
 
 FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
   FileSpec module_filespec;