[libc] Add macro LIBC_THREAD_LOCAL.

[sivachandra]

Summary

It resolves to thread_local on all platform except for the GPUs on which
it resolves to nothing. The use of thread_local in the source code has been
replaced with the new macro.

[jhuber6]

Thanks, this helps some of the implementation details.

[tschuett]

Please have a look at LLVM_THREAD_LOCAL macro in compiler.h. I believe there are two variants.

[jhuber6]

In D151486#4373637, @tschuett wrote:

Please have a look at LLVM_THREAD_LOCAL macro in compiler.h. I believe there are two variants.

I think that's only important for code before C++11. Since we're always compiling with C++17 internally it shouldn't be necessary.

[barannikov88]

Should errno.h.def also be updated? It declares:

extern _Thread_local int __llvmlibc_errno;

while the variable is defined in libc_errno.cpp as:

LIBC_THREAD_LOCAL int __llvmlibc_errno;

libc/src/__support/StringUtil/CMakeLists.txt

add_object_library(
   error_to_string
   HDRS
     error_to_string.h
   SRCS
     error_to_string.cpp
   DEPENDS
     .message_mapper
     .platform_errors
+    libc.src.__support.common
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.stringstream
     libc.src.__support.integer_to_string
 )
 
 add_object_library(
   signal_to_string
   HDRS
     signal_to_string.h
   SRCS
     signal_to_string.cpp
   DEPENDS
     .message_mapper
     .platform_signals
     libc.include.signal
+    libc.src.__support.common
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.stringstream
     libc.src.__support.integer_to_string
 )

libc/src/__support/StringUtil/error_to_string.cpp

 //===-- Implementation of a class for mapping errors to strings -----------===//
 //
 // 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 "error_to_string.h"
 #include "platform_errors.h"
 
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/StringUtil/message_mapper.h"
 #include "src/__support/integer_to_string.h"
+#include "src/__support/macros/attributes.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 constexpr size_t max_buff_size() {
   constexpr size_t unknown_str_len = sizeof("Unknown error");
   constexpr size_t max_num_len =
       __llvm_libc::IntegerToString::dec_bufsize<int>();
   // the buffer should be able to hold "Unknown error" + ' ' + num_str
   return (unknown_str_len + 1 + max_num_len) * sizeof(char);
 }
 
 // This is to hold error strings that have to be custom built. It may be
 // rewritten on every call to strerror (or other error to string function).
 constexpr size_t ERR_BUFFER_SIZE = max_buff_size();
-thread_local char error_buffer[ERR_BUFFER_SIZE];
+LIBC_THREAD_LOCAL char error_buffer[ERR_BUFFER_SIZE];
 
 constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_ERRORS);
 
 // Since the StringMappings array is a map from error numbers to their
 // corresponding strings, we have to have an array large enough we can use the
 // error numbers as indexes. The current linux configuration has 132 values with
 // the maximum value being 133 (41 and 58 are skipped). If other platforms use
 // negative numbers or discontiguous ranges, then the array should be turned

libc/src/__support/StringUtil/signal_to_string.cpp

 //===-- Implementation of a class for mapping signals to strings ----------===//
 //
 // 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 "signal_to_string.h"
 #include "platform_signals.h"
 
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/StringUtil/message_mapper.h"
 #include "src/__support/integer_to_string.h"
+#include "src/__support/macros/attributes.h"
 
 #include <signal.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 constexpr size_t max_buff_size() {
   constexpr size_t base_str_len = sizeof("Real-time signal");
   constexpr size_t max_num_len =
       __llvm_libc::IntegerToString::dec_bufsize<int>();
   // the buffer should be able to hold "Real-time signal" + ' ' + num_str
   return (base_str_len + 1 + max_num_len) * sizeof(char);
 }
 
 // This is to hold signal strings that have to be custom built. It may be
 // rewritten on every call to strsignal (or other signal to string function).
 constexpr size_t SIG_BUFFER_SIZE = max_buff_size();
-thread_local char signal_buffer[SIG_BUFFER_SIZE];
+LIBC_THREAD_LOCAL char signal_buffer[SIG_BUFFER_SIZE];
 
 constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_SIGNALS);
 
 constexpr size_t SIG_ARRAY_SIZE = max_key_val(PLATFORM_SIGNALS) + 1;
 
 constexpr MessageMapper<SIG_ARRAY_SIZE, TOTAL_STR_LEN>
     signal_mapper(PLATFORM_SIGNALS);
 

libc/src/__support/macros/attributes.h

 // where applicable, certain function calls.
 //
 // Most macros here are exposing GCC or Clang features, and are stubbed out for
 // other compilers.
 
 #ifndef LLVM_LIBC_SUPPORT_MACROS_ATTRIBUTES_H
 #define LLVM_LIBC_SUPPORT_MACROS_ATTRIBUTES_H
 
+#include "properties/architectures.h"
+
 #define LIBC_INLINE inline
 #define LIBC_INLINE_ASM __asm__ __volatile__
 #define LIBC_UNUSED __attribute__((unused))
 
+#ifdef LIBC_TARGET_ARCH_IS_GPU
+#define LIBC_THREAD_LOCAL
+#else
+#define LIBC_THREAD_LOCAL thread_local
+#endif
+
 #endif // LLVM_LIBC_SUPPORT_MACROS_ATTRIBUTES_H

libc/src/__support/threads/CMakeLists.txt

 if(TARGET libc.src.__support.threads.${LIBC_TARGET_OS}.thread)
   add_object_library(
     thread
     SRCS
       thread.cpp
     DEPENDS
       .mutex
       .${LIBC_TARGET_OS}.thread
+      libc.src.__support.common
       libc.src.__support.fixedvector
       libc.src.__support.CPP.array
       libc.src.__support.CPP.optional
   )
 endif()
 
 if(TARGET libc.src.__support.threads.${LIBC_TARGET_OS}.callonce)
   add_object_library(
     callonce
     ALIAS
     DEPENDS
       .${LIBC_TARGET_OS}.callonce
   )
 endif()

libc/src/__support/threads/thread.h

 //===--- A platform independent indirection for a thread class --*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H
 #define LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H
 
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
+#include "src/__support/macros/attributes.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #include <linux/param.h> // for exec_pagesize.
 
 #include <stddef.h> // For size_t
 #include <stdint.h>
 
 namespace __llvm_libc {
struct Thread {
 
   // Set the name of the thread. Return the error number on error.
   int set_name(const cpp::string_view &name);
 
   // Return the name of the thread in |name|. Return the error number of error.
   int get_name(cpp::StringStream &name) const;
 };
 
-extern thread_local Thread self;
+extern LIBC_THREAD_LOCAL Thread self;
 
 // Platforms should implement this function.
 [[noreturn]] void thread_exit(ThreadReturnValue retval, ThreadStyle style);
 
 namespace internal {
 // Internal namespace containing utilities which are to be used by platform
 // implementations of threads.
 

libc/src/__support/threads/thread.cpp

 //===--- Definitions of common thread items ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "thread.h"
 #include "mutex.h"
 
 #include "src/__support/CPP/array.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/fixedvector.h"
+#include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc {
 
-thread_local Thread self;
+LIBC_THREAD_LOCAL Thread self;
 
 namespace {
 
 using AtExitCallback = void(void *);
 
 struct AtExitUnit {
   AtExitCallback *callback = nullptr;
   void *obj = nullptr;
struct TSSValueUnit {
   void *payload = nullptr;
   TSSDtor *dtor = nullptr;
 
   constexpr TSSValueUnit() = default;
   constexpr TSSValueUnit(void *p, TSSDtor *d)
       : active(true), payload(p), dtor(d) {}
 };
 
-static thread_local cpp::array<TSSValueUnit, TSS_KEY_COUNT> tss_values;
+static LIBC_THREAD_LOCAL cpp::array<TSSValueUnit, TSS_KEY_COUNT> tss_values;
 
 } // anonymous namespace
 
 class ThreadAtExitCallbackMgr {
   Mutex mtx;
   // TODO: Use a BlockStore when compiled for production.
   FixedVector<AtExitUnit, 1024> callback_list;
 
while (!callback_list.empty()) {
       callback_list.pop_back();
       mtx.unlock();
       atexit_unit.callback(atexit_unit.obj);
       mtx.lock();
     }
   }
 };
 
-static thread_local ThreadAtExitCallbackMgr atexit_callback_mgr;
+static LIBC_THREAD_LOCAL ThreadAtExitCallbackMgr atexit_callback_mgr;
 
 // The function __cxa_thread_atexit is provided by C++ runtimes like libcxxabi.
 // It is used by thread local object runtime to register destructor calls. To
 // actually register destructor call with the threading library, it calls
 // __cxa_thread_atexit_impl, which is to be provided by the threading library.
 // The semantics are very similar to the __cxa_atexit function except for the
 // fact that the registered callback is thread specific.
 extern "C" int __cxa_thread_atexit_impl(AtExitCallback *callback, void *obj,

libc/src/errno/CMakeLists.txt

 add_entrypoint_object(
   errno
   SRCS
     libc_errno.cpp
   HDRS
     libc_errno.h     # Include this
   DEPENDS
     libc.include.errno
+    libc.src.__support.common
 )

libc/src/errno/libc_errno.h

 //===-- Implementation header for errno -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
 #define LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
 
+#include "src/__support/macros/attributes.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #include <errno.h>
 
 // If we are targeting the GPU we currently don't support 'errno'. We simply
 // consume it.
 #ifdef LIBC_TARGET_ARCH_IS_GPU
 namespace __llvm_libc {

 #endif
 #else
 namespace __llvm_libc {
 
 #ifdef LIBC_TARGET_ARCH_IS_GPU
 extern "C" ErrnoConsumer __llvmlibc_internal_errno;
 #else // LIBC_TARGET_ARCH_IS_GPU
 extern "C" {
-extern thread_local int __llvmlibc_internal_errno;
+extern LIBC_THREAD_LOCAL int __llvmlibc_internal_errno;
 } // extern "C"
 #endif
 
 // TODO: After all of libc/src and libc/test are switched over to use
 // libc_errno, this header file will be "shipped" via an add_entrypoint_object
 // target. At which point libc_errno, should point to __llvmlibc_internal_errno
 // if LIBC_COPT_PUBLIC_PACKAGING is not defined.
 #define libc_errno __llvm_libc::__llvmlibc_internal_errno
 
 } // namespace __llvm_libc
 #endif
 
 #endif // LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H

libc/src/errno/libc_errno.cpp

 //===-- Implementation of errno -------------------------------------------===//
 //
 // 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 "src/__support/macros/attributes.h"
 #include "src/__support/macros/properties/architectures.h"
 
 namespace __llvm_libc {
 
 #ifdef LIBC_TARGET_ARCH_IS_GPU
 struct ErrnoConsumer {
   void operator=(int) {}
 };
 #endif
 
 extern "C" {
 #ifdef LIBC_COPT_PUBLIC_PACKAGING
 // TODO: Declare __llvmlibc_errno only under LIBC_COPT_PUBLIC_PACKAGING and
 // __llvmlibc_internal_errno otherwise.
 // In overlay mode, this will be an unused thread local variable as libc_errno
 // will resolve to errno from the system libc's errno.h. In full build mode
 // however, libc_errno will resolve to this thread local variable via the errno
 // macro defined in LLVM libc's public errno.h header file.
 // TODO: Use a macro to distinguish full build and overlay build which can be
 //       used to exclude __llvmlibc_errno under overlay build.
 #ifdef LIBC_TARGET_ARCH_IS_GPU
 ErrnoConsumer __llvmlibc_errno;
 #else
-thread_local int __llvmlibc_errno;
+LIBC_THREAD_LOCAL int __llvmlibc_errno;
 #endif // LIBC_TARGET_ARCH_IS_GPU
 #else
 #ifdef LIBC_TARGET_ARCH_IS_GPU
 ErrnoConsumer __llvmlibc_internal_errno;
 #else
-thread_local int __llvmlibc_internal_errno;
+LIBC_THREAD_LOCAL int __llvmlibc_internal_errno;
 #endif // LIBC_TARGET_ARCH_IS_GPU
 #endif
 } // extern "C"
 
 } // namespace __llvm_libc

libc/src/stdlib/CMakeLists.txt

 )
 
 add_object_library(
   rand_util
   SRCS
     rand_util.cpp
   HDRS
     rand_util.h
+  DEPENDS
+    libc.src.__support.common
 )
 
 add_entrypoint_object(
   rand
   SRCS
     rand.cpp
   HDRS
     rand.h

libc/src/stdlib/rand_util.h

 //===-- Implementation header for rand utilities ----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STDLIB_RAND_UTIL_H
 #define LLVM_LIBC_SRC_STDLIB_RAND_UTIL_H
 
+#include "src/__support/macros/attributes.h"
+
 namespace __llvm_libc {
 
-extern thread_local unsigned long rand_next;
+extern LIBC_THREAD_LOCAL unsigned long rand_next;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDLIB_RAND_UTIL_H

libc/src/stdlib/rand_util.cpp

 //===-- Shared utility for rand -------------------------------------------===//
 //
 // 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 "src/stdlib/rand_util.h"
+#include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc {
 
-thread_local unsigned long rand_next;
+LIBC_THREAD_LOCAL unsigned long rand_next;
 
 } // namespace __llvm_libc

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

libc_support_library(
     name = "__support_macros_config",
     hdrs = ["src/__support/macros/config.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_macros_attributes",
     hdrs = ["src/__support/macros/attributes.h"],
-    deps = [":libc_root"],
+    deps = [
+        ":__support_macros_properties_architectures",
+        ":libc_root"
+    ],
 )
 
 libc_support_library(
     name = "__support_macros_optimization",
     hdrs = ["src/__support/macros/optimization.h"],
     deps = [
         ":__support_macros_attributes",
         ":__support_macros_config",

 ############################### errno targets ################################
 
 libc_function(
     name = "errno",
     srcs = ["src/errno/libc_errno.cpp"],
     hdrs = ["src/errno/libc_errno.h"],
     deps = [
         ":__support_common",
+        ":__support_macros_attributes",
         ":__support_macros_properties_architectures",
     ],
 )
 
 ################################ fenv targets ################################
 
 libc_function(
     name = "fetestexcept",