Remove the outdated ThreadLocal class in favor of C++ thread_local.

[resistor]

Getting the repository right.

[resistor]

Remove unit test for ThreadLocal as well.

[resistor]

Add static

[resistor]

Use static

[lebedev.ri]

llvm/lib/Support/CrashRecoveryContext.cpp

21

Are you sure thread_local is fully supported by all the compilers that are supported for building LLVM?
It wasn't supported by xcode for some time, maybe the newest version supports it though.

[resistor]

llvm/lib/Support/CrashRecoveryContext.cpp

21

thread_local support was added in Xcode 8, in 2016: https://asciiwwdc.com/2016/sessions/405#t=354.596

As far as I'm aware, all other supported compiler (GCC, MSVC) had thread_local support earlier than that.

[lebedev.ri]

llvm/lib/Support/CrashRecoveryContext.cpp

21

In particular, i would like to see a table of all the compilers that are officially supported by LLVM,
and a yes/no column for thread_local support.

llvm/cmake/config-ix.cmake

if(NOT HAVE_LINUX_MAGIC_H)
     check_include_file(linux/smb.h HAVE_LINUX_SMB_H)
   endif()
 endif()
 
 # library checks
 if( NOT PURE_WINDOWS )
   check_library_exists(pthread pthread_create "" HAVE_LIBPTHREAD)
   if (HAVE_LIBPTHREAD)
-    check_library_exists(pthread pthread_getspecific "" HAVE_PTHREAD_GETSPECIFIC)
     check_library_exists(pthread pthread_rwlock_init "" HAVE_PTHREAD_RWLOCK_INIT)
     check_library_exists(pthread pthread_mutex_lock "" HAVE_PTHREAD_MUTEX_LOCK)
   else()
     # this could be Android
     check_library_exists(c pthread_create "" PTHREAD_IN_LIBC)
     if (PTHREAD_IN_LIBC)
-      check_library_exists(c pthread_getspecific "" HAVE_PTHREAD_GETSPECIFIC)
       check_library_exists(c pthread_rwlock_init "" HAVE_PTHREAD_RWLOCK_INIT)
       check_library_exists(c pthread_mutex_lock "" HAVE_PTHREAD_MUTEX_LOCK)
     endif()
   endif()
   check_library_exists(dl dlopen "" HAVE_LIBDL)
   check_library_exists(rt clock_gettime "" HAVE_LIBRT)
 endif()
 

llvm/include/llvm/Support/ThreadLocal.h

-//===- llvm/Support/ThreadLocal.h - Thread Local Data ------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the llvm::sys::ThreadLocal class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_THREADLOCAL_H
-#define LLVM_SUPPORT_THREADLOCAL_H
-
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Threading.h"
-#include <cassert>
-
-namespace llvm {
-  namespace sys {
-    // ThreadLocalImpl - Common base class of all ThreadLocal instantiations.
-    // YOU SHOULD NEVER USE THIS DIRECTLY.
-    class ThreadLocalImpl {
-      typedef uint64_t ThreadLocalDataTy;
-      /// Platform-specific thread local data.
-      ///
-      /// This is embedded in the class and we avoid malloc'ing/free'ing it,
-      /// to make this class more safe for use along with CrashRecoveryContext.
-      union {
-        char data[sizeof(ThreadLocalDataTy)];
-        ThreadLocalDataTy align_data;
-      };
-    public:
-      ThreadLocalImpl();
-      virtual ~ThreadLocalImpl();
-      void setInstance(const void* d);
-      void *getInstance();
-      void removeInstance();
-    };
-
-    /// ThreadLocal - A class used to abstract thread-local storage.  It holds,
-    /// for each thread, a pointer a single object of type T.
-    template<class T>
-    class ThreadLocal : public ThreadLocalImpl {
-    public:
-      ThreadLocal() : ThreadLocalImpl() { }
-
-      /// get - Fetches a pointer to the object associated with the current
-      /// thread.  If no object has yet been associated, it returns NULL;
-      T* get() { return static_cast<T*>(getInstance()); }
-
-      // set - Associates a pointer to an object with the current thread.
-      void set(T* d) { setInstance(d); }
-
-      // erase - Removes the pointer associated with the current thread.
-      void erase() { removeInstance(); }
-    };
-  }
-}
-
-#endif

llvm/lib/Support/CMakeLists.txt

# System
   Memory.cpp
   Mutex.cpp
   Path.cpp
   Process.cpp
   Program.cpp
   RWMutex.cpp
   Signals.cpp
   TargetRegistry.cpp
-  ThreadLocal.cpp
   Threading.cpp
   Valgrind.cpp
   Watchdog.cpp
 
   ADDITIONAL_HEADER_DIRS
   Unix
   Windows
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ADT
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Support
   ${Backtrace_INCLUDE_DIRS}
   LINK_LIBS ${system_libs} ${delayload_flags}
   )
 
 set_property(TARGET LLVMSupport PROPERTY LLVM_SYSTEM_LIBS "${system_libs}")

llvm/lib/Support/CrashRecoveryContext.cpp

 //===--- CrashRecoveryContext.cpp - Crash Recovery ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
-#include "llvm/Support/ThreadLocal.h"
 #include <setjmp.h>
 using namespace llvm;
 
 namespace {
 
 struct CrashRecoveryContextImpl;
 
-static ManagedStatic<
-    sys::ThreadLocal<const CrashRecoveryContextImpl> > CurrentContext;
+static const thread_local CrashRecoveryContextImpl *CurrentContext;
 
 struct CrashRecoveryContextImpl {
   // When threads are disabled, this links up all active
   // CrashRecoveryContextImpls.  When threads are enabled there's one thread
   // per CrashRecoveryContext and CurrentContext is a thread-local, so only one
   // CrashRecoveryContextImpl is active per thread and this is always null.
   const CrashRecoveryContextImpl *Next;
 
   CrashRecoveryContext *CRC;
   ::jmp_buf JumpBuffer;
   volatile unsigned Failed : 1;
   unsigned SwitchedThread : 1;
 
 public:
   CrashRecoveryContextImpl(CrashRecoveryContext *CRC) : CRC(CRC),
                                                         Failed(false),
                                                         SwitchedThread(false) {
-    Next = CurrentContext->get();
-    CurrentContext->set(this);
+    Next = CurrentContext;
+    CurrentContext = this;
   }
   ~CrashRecoveryContextImpl() {
     if (!SwitchedThread)
-      CurrentContext->set(Next);
+      CurrentContext = Next;
   }
 
   /// Called when the separate crash-recovery thread was finished, to
   /// indicate that we don't need to clear the thread-local CurrentContext.
   void setSwitchedThread() {
 #if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
     SwitchedThread = true;
 #endif
   }
 
   void HandleCrash() {
     // Eliminate the current context entry, to avoid re-entering in case the
     // cleanup code crashes.
-    CurrentContext->set(Next);
+    CurrentContext = Next;
 
     assert(!Failed && "Crash recovery context already failed!");
     Failed = true;
 
     // FIXME: Stash the backtrace.
 
     // Jump back to the RunSafely we were called under.
     longjmp(JumpBuffer, 1);
   }
 };
 
 }
 
 static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
 static bool gCrashRecoveryEnabled = false;
 
-static ManagedStatic<sys::ThreadLocal<const CrashRecoveryContext>>
-       tlIsRecoveringFromCrash;
+const thread_local CrashRecoveryContext *tlIsRecoveringFromCrash = nullptr;
 
 static void installExceptionOrSignalHandlers();
 static void uninstallExceptionOrSignalHandlers();
 
 CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
 
 CrashRecoveryContext::~CrashRecoveryContext() {
   // Reclaim registered resources.
   CrashRecoveryContextCleanup *i = head;
-  const CrashRecoveryContext *PC = tlIsRecoveringFromCrash->get();
-  tlIsRecoveringFromCrash->set(this);
+  const CrashRecoveryContext *PC = tlIsRecoveringFromCrash;
+  tlIsRecoveringFromCrash = this;
   while (i) {
     CrashRecoveryContextCleanup *tmp = i;
     i = tmp->next;
     tmp->cleanupFired = true;
     tmp->recoverResources();
     delete tmp;
   }
-  tlIsRecoveringFromCrash->set(PC);
+  tlIsRecoveringFromCrash = PC;
 
   CrashRecoveryContextImpl *CRCI = (CrashRecoveryContextImpl *) Impl;
   delete CRCI;
 }
 
 bool CrashRecoveryContext::isRecoveringFromCrash() {
-  return tlIsRecoveringFromCrash->get() != nullptr;
+  return tlIsRecoveringFromCrash != nullptr;
 }
 
 CrashRecoveryContext *CrashRecoveryContext::GetCurrent() {
   if (!gCrashRecoveryEnabled)
     return nullptr;
 
-  const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
+  const CrashRecoveryContextImpl *CRCI = CurrentContext;
   if (!CRCI)
     return nullptr;
 
   return CRCI->CRC;
 }
 
 void CrashRecoveryContext::Enable() {
   sys::ScopedLock L(*gCrashRecoveryContextMutex);

 
 static const int Signals[] =
     { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP };
 static const unsigned NumSignals = array_lengthof(Signals);
 static struct sigaction PrevActions[NumSignals];
 
 static void CrashRecoverySignalHandler(int Signal) {
   // Lookup the current thread local recovery object.
-  const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
+  const CrashRecoveryContextImpl *CRCI = CurrentContext;
 
   if (!CRCI) {
     // We didn't find a crash recovery context -- this means either we got a
     // signal on a thread we didn't expect it on, the application got a signal
     // outside of a crash recovery context, or something else went horribly
     // wrong.
     //
     // Disable crash recovery and raise the signal again. The assumption here is

llvm/lib/Support/ThreadLocal.cpp

-//===- ThreadLocal.cpp - Thread Local Data ----------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the llvm::sys::ThreadLocal class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/ThreadLocal.h"
-#include "llvm/Config/llvm-config.h"
-#include "llvm/Support/Compiler.h"
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only TRULY operating system
-//===          independent code.
-//===----------------------------------------------------------------------===//
-
-#if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
-// Define all methods as no-ops if threading is explicitly disabled
-namespace llvm {
-using namespace sys;
-ThreadLocalImpl::ThreadLocalImpl() : data() { }
-ThreadLocalImpl::~ThreadLocalImpl() { }
-void ThreadLocalImpl::setInstance(const void* d) {
-  static_assert(sizeof(d) <= sizeof(data), "size too big");
-  void **pd = reinterpret_cast<void**>(&data);
-  *pd = const_cast<void*>(d);
-}
-void *ThreadLocalImpl::getInstance() {
-  void **pd = reinterpret_cast<void**>(&data);
-  return *pd;
-}
-void ThreadLocalImpl::removeInstance() {
-  setInstance(nullptr);
-}
-}
-#elif defined(LLVM_ON_UNIX)
-#include "Unix/ThreadLocal.inc"
-#elif defined( _WIN32)
-#include "Windows/ThreadLocal.inc"
-#else
-#warning Neither LLVM_ON_UNIX nor _WIN32 set in Support/ThreadLocal.cpp
-#endif

llvm/lib/Support/Unix/ThreadLocal.inc

-//=== llvm/Support/Unix/ThreadLocal.inc - Unix Thread Local Data -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the Unix specific (non-pthread) ThreadLocal class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//===          is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Config/config.h"
-
-#if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_GETSPECIFIC)
-
-#include <cassert>
-#include <pthread.h>
-#include <stdlib.h>
-
-namespace llvm {
-using namespace sys;
-
-ThreadLocalImpl::ThreadLocalImpl() : data() {
-  static_assert(sizeof(pthread_key_t) <= sizeof(data), "size too big");
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
-  int errorcode = pthread_key_create(key, nullptr);
-  assert(errorcode == 0);
-  (void) errorcode;
-}
-
-ThreadLocalImpl::~ThreadLocalImpl() {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
-  int errorcode = pthread_key_delete(*key);
-  assert(errorcode == 0);
-  (void) errorcode;
-}
-
-void ThreadLocalImpl::setInstance(const void* d) {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
-  int errorcode = pthread_setspecific(*key, d);
-  assert(errorcode == 0);
-  (void) errorcode;
-}
-
-void *ThreadLocalImpl::getInstance() {
-  pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
-  return pthread_getspecific(*key);
-}
-
-void ThreadLocalImpl::removeInstance() {
-  setInstance(nullptr);
-}
-
-}
-#else
-namespace llvm {
-using namespace sys;
-ThreadLocalImpl::ThreadLocalImpl() : data() { }
-ThreadLocalImpl::~ThreadLocalImpl() { }
-void ThreadLocalImpl::setInstance(const void* d) { data = const_cast<void*>(d);}
-void *ThreadLocalImpl::getInstance() { return data; }
-void ThreadLocalImpl::removeInstance() { setInstance(0); }
-}
-#endif

llvm/lib/Support/Windows/ThreadLocal.inc

-//= llvm/Support/Win32/ThreadLocal.inc - Win32 Thread Local Data -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the Win32 specific (non-pthread) ThreadLocal class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic Win32 code that
-//===          is guaranteed to work on *all* Win32 variants.
-//===----------------------------------------------------------------------===//
-
-#include "WindowsSupport.h"
-#include "llvm/Support/ThreadLocal.h"
-
-namespace llvm {
-
-sys::ThreadLocalImpl::ThreadLocalImpl() : data() {
-  static_assert(sizeof(DWORD) <= sizeof(data), "size too big");
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
-  *tls = TlsAlloc();
-  assert(*tls != TLS_OUT_OF_INDEXES);
-}
-
-sys::ThreadLocalImpl::~ThreadLocalImpl() {
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
-  TlsFree(*tls);
-}
-
-void *sys::ThreadLocalImpl::getInstance() {
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
-  return TlsGetValue(*tls);
-}
-
-void sys::ThreadLocalImpl::setInstance(const void* d){
-  DWORD* tls = reinterpret_cast<DWORD*>(&data);
-  int errorcode = TlsSetValue(*tls, const_cast<void*>(d));
-  assert(errorcode != 0);
-  (void)errorcode;
-}
-
-void sys::ThreadLocalImpl::removeInstance() {
-  setInstance(0);
-}
-
-}

llvm/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   SourceMgrTest.cpp
   SpecialCaseListTest.cpp
   StringPool.cpp
   SwapByteOrderTest.cpp
   SymbolRemappingReaderTest.cpp
   TarWriterTest.cpp
   TargetParserTest.cpp
   TaskQueueTest.cpp
-  ThreadLocalTest.cpp
   ThreadPool.cpp
   Threading.cpp
   TimerTest.cpp
   TypeNameTest.cpp
   TypeTraitsTest.cpp
   TrailingObjectsTest.cpp
   TrigramIndexTest.cpp
   UnicodeTest.cpp

llvm/unittests/Support/ThreadLocalTest.cpp

-//===- llvm/unittest/Support/ThreadLocalTest.cpp - ThreadLocal tests ------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/ThreadLocal.h"
-#include "gtest/gtest.h"
-#include <type_traits>
-
-using namespace llvm;
-using namespace sys;
-
-namespace {
-
-class ThreadLocalTest : public ::testing::Test {
-};
-
-struct S {
-  int i;
-};
-
-TEST_F(ThreadLocalTest, Basics) {
-  ThreadLocal<const S> x;
-
-  static_assert(
-      std::is_const<std::remove_pointer<decltype(x.get())>::type>::value,
-      "ThreadLocal::get didn't return a pointer to const object");
-
-  EXPECT_EQ(nullptr, x.get());
-
-  S s;
-  x.set(&s);
-  EXPECT_EQ(&s, x.get());
-
-  x.erase();
-  EXPECT_EQ(nullptr, x.get());
-
-  ThreadLocal<S> y;
-
-  static_assert(
-      !std::is_const<std::remove_pointer<decltype(y.get())>::type>::value,
-      "ThreadLocal::get returned a pointer to const object");
-
-  EXPECT_EQ(nullptr, y.get());
-
-  y.set(&s);
-  EXPECT_EQ(&s, y.get());
-
-  y.erase();
-  EXPECT_EQ(nullptr, y.get());
-}
-
-}