[libc] Add implemementations of thread specific data related API.

[sivachandra]

Summary

Specifically, POSIX functions pthread_key_create, pthread_key_delete,
pthread_setspecific and pthread_getspecific have been added. The C
standard equivalents tss_create, tss_delete, tss_set and tss_get have
also been added.

[sivachandra]

This seems like a large patch, but the core is in just one file src/__support/threads/thread.cpp.

[michaelrj]

LGTM

libc/config/linux/api.td

def ThreadsAPI : PublicAPI<"threads.h"> {
 
   let Types = [
     "__call_once_func_t",
     "once_flag",
     "cnd_t",
     "mtx_t",
     "thrd_t",
     "thrd_start_t",
+    "tss_t",
+    "tss_dtor_t",
   ];
 
   let Enumerations = [
     "mtx_plain",
     "mtx_recursive",
     "mtx_timed",
     "thrd_timedout",
     "thrd_success",
     "thrd_busy",
     "thrd_error",
     "thrd_nomem",
   ];
 }
 
 def PThreadAPI : PublicAPI<"pthread.h"> {
   let Types = [
       "__pthread_start_t",
+      "__pthread_tss_dtor_t",
       "pthread_attr_t",
       "pthread_mutex_t",
       "pthread_mutexattr_t",
       "pthread_t",
+      "pthread_key_t",
   ];
 }
 
 def DirentAPI : PublicAPI<"dirent.h"> {
   let Types = [
     "ino_t",
     "DIR",
     "struct dirent",

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.pthread.pthread_attr_setstack
     libc.src.pthread.pthread_attr_setstacksize
     libc.src.pthread.pthread_attr_init
     libc.src.pthread.pthread_create
     libc.src.pthread.pthread_detach
     libc.src.pthread.pthread_equal
     libc.src.pthread.pthread_exit
     libc.src.pthread.pthread_getname_np
+    libc.src.pthread.pthread_getspecific
     libc.src.pthread.pthread_join
     libc.src.pthread.pthread_self
     libc.src.pthread.pthread_setname_np
+    libc.src.pthread.pthread_key_create
+    libc.src.pthread.pthread_key_delete
     libc.src.pthread.pthread_mutex_destroy
     libc.src.pthread.pthread_mutex_init
     libc.src.pthread.pthread_mutex_lock
     libc.src.pthread.pthread_mutex_unlock
     libc.src.pthread.pthread_mutexattr_destroy
     libc.src.pthread.pthread_mutexattr_init
     libc.src.pthread.pthread_mutexattr_getpshared
     libc.src.pthread.pthread_mutexattr_getrobust
     libc.src.pthread.pthread_mutexattr_gettype
     libc.src.pthread.pthread_mutexattr_setpshared
     libc.src.pthread.pthread_mutexattr_setrobust
     libc.src.pthread.pthread_mutexattr_settype
+    libc.src.pthread.pthread_setspecific
 
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     libc.src.stdlib.atexit
     libc.src.stdlib.exit
     libc.src.stdlib.getenv
 
     # stdio.h entrypoints
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_current
     libc.src.threads.thrd_detach
     libc.src.threads.thrd_equal
     libc.src.threads.thrd_exit
     libc.src.threads.thrd_join
+    libc.src.threads.tss_create
+    libc.src.threads.tss_delete
+    libc.src.threads.tss_get
+    libc.src.threads.tss_set
 
     # time.h entrypoints
     libc.src.time.asctime
     libc.src.time.asctime_r
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/include/CMakeLists.txt

add_gen_header(
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-types.__call_once_func_t
     .llvm-libc-types.cnd_t
     .llvm-libc-types.mtx_t
     .llvm-libc-types.once_flag
     .llvm-libc-types.thrd_start_t
     .llvm-libc-types.thrd_t
+    .llvm-libc-types.tss_t
+    .llvm-libc-types.tss_dtor_t
 )
 
 add_gen_header(
   errno
   DEF_FILE errno.h.def
   PARAMS
     platform_errno=../config/${LIBC_TARGET_OS}/errno.h.in
   GEN_HDR errno.h

 
 add_gen_header(
   pthread
   DEF_FILE pthread.h.def
   GEN_HDR pthread.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-types.__pthread_start_t
+    .llvm-libc-types.__pthread_tss_dtor_t
     .llvm-libc-types.pthread_attr_t
+    .llvm-libc-types.pthread_key_t
     .llvm-libc-types.pthread_mutex_t
     .llvm-libc-types.pthread_mutexattr_t
     .llvm-libc-types.pthread_t
 )
 
 # TODO: Not all platforms will have a include/sys directory. Add the sys
 # directory and the targets for sys/*.h files conditional to the OS requiring
 # them.

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(__bsearchcompare_t HDR __bsearchcompare_t.h)
 add_header(__call_once_func_t HDR __call_once_func_t.h)
 add_header(__futex_word HDR __futex_word.h)
 add_header(__mutex_type HDR __mutex_type.h DEPENDS .__futex_word)
 add_header(__pthread_start_t HDR __pthread_start_t.h)
+add_header(__pthread_tss_dtor_t HDR __pthread_tss_dtor_t.h)
 add_header(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(__thread_type HDR __thread_type.h)
 add_header(cnd_t HDR cnd_t.h)
 add_header(cookie_io_functions_t HDR cookie_io_functions_t.h DEPENDS .off64_t)
 add_header(double_t HDR double_t.h)
 add_header(DIR HDR DIR.h)
 add_header(div_t HDR div_t.h)
 add_header(ldiv_t HDR ldiv_t.h)
 add_header(lldiv_t HDR lldiv_t.h)
 add_header(FILE HDR FILE.h)
 add_header(fenv_t HDR fenv_t.h)
 add_header(fexcept_t HDR fexcept_t.h)
 add_header(float_t HDR float_t.h)
 add_header(imaxdiv_t HDR imaxdiv_t.h)
 add_header(ino_t HDR ino_t.h)
 add_header(mode_t HDR mode_t.h)
 add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(off_t HDR off_t.h)
 add_header(off64_t HDR off64_t.h)
 add_header(once_flag HDR once_flag.h DEPENDS .__futex_word)
 add_header(pthread_attr_t HDR pthread_attr_t.h DEPENDS .size_t)
+add_header(pthread_key_t HDR pthread_key_t.h)
 add_header(pthread_mutex_t HDR pthread_mutex_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(pthread_t HDR pthread_t.h DEPENDS .__thread_type)
 add_header(pthread_mutexattr_t HDR pthread_mutexattr_t.h)
 add_header(size_t HDR size_t.h)
 add_header(ssize_t HDR ssize_t.h)
 add_header(struct_dirent HDR struct_dirent.h DEPENDS .ino_t .off_t)
 add_header(struct_sigaction HDR struct_sigaction.h)
 add_header(struct_tm HDR struct_tm.h)
 add_header(thrd_start_t HDR thrd_start_t.h)
 add_header(thrd_t HDR thrd_t.h DEPENDS .__thread_type)
 add_header(time_t HDR time_t.h)
+add_header(tss_t HDR tss_t.h)
+add_header(tss_dtor_t HDR tss_dtor_t.h)
 add_header(__atexithandler_t HDR __atexithandler_t.h)

libc/include/llvm-libc-types/__pthread_tss_dtor_t.h

+//===-- Definition of the type __pthread_tss_dtor_t -----------------------===//
+//
+// 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_TYPES_PTHREAD_TSS_DTOR_T_H__
+#define __LLVM_LIBC_TYPES_PTHREAD_TSS_DTOR_T_H__
+
+typedef void (*__pthread_tss_dtor_t)(void *);
+
+#endif // __LLVM_LIBC_TYPES_PTHREAD_TSS_DTOR_T_H__

libc/include/llvm-libc-types/pthread_key_t.h

+//===-- Definition of the type pthread_key_t ------------------------------===//
+//
+// 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_TYPES_PTHREAD_KEY_T_H__
+#define __LLVM_LIBC_TYPES_PTHREAD_KEY_T_H__
+
+typedef unsigned int pthread_key_t;
+
+#endif // __LLVM_LIBC_TYPES_PTHREAD_KEY_T_H__

libc/include/llvm-libc-types/tss_dtor_t.h

+//===-- Definition of the type tss_dtor_t ---------------------------------===//
+//
+// 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_TYPES_TSS_DTOR_T_H__
+#define __LLVM_LIBC_TYPES_TSS_DTOR_T_H__
+
+typedef void (*tss_dtor_t)(void *);
+
+#endif // __LLVM_LIBC_TYPES_TSS_DTOR_T_H__

libc/include/llvm-libc-types/tss_t.h

+//===-- Definition of the type tss_t --------------------------------------===//
+//
+// 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_TYPES_TSS_T_H__
+#define __LLVM_LIBC_TYPES_TSS_T_H__
+
+typedef unsigned int tss_t;
+
+#endif // __LLVM_LIBC_TYPES_TSS_T_H__

libc/spec/posix.td

 def SigSetType : NamedType<"sigset_t">;
 def SigSetPtrType : PtrType<SigSetType>;
 def ConstSigSetPtrType : ConstType<SigSetPtrType>;
 def RestrictedSigSetType : RestrictedPtrType<SigSetType>;
 def ConstRestrictedSigSetType : ConstType<RestrictedSigSetType>;
 
 def StructSigaction : NamedType<"struct sigaction">;
 def StructSigactionPtr : PtrType<StructSigaction>;
 def ConstStructSigactionPtr : ConstType<StructSigactionPtr>;
 def RestrictedStructSigactionPtr : RestrictedPtrType<StructSigaction>;
 def ConstRestrictedStructSigactionPtr : ConstType<RestrictedStructSigactionPtr>;
 
 def PThreadStartT : NamedType<"__pthread_start_t">;
+def PThreadTSSDtorT : NamedType<"__pthread_tss_dtor_t">;
+def PThreadKeyT : NamedType<"pthread_key_t">;
+def PThreadKeyTPtr : PtrType<PThreadKeyT>;
 
 def InoT : NamedType<"ino_t">;
 def DIR : NamedType<"DIR">;
 def DIRPtr : PtrType<DIR>;
 def DIRRestrictedPtr : RestrictedPtrType<DIR>;
 def StructDirent : NamedType<"struct dirent">;
 def StructDirentPtr : PtrType<StructDirent>;
 def StructDirentPtrPtr : PtrType<StructDirentPtr>;
[
             [ArgSpec<IntType>, ArgSpec<ConstCharPtr>, ArgSpec<ModeTType>]
         >,
     ]
   >;
 
   HeaderSpec PThread = HeaderSpec<
     "pthread.h",
     [], // Macros
-    [PThreadAttrTType, PThreadMutexAttrTType, PThreadMutexTType, PThreadStartT, PThreadTType], // Types
+    [
+        PThreadAttrTType,
+        PThreadKeyT,
+        PThreadMutexAttrTType,
+        PThreadMutexTType,
+        PThreadStartT,
+        PThreadTSSDtorT,
+        PThreadTType,
+    ], // Types
     [], // Enumerations
     [
       FunctionSpec<
           "pthread_attr_init",
           RetValSpec<IntType>,
           [ArgSpec<PThreadAttrTPtr>]
       >,
       FunctionSpec<
[
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexTPtr>]
       >,
       FunctionSpec<
           "pthread_mutex_unlock",
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexTPtr>]
       >,
+      FunctionSpec<
+          "pthread_key_create",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadKeyTPtr>, ArgSpec<PThreadTSSDtorT>]
+      >,
+      FunctionSpec<
+          "pthread_key_delete",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadKeyT>]
+      >,
+      FunctionSpec<
+          "pthread_getspecific",
+          RetValSpec<VoidPtr>,
+          [ArgSpec<PThreadKeyT>]
+      >,
+      FunctionSpec<
+          "pthread_setspecific",
+          RetValSpec<VoidPtr>,
+          [ArgSpec<PThreadKeyT>, ArgSpec<ConstVoidPtr>]
+      >,
     ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [], // Macros
       [], // Types
       [], // Enumerations

libc/spec/stdc.td

 def StdC : StandardSpec<"stdc"> {
 
   NamedType StructTmType = NamedType<"struct tm">;
   PtrType StructTmPtr = PtrType<StructTmType>;
   PtrType TimeTTypePtr = PtrType<TimeTType>;
 
   NamedType DivTType = NamedType<"div_t">;
   NamedType LDivTType = NamedType<"ldiv_t">;
   NamedType LLDivTType = NamedType<"lldiv_t">;
 
+  NamedType TssTType = NamedType<"tss_t">;
+  PtrType TssTPtr = PtrType<TssTType>;
+  NamedType TssDtorTType = NamedType<"tss_dtor_t">;
+
   HeaderSpec Assert = HeaderSpec<
       "assert.h",
       [
           Macro<"static_assert">,
           Macro<"assert">,
       ],
       [], // Types
       [], // Enumerations
HeaderSpec Threads = HeaderSpec<
       ],
       [
           OnceFlagType,
           CallOnceFuncType,
           CndTType,
           MtxTType,
           ThrdStartTType,
           ThrdTType,
+          TssTType,
+          TssDtorTType,
       ],
       [
           EnumeratedNameValue<"mtx_plain">,
           EnumeratedNameValue<"mtx_recursive">,
           EnumeratedNameValue<"mtx_timed">,
           EnumeratedNameValue<"thrd_timedout">,
           EnumeratedNameValue<"thrd_success">,
           EnumeratedNameValue<"thrd_busy">,
HeaderSpec Threads = HeaderSpec<
               RetValSpec<IntType>,
               [ArgSpec<ThrdTType>, ArgSpec<ThrdTType>]
           >,
           FunctionSpec<
               "thrd_exit",
               RetValSpec<VoidType>,
               [ArgSpec<IntType>]
           >,
+          FunctionSpec<
+              "tss_create",
+              RetValSpec<IntType>,
+              [ArgSpec<TssTPtr>, ArgSpec<TssDtorTType>]
+          >,
+          FunctionSpec<
+              "tss_delete",
+              RetValSpec<IntType>,
+              [ArgSpec<TssTType>]
+          >,
+          FunctionSpec<
+              "tss_get",
+              RetValSpec<VoidPtr>,
+              [ArgSpec<TssTType>]
+          >,
+          FunctionSpec<
+              "tss_set",
+              RetValSpec<IntType>,
+              [ArgSpec<TssTType>, ArgSpec<VoidPtr>]
+          >,
       ]
   >;
 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
       [ // Types
        StructTmType,

libc/src/__support/threads/CMakeLists.txt

 
 add_header_library(
   thread_common
   HDRS
     thread.h
   DEPENDS
     libc.src.__support.common
     libc.src.__support.CPP.atomic
+    libc.src.__support.CPP.optional
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.stringstream
 )
 
 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.fixedvector
+      libc.src.__support.CPP.array
+      libc.src.__support.CPP.optional
   )
 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/StringView.h"
 #include "src/__support/CPP/atomic.h"
+#include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/architectures.h"
 
 #include <stddef.h> // For size_t
 #include <stdint.h>
 
 namespace __llvm_libc {
 
struct alignas(STACK_ALIGNMENT) ThreadAttributes {
 
   constexpr ThreadAttributes()
       : detach_state(uint32_t(DetachState::DETACHED)), stack(nullptr),
         stack_size(0), tls(0), tls_size(0), owned_stack(false), tid(-1),
         style(ThreadStyle::POSIX), retval(), atexit_callback_mgr(nullptr),
         platform_data(nullptr) {}
 };
 
+using TSSDtor = void(void *);
+
+// Create a new TSS key and associate the |dtor| as the corresponding
+// destructor. Can be used to implement public functions like
+// pthread_key_create.
+cpp::optional<unsigned int> new_tss_key(TSSDtor *dtor);
+
+// Delete the |key|. Can be used to implement public functions like
+// pthread_key_delete.
+//
+// Return true on success, false on failure.
+bool tss_key_delete(unsigned int key);
+
+// Set the value associated with |key| for the current thread. Can be used
+// to implement public functions like pthread_setspecific.
+//
+// Return true on success, false on failure.
+bool set_tss_value(unsigned int key, void *value);
+
+// Return the value associated with |key| for the current thread. Return
+// nullptr if |key| is invalid. Can be used to implement public functions like
+// pthread_getspecific.
+void *get_tss_value(unsigned int key);
+
 struct Thread {
   ThreadAttributes *attrib;
 
   constexpr Thread() : attrib(nullptr) {}
   constexpr Thread(ThreadAttributes *attr) : attrib(attr) {}
 
   int run(ThreadRunnerPosix *func, void *arg, void *stack, size_t size,
           bool detached = false) {

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"
 
 namespace __llvm_libc {
 
 thread_local Thread self;
 
 namespace {
 
 using AtExitCallback = void(void *);
 
 struct AtExitUnit {
   AtExitCallback *callback = nullptr;
   void *obj = nullptr;
   constexpr AtExitUnit() = default;
   constexpr AtExitUnit(AtExitCallback *cb, void *o) : callback(cb), obj(o) {}
 };
 
+constexpr size_t TSS_KEY_COUNT = 1024;
+
+struct TSSKeyUnit {
+  // Indicates whether is unit is active. Presence of a non-null dtor
+  // is not sufficient to indicate the same information as a TSS key can
+  // have a null destructor.
+  bool active = false;
+
+  TSSDtor *dtor = nullptr;
+
+  constexpr TSSKeyUnit() = default;
+  constexpr TSSKeyUnit(TSSDtor *d) : active(true), dtor(d) {}
+
+  void reset() {
+    active = false;
+    dtor = nullptr;
+  }
+};
+
+class TSSKeyMgr {
+  Mutex mtx;
+  cpp::array<TSSKeyUnit, TSS_KEY_COUNT> units;
+
+public:
+  constexpr TSSKeyMgr() : mtx(false, false, false) {}
+
+  cpp::optional<unsigned int> new_key(TSSDtor *dtor) {
+    MutexLock lock(&mtx);
+    for (size_t i = 0; i < TSS_KEY_COUNT; ++i) {
+      TSSKeyUnit &u = units[i];
+      if (!u.active) {
+        u = {dtor};
+        return i;
+      }
+    }
+    return cpp::optional<unsigned int>();
+  }
+
+  TSSDtor *get_dtor(unsigned int key) {
+    if (key >= TSS_KEY_COUNT)
+      return nullptr;
+    MutexLock lock(&mtx);
+    return units[key].dtor;
+  }
+
+  bool remove_key(unsigned int key) {
+    if (key >= TSS_KEY_COUNT)
+      return false;
+    MutexLock lock(&mtx);
+    units[key].reset();
+    return true;
+  }
+
+  bool is_valid_key(unsigned int key) {
+    MutexLock lock(&mtx);
+    return units[key].active;
+  }
+};
+
+TSSKeyMgr tss_key_mgr;
+
+struct TSSValueUnit {
+  bool active = false;
+  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;
+
 } // anonymous namespace
 
 class ThreadAtExitCallbackMgr {
   Mutex mtx;
   // TODO: Use a BlockStore when compiled for production.
   FixedVector<AtExitUnit, 1024> callback_list;
 
 public:

 namespace internal {
 
 ThreadAtExitCallbackMgr *get_thread_atexit_callback_mgr() {
   return &atexit_callback_mgr;
 }
 
 void call_atexit_callbacks(ThreadAttributes *attrib) {
   attrib->atexit_callback_mgr->call();
+  for (size_t i = 0; i < TSS_KEY_COUNT; ++i) {
+    TSSValueUnit &unit = tss_values[i];
+    if (unit.dtor != nullptr)
+      unit.dtor(unit.payload);
+  }
 }
 
 } // namespace internal
 
+cpp::optional<unsigned int> new_tss_key(TSSDtor *dtor) {
+  return tss_key_mgr.new_key(dtor);
+}
+
+bool tss_key_delete(unsigned int key) { return tss_key_mgr.remove_key(key); }
+
+bool set_tss_value(unsigned int key, void *val) {
+  if (!tss_key_mgr.is_valid_key(key))
+    return false;
+  tss_values[key] = {val, tss_key_mgr.get_dtor(key)};
+  return true;
+}
+
+void *get_tss_value(unsigned int key) {
+  if (key >= TSS_KEY_COUNT)
+    return nullptr;
+
+  auto &u = tss_values[key];
+  if (!u.active)
+    return nullptr;
+  return u.payload;
+}
+
 } // namespace __llvm_libc

libc/src/pthread/CMakeLists.txt

add_entrypoint_object(
   HDRS
     pthread_getname_np.h
   DEPENDS
     libc.include.pthread
     libc.src.__support.CPP.array_ref
     libc.src.__support.CPP.stringstream
     libc.src.__support.threads.thread
 )
+
+add_entrypoint_object(
+  pthread_key_create
+  SRCS
+    pthread_key_create.cpp
+  HDRS
+    pthread_key_create.h
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  pthread_key_delete
+  SRCS
+    pthread_key_delete.cpp
+  HDRS
+    pthread_key_delete.h
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  pthread_getspecific
+  SRCS
+    pthread_getspecific.cpp
+  HDRS
+    pthread_getspecific.h
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  pthread_setspecific
+  SRCS
+    pthread_setspecific.cpp
+  HDRS
+    pthread_setspecific.h
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)

libc/src/pthread/pthread_getspecific.h

+//===-- Implementation header for pthread_getspecific function --*- 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_PTHREAD_PTHREAD_GETSPECIFIC_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H
+
+#include <pthread.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+void *pthread_getspecific(pthread_key_t);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H

libc/src/pthread/pthread_getspecific.cpp

+//===-- Linux implementation of the pthread_getspecific function ----------===//
+//
+// 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 "pthread_getspecific.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <pthread.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(void *, pthread_getspecific, (pthread_key_t key)) {
+  return get_tss_value(key);
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_key_create.h

+//===-- Implementation header for pthread_key_create ------------*- 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_PTHREAD_PTHREAD_KEY_CREATE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_key_create(pthread_key_t *key, __pthread_tss_dtor_t dtor);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H

libc/src/pthread/pthread_key_create.cpp

+//===-- Implementation of the pthread_key_create --------------------------===//
+//
+// 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 "pthread_key_create.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <errno.h>
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_key_create,
+                   (pthread_key_t * key, __pthread_tss_dtor_t dtor)) {
+  auto k = __llvm_libc::new_tss_key(dtor);
+  if (!k)
+    return EINVAL;
+  *key = *k;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_key_delete.h

+//===-- Implementation header for pthread_key_delete ------------*- 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_PTHREAD_PTHREAD_KEY_DELETE_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_key_delete(pthread_key_t key);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H

libc/src/pthread/pthread_key_delete.cpp

+//===-- Implementation of the pthread_key_delete --------------------------===//
+//
+// 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 "pthread_key_delete.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <errno.h>
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_key_delete, (pthread_key_t key)) {
+  if (__llvm_libc::tss_key_delete(key))
+    return 0;
+  else
+    return EINVAL;
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_setspecific.h

+//===-- Implementation header for pthread_setspecific function --*- 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_PTHREAD_PTHREAD_SETSPECIFIC_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_setspecific(pthread_key_t, const void *);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H

libc/src/pthread/pthread_setspecific.cpp

+//===-- Linux implementation of the pthread_setspecific function ----------===//
+//
+// 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 "pthread_setspecific.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <errno.h>
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, pthread_setspecific,
+                   (pthread_key_t key, const void *data)) {
+  if (set_tss_value(key, const_cast<void *>(data)))
+    return 0;
+  else
+    return EINVAL;
+}
+
+} // namespace __llvm_libc

libc/src/threads/CMakeLists.txt

add_entrypoint_object(
   HDRS
     mtx_unlock.h
   DEPENDS
     libc.include.threads
     libc.src.__support.threads.mutex
 )
 
 add_entrypoint_object(
+  tss_create
+  SRCS
+    tss_create.cpp
+  HDRS
+    tss_create.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.mutex
+)
+
+add_entrypoint_object(
+  tss_delete
+  SRCS
+    tss_delete.cpp
+  HDRS
+    tss_delete.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.mutex
+)
+
+add_entrypoint_object(
+  tss_get
+  SRCS
+    tss_get.cpp
+  HDRS
+    tss_get.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.mutex
+)
+
+add_entrypoint_object(
+  tss_set
+  SRCS
+    tss_set.cpp
+  HDRS
+    tss_set.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.mutex
+)
+
+add_entrypoint_object(
   cnd_init
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.cnd_init
 )
 
 add_entrypoint_object(
   cnd_destroy

libc/src/threads/tss_create.h

+//===-- Implementation header for tss_create --------------------*- 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_THREADS_TSS_CREATE_H
+#define LLVM_LIBC_SRC_THREADS_TSS_CREATE_H
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+int tss_create(tss_t *key, tss_dtor_t dtor);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_TSS_CREATE_H

libc/src/threads/tss_create.cpp

+//===-- Implementation of the tss_create ----------------------------------===//
+//
+// 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 "tss_create.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, tss_create, (tss_t * key, tss_dtor_t dtor)) {
+  auto k = __llvm_libc::new_tss_key(dtor);
+  if (!k)
+    return thrd_error;
+  *key = *k;
+  return thrd_success;
+}
+
+} // namespace __llvm_libc

libc/src/threads/tss_delete.h

+//===-- Implementation header for tss_delete --------------------*- 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_THREADS_TSS_DELETE_H
+#define LLVM_LIBC_SRC_THREADS_TSS_DELETE_H
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+void tss_delete(tss_t key);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_TSS_DELETE_H

libc/src/threads/tss_delete.cpp

+//===-- Implementation of the tss_delete ----------------------------------===//
+//
+// 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 "tss_delete.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(void, tss_delete, (tss_t key)) {
+  __llvm_libc::tss_key_delete(key);
+}
+
+} // namespace __llvm_libc

libc/src/threads/tss_get.h

+//===-- Implementation header for tss_get function --------------*- 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_THREADS_TSS_GET_H
+#define LLVM_LIBC_SRC_THREADS_TSS_GET_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+void *tss_get(pthread_key_t);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_TSS_GET_H

libc/src/threads/tss_get.cpp

+//===-- Linux implementation of the tss_get function ----------------------===//
+//
+// 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 "tss_get.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(void *, tss_get, (tss_t key)) { return get_tss_value(key); }
+
+} // namespace __llvm_libc

libc/src/threads/tss_set.h

+//===-- Implementation header for tss_set function --------------*- 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_THREADS_TSS_SET_H
+#define LLVM_LIBC_SRC_THREADS_TSS_SET_H
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+int tss_set(tss_t, void *);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_TSS_SET_H

libc/src/threads/tss_set.cpp

+//===-- Linux implementation of the tss_set function ----------------------===//
+//
+// 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 "tss_set.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, tss_set, (tss_t key, void *data)) {
+  if (set_tss_value(key, data))
+    return thrd_success;
+  else
+    return thrd_error;
+}
+
+} // namespace __llvm_libc

libc/test/integration/src/pthread/CMakeLists.txt

add_integration_test(
   LOADER
     libc.loader.linux.crt1
   DEPENDS
     libc.include.pthread
     libc.src.pthread.pthread_create
     libc.src.pthread.pthread_exit
     libc.src.pthread.pthread_join
 )
+
+add_integration_test(
+  pthread_tss_test
+  SUITE
+    libc-pthread-integration-tests
+  SRCS
+    pthread_tss_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.pthread
+    libc.src.pthread.pthread_create
+    libc.src.pthread.pthread_exit
+    libc.src.pthread.pthread_join
+    libc.src.pthread.pthread_key_create
+    libc.src.pthread.pthread_key_delete
+    libc.src.pthread.pthread_getspecific
+    libc.src.pthread.pthread_setspecific
+)

libc/test/integration/src/pthread/pthread_tss_test.cpp

+//===-- Tests for TSS API like pthread_setspecific etc. -------------------===//
+//
+// 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/pthread/pthread_create.h"
+#include "src/pthread/pthread_exit.h"
+#include "src/pthread/pthread_getspecific.h"
+#include "src/pthread/pthread_join.h"
+#include "src/pthread/pthread_key_create.h"
+#include "src/pthread/pthread_key_delete.h"
+#include "src/pthread/pthread_setspecific.h"
+#include "utils/IntegrationTest/test.h"
+
+#include <pthread.h>
+
+static constexpr int THREAD_DATA_INITVAL = 0x1234;
+static constexpr int THREAD_DATA_FINIVAL = 0x4321;
+static constexpr int THREAD_RUN_VAL = 0x600D;
+
+int child_thread_data = THREAD_DATA_INITVAL;
+int main_thread_data = THREAD_DATA_INITVAL;
+
+pthread_key_t key;
+void dtor(void *data) {
+  auto *v = reinterpret_cast<int *>(data);
+  *v = THREAD_DATA_FINIVAL;
+}
+
+void *func(void *obj) {
+  ASSERT_EQ(__llvm_libc::pthread_setspecific(key, &child_thread_data), 0);
+  int *d = reinterpret_cast<int *>(__llvm_libc::pthread_getspecific(key));
+  ASSERT_TRUE(d != nullptr);
+  ASSERT_EQ(&child_thread_data, d);
+  ASSERT_EQ(*d, THREAD_DATA_INITVAL);
+  *reinterpret_cast<int *>(obj) = THREAD_RUN_VAL;
+  return nullptr;
+}
+
+TEST_MAIN() {
+  ASSERT_EQ(__llvm_libc::pthread_key_create(&key, &dtor), 0);
+  ASSERT_EQ(__llvm_libc::pthread_setspecific(key, &main_thread_data), 0);
+  int *d = reinterpret_cast<int *>(__llvm_libc::pthread_getspecific(key));
+  ASSERT_TRUE(d != nullptr);
+  ASSERT_EQ(&main_thread_data, d);
+  ASSERT_EQ(*d, THREAD_DATA_INITVAL);
+
+  pthread_t th;
+  int arg = 0xBAD;
+  ASSERT_EQ(__llvm_libc::pthread_create(&th, nullptr, &func, &arg), 0);
+  void *retval = &child_thread_data; // Init to some non-nullptr val.
+  ASSERT_EQ(__llvm_libc::pthread_join(th, &retval), 0);
+  ASSERT_EQ(retval, nullptr);
+  ASSERT_EQ(arg, THREAD_RUN_VAL);
+  ASSERT_EQ(child_thread_data, THREAD_DATA_FINIVAL);
+
+  ASSERT_EQ(__llvm_libc::pthread_key_delete(key), 0);
+  return 0;
+}

libc/test/integration/src/threads/CMakeLists.txt

add_integration_test(
   DEPENDS
     libc.include.threads
     libc.src.threads.thrd_create
     libc.src.threads.thrd_exit
     libc.src.threads.thrd_join
 )
 
 add_integration_test(
+  tss_test
+  SUITE
+    libc-threads-integration-tests
+  SRCS
+    tss_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.threads
+    libc.src.threads.thrd_create
+    libc.src.threads.thrd_exit
+    libc.src.threads.thrd_join
+    libc.src.threads.tss_create
+    libc.src.threads.tss_delete
+    libc.src.threads.tss_get
+    libc.src.threads.tss_set
+)
+
+add_integration_test(
   call_once_test
   SUITE
     libc-threads-integration-tests
   SRCS
     call_once_test.cpp
   LOADER
     libc.loader.linux.crt1
   DEPENDS

libc/test/integration/src/threads/tss_test.cpp

+//===-- Tests for TSS API like tss_set, tss_get etc. ----------------------===//
+//
+// 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/threads/thrd_create.h"
+#include "src/threads/thrd_exit.h"
+#include "src/threads/thrd_join.h"
+#include "src/threads/tss_create.h"
+#include "src/threads/tss_delete.h"
+#include "src/threads/tss_get.h"
+#include "src/threads/tss_set.h"
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
+
+static constexpr int THREAD_DATA_INITVAL = 0x1234;
+static constexpr int THREAD_DATA_FINIVAL = 0x4321;
+static constexpr int THREAD_RUN_VAL = 0x600D;
+
+int child_thread_data = THREAD_DATA_INITVAL;
+int main_thread_data = THREAD_DATA_INITVAL;
+
+tss_t key;
+void dtor(void *data) {
+  auto *v = reinterpret_cast<int *>(data);
+  *v = THREAD_DATA_FINIVAL;
+}
+
+int func(void *obj) {
+  ASSERT_EQ(__llvm_libc::tss_set(key, &child_thread_data), thrd_success);
+  int *d = reinterpret_cast<int *>(__llvm_libc::tss_get(key));
+  ASSERT_TRUE(d != nullptr);
+  ASSERT_EQ(&child_thread_data, d);
+  ASSERT_EQ(*d, THREAD_DATA_INITVAL);
+  *reinterpret_cast<int *>(obj) = THREAD_RUN_VAL;
+  return 0;
+}
+
+TEST_MAIN() {
+  ASSERT_EQ(__llvm_libc::tss_create(&key, &dtor), thrd_success);
+  ASSERT_EQ(__llvm_libc::tss_set(key, &main_thread_data), thrd_success);
+  int *d = reinterpret_cast<int *>(__llvm_libc::tss_get(key));
+  ASSERT_TRUE(d != nullptr);
+  ASSERT_EQ(&main_thread_data, d);
+  ASSERT_EQ(*d, THREAD_DATA_INITVAL);
+
+  thrd_t th;
+  int arg = 0xBAD;
+  ASSERT_EQ(__llvm_libc::thrd_create(&th, &func, &arg), thrd_success);
+  int retval = THREAD_DATA_INITVAL; // Init to some non-zero val.
+  ASSERT_EQ(__llvm_libc::thrd_join(th, &retval), thrd_success);
+  ASSERT_EQ(retval, 0);
+  ASSERT_EQ(arg, THREAD_RUN_VAL);
+  ASSERT_EQ(child_thread_data, THREAD_DATA_FINIVAL);
+
+  __llvm_libc::tss_delete(key);
+
+  return 0;
+}