[libc] Add implementations of pthread_equal and pthread_self.

[sivachandra]

Update aarch64 loader

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.pthread.pthread_attr_getstacksize
     libc.src.pthread.pthread_attr_setdetachstate
     libc.src.pthread.pthread_attr_setguardsize
     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_join
+    libc.src.pthread.pthread_self
     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
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.cnd_init
     libc.src.threads.cnd_signal
     libc.src.threads.cnd_wait
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     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_join
 
     # 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/loader/linux/x86_64/CMakeLists.txt

 add_loader_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
+    libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
     libc.src.string.memory_utils.memcpy_implementation
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
 )

libc/loader/linux/x86_64/start.cpp

 //===-- Implementation of crt for x86_64 ----------------------------------===//
 //
 // 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 "config/linux/app.h"
 #include "src/__support/OSUtil/syscall.h"
+#include "src/__support/threads/thread.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 
 #include <asm/prctl.h>
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 
 extern "C" int main(int, char **, char **);
 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long mmapSyscallNumber = SYS_mmap2;
 #elif SYS_mmap
 static constexpr long mmapSyscallNumber = SYS_mmap;
 #else
 #error "Target platform does not have SYS_mmap or SYS_mmap2 defined"
 #endif
 
 AppProperties app;
 
+static ThreadAttributes main_thread_attrib;
+
 // TODO: The function is x86_64 specific. Move it to config/linux/app.h
 // and generalize it. Also, dynamic loading is not handled currently.
 void init_tls(TLSDescriptor &tls_descriptor) {
   if (app.tls.size == 0) {
     tls_descriptor.size = 0;
     tls_descriptor.tp = 0;
     return;
   }

 
 // TODO: Would be nice to use the aux entry structure from elf.h when available.
 struct AuxEntry {
   uint64_t type;
   uint64_t value;
 };
 
 extern "C" void _start() {
+  auto tid = __llvm_libc::syscall(SYS_gettid);
+  if (tid <= 0)
+    __llvm_libc::syscall(SYS_exit, 1);
+  __llvm_libc::main_thread_attrib.tid = tid;
+
   // This TU is compiled with -fno-omit-frame-pointer. Hence, the previous value
   // of the base pointer is pushed on to the stack. So, we step over it (the
   // "+ 1" below) to get to the args.
   app.args = reinterpret_cast<__llvm_libc::Args *>(
       reinterpret_cast<uintptr_t *>(__builtin_frame_address(0)) + 1);
 
   // The x86_64 ABI requires that the stack pointer is aligned to a 16-byte
   // boundary. We align it here but we cannot use any local variables created
for (uintptr_t i = 0; i < programHdrCount; ++i) {
     app.tls.align = phdr->p_align;
   }
 
   __llvm_libc::TLSDescriptor tls;
   __llvm_libc::init_tls(tls);
   if (tls.size != 0 && !__llvm_libc::set_thread_ptr(tls.tp))
     __llvm_libc::syscall(SYS_exit, 1);
 
+  __llvm_libc::self.attrib = &__llvm_libc::main_thread_attrib;
+
   int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv),
                     reinterpret_cast<char **>(env_ptr));
   __llvm_libc::cleanup_tls(tls.addr, tls.size);
   __llvm_libc::syscall(SYS_exit, retval);
 }

libc/spec/posix.td

[
           [ArgSpec<PThreadTType>, ArgSpec<VoidPtrPtr>]
       >,
       FunctionSpec<
           "pthread_detach",
           RetValSpec<IntType>,
           [ArgSpec<PThreadTType>]
       >,
       FunctionSpec<
+          "pthread_self",
+          RetValSpec<PThreadTType>,
+          [ArgSpec<VoidType>]
+      >,
+      FunctionSpec<
+          "pthread_equal",
+          RetValSpec<IntType>,
+          [ArgSpec<PThreadTType>, ArgSpec<PThreadTType>]
+      >,
+      FunctionSpec<
           "pthread_mutexattr_init",
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexAttrTPtr>]
       >,
       FunctionSpec<
           "pthread_mutexattr_destroy",
           RetValSpec<IntType>,
           [ArgSpec<PThreadMutexAttrTPtr>]

libc/spec/stdc.td

HeaderSpec Threads = HeaderSpec<
                   ArgSpec<ThrdTTypePtr>,
                   ArgSpec<IntPtr>,
               ]
           >,
           FunctionSpec<
               "thrd_detach",
               RetValSpec<IntType>,
               [ArgSpec<ThrdTType>]
+          >,
+          FunctionSpec<
+              "thrd_current",
+              RetValSpec<ThrdTType>,
+              [ArgSpec<VoidType>]
+          >,
+          FunctionSpec<
+              "thrd_equal",
+              RetValSpec<IntType>,
+              [ArgSpec<ThrdTType>, ArgSpec<ThrdTType>]
           >
       ]
   >;
 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
       [ // Types

libc/src/__support/threads/linux/thread.cpp

#elif defined(LLVM_LIBC_ARCH_AARCH64)
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(1));
 #endif
 }
 
 __attribute__((noinline))
 static void start_thread() {
   auto *start_args = reinterpret_cast<StartArgs *>(get_start_args_addr());
   auto *attrib = start_args->thread_attrib;
+  self.attrib = attrib;
+
   long retval;
   if (attrib->style == ThreadStyle::POSIX) {
     attrib->retval.posix_retval =
         start_args->runner.posix_runner(start_args->arg);
     retval = long(attrib->retval.posix_retval);
   } else {
     attrib->retval.stdc_retval =
         start_args->runner.stdc_runner(start_args->arg);
void Thread::wait() {
   while (clear_tid->load() != 0) {
     // We cannot do a FUTEX_WAIT_PRIVATE here as the kernel does a
     // FUTEX_WAKE and not a FUTEX_WAKE_PRIVATE.
     __llvm_libc::syscall(SYS_futex, &clear_tid->val, FUTEX_WAIT,
                          CLEAR_TID_VALUE, nullptr);
   }
 }
 
+bool Thread::operator==(const Thread &thread) const {
+  return attrib->tid == thread.attrib->tid;
+}
+
 } // namespace __llvm_libc

libc/src/__support/threads/thread.h

struct Thread {
   //    not been detached or joined, wait can be called multiple times.
   //
   // Also, only one thread can wait and expect to get woken up when the thread
   // finishes.
   //
   // NOTE: This function is to be used for testing only. There is no standard
   // which requires exposing it via a public API.
   void wait();
+
+  // Return true if this thread is equal to the other thread.
+  bool operator==(const Thread &other) const;
 };
 
+extern thread_local Thread self;
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H

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
 //
 //===----------------------------------------------------------------------===//
 
-// This file is currently emtpy. In future, declaration of a self thread object
-// etc. will be added here.
+#include "thread.h"
+
+namespace __llvm_libc {
+
+thread_local Thread self;
+
+} // namespace __llvm_libc

libc/src/pthread/CMakeLists.txt

add_entrypoint_object(
   SRCS
     pthread_detach.cpp
   HDRS
     pthread_detach.h
   DEPENDS
     libc.include.pthread
     libc.src.__support.threads.thread
 )
+
+add_entrypoint_object(
+  pthread_equal
+  SRCS
+    pthread_equal.cpp
+  HDRS
+    pthread_equal.h
+  DEPENDS
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  pthread_self
+  SRCS
+    pthread_self.cpp
+  HDRS
+    pthread_self.h
+  DEPENDS
+    libc.include.pthread
+    libc.src.__support.threads.thread
+)

libc/src/pthread/pthread_equal.h

+//===-- Implementation header for pthread_equal 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_PTHREAD_EQUAL_H
+#define LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_equal(pthread_t lhs, pthread_t rhs);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H

libc/src/pthread/pthread_equal.cpp

-//===-- Linux implementation of the pthread_join function -----------------===//
+//===-- Implementation of the pthread_equal 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_join.h"
+#include "pthread_equal.h"
 
 #include "src/__support/common.h"
 #include "src/__support/threads/thread.h"
 
 #include <pthread.h> // For pthread_* type definitions.
 
 namespace __llvm_libc {
 
 static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between pthread_t and internal Thread.");
 
-LLVM_LIBC_FUNCTION(int, pthread_join, (pthread_t th, void **retval)) {
-  auto *thread = reinterpret_cast<Thread *>(&th);
-  int result = thread->join(retval);
-  return result;
+LLVM_LIBC_FUNCTION(int, pthread_equal, (pthread_t lhs, pthread_t rhs)) {
+  auto *lhs_internal = reinterpret_cast<Thread *>(&lhs);
+  auto *rhs_internal = reinterpret_cast<Thread *>(&rhs);
+  return *lhs_internal == *rhs_internal;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_join.cpp

-//===-- Linux implementation of the pthread_join function -----------------===//
+//===-- Implementation of the pthread_join 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_join.h"

libc/src/pthread/pthread_self.h

-//===--- Definitions of common thread items ---------------------*- C++ -*-===//
+//===-- Implementation header for pthread_self 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
 //
 //===----------------------------------------------------------------------===//
 
-// This file is currently emtpy. In future, declaration of a self thread object
-// etc. will be added here.
+#ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H
+#define LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+pthread_t pthread_self();
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H

libc/src/pthread/pthread_self.cpp

-//===-- Linux implementation of the pthread_join function -----------------===//
+//===-- Implementation of the pthread_self 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_join.h"
+#include "pthread_self.h"
 
 #include "src/__support/common.h"
 #include "src/__support/threads/thread.h"
 
 #include <pthread.h> // For pthread_* type definitions.
 
 namespace __llvm_libc {
 
 static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between pthread_t and internal Thread.");
 
-LLVM_LIBC_FUNCTION(int, pthread_join, (pthread_t th, void **retval)) {
-  auto *thread = reinterpret_cast<Thread *>(&th);
-  int result = thread->join(retval);
-  return result;
+LLVM_LIBC_FUNCTION(pthread_t, pthread_self, ()) {
+  pthread_t th;
+  th.__attrib = self.attrib;
+  return th;
 }
 
 } // namespace __llvm_libc

libc/src/threads/CMakeLists.txt

add_entrypoint_object(
   HDRS
     thrd_detach.h
   DEPENDS
     libc.include.threads
     libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
+  thrd_current
+  SRCS
+    thrd_current.cpp
+  HDRS
+    thrd_current.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  thrd_equal
+  SRCS
+    thrd_equal.cpp
+  HDRS
+    thrd_equal.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
   mtx_init
   SRCS
     mtx_init.cpp
   HDRS
     mtx_init.h
   DEPENDS
     libc.include.threads
     libc.src.__support.threads.mutex

libc/src/threads/thrd_current.h

+//===-- Implementation header for thrd_current 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_THRD_CURRENT_H
+#define LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+thrd_t thrd_current();
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H

libc/src/threads/thrd_current.cpp

+//===-- Implementation of the thrd_current 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 "src/threads/thrd_current.h"
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h> // For thrd_* type definitions.
+
+namespace __llvm_libc {
+
+static_assert(sizeof(thrd_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between thrd_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(thrd_t, thrd_current, ()) {
+  thrd_t th;
+  th.__attrib = self.attrib;
+  return th;
+}
+
+} // namespace __llvm_libc

libc/src/threads/thrd_equal.h

+//===-- Implementation header for thrd_equal 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_THRD_EQUAL_H
+#define LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H
+
+#include "include/threads.h"
+
+namespace __llvm_libc {
+
+int thrd_equal(thrd_t lhs, thrd_t rhs);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H

libc/src/threads/thrd_equal.cpp

+//===-- Implementation of the thrd_equal 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 "src/threads/thrd_equal.h"
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h> // For thrd_* type definitions.
+
+namespace __llvm_libc {
+
+static_assert(sizeof(thrd_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between thrd_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(int, thrd_equal, (thrd_t lhs, thrd_t rhs)) {
+  auto *lhs_internal = reinterpret_cast<Thread *>(&lhs);
+  auto *rhs_internal = reinterpret_cast<Thread *>(&rhs);
+  return *lhs_internal == *rhs_internal;
+}
+
+} // namespace __llvm_libc

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

SRCS
     pthread_test.cpp
   LOADER
     libc.loader.linux.crt1
   DEPENDS
     libc.include.pthread
     libc.src.pthread.pthread_create
     libc.src.pthread.pthread_join
 )
+
+add_integration_test(
+  pthread_equal_test
+  SUITE
+    libc-pthread-integration-tests
+  SRCS
+    pthread_equal_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.pthread
+    libc.src.errno.errno
+    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_create
+    libc.src.pthread.pthread_equal
+    libc.src.pthread.pthread_join
+    libc.src.pthread.pthread_self
+)

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

+//===-- Tests for pthread_equal -------------------------------------------===//
+//
+// 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_equal.h"
+#include "src/pthread/pthread_join.h"
+#include "src/pthread/pthread_mutex_destroy.h"
+#include "src/pthread/pthread_mutex_init.h"
+#include "src/pthread/pthread_mutex_lock.h"
+#include "src/pthread/pthread_mutex_unlock.h"
+#include "src/pthread/pthread_self.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <pthread.h>
+
+pthread_t child_thread;
+pthread_mutex_t mutex;
+
+static void *child_func(void *arg) {
+  __llvm_libc::pthread_mutex_lock(&mutex);
+  int *ret = reinterpret_cast<int *>(arg);
+  auto self = __llvm_libc::pthread_self();
+  *ret = __llvm_libc::pthread_equal(child_thread, self);
+  __llvm_libc::pthread_mutex_unlock(&mutex);
+  return nullptr;
+}
+
+int main() {
+  // We init and lock the mutex so that we guarantee that the child thread is
+  // waiting after startup.
+  ASSERT_EQ(__llvm_libc::pthread_mutex_init(&mutex, nullptr), 0);
+  ASSERT_EQ(__llvm_libc::pthread_mutex_lock(&mutex), 0);
+
+  auto main_thread = __llvm_libc::pthread_self();
+
+  // The idea here is that, we start a child thread which will immediately
+  // wait on |mutex|. The main thread will update the global |child_thread| var
+  // and unlock |mutex|. This will give the child thread a chance to compare
+  // the result of pthread_self with the |child_thread|. The result of the
+  // comparison is returned in the thread arg.
+  int result = 0;
+  pthread_t th;
+  ASSERT_EQ(__llvm_libc::pthread_create(&th, nullptr, child_func, &result), 0);
+  // This new thread should of course not be equal to the main thread.
+  ASSERT_EQ(__llvm_libc::pthread_equal(th, main_thread), 0);
+
+  // Set the |child_thread| global var and unlock to allow the child to perform
+  // the comparison.
+  child_thread = th;
+  ASSERT_EQ(__llvm_libc::pthread_mutex_unlock(&mutex), 0);
+
+  void *retval;
+  ASSERT_EQ(__llvm_libc::pthread_join(th, &retval), 0);
+  ASSERT_EQ(uintptr_t(retval), uintptr_t(nullptr));
+  // The child thread should see that pthread_self return value is the same as
+  // |child_thread|.
+  ASSERT_NE(result, 0);
+
+  __llvm_libc::pthread_mutex_destroy(&mutex);
+  return 0;
+}

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

DEPENDS
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 )
 
 add_integration_test(
+  thrd_equal_test
+  SUITE
+    libc-threads-integration-tests
+  SRCS
+    thrd_equal_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.threads
+    libc.src.threads.mtx_destroy
+    libc.src.threads.mtx_init
+    libc.src.threads.mtx_lock
+    libc.src.threads.mtx_unlock
+    libc.src.threads.thrd_create
+    libc.src.threads.thrd_current
+    libc.src.threads.thrd_equal
+    libc.src.threads.thrd_join
+)
+
+add_integration_test(
   thrd_test
   SUITE
     libc-threads-integration-tests
   SRCS
     thrd_test.cpp
   LOADER
     libc.loader.linux.crt1
   DEPENDS

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

+//===-- Tests for thrd_equal ----------------------------------------------===//
+//
+// 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/mtx_destroy.h"
+#include "src/threads/mtx_init.h"
+#include "src/threads/mtx_lock.h"
+#include "src/threads/mtx_unlock.h"
+#include "src/threads/thrd_create.h"
+#include "src/threads/thrd_current.h"
+#include "src/threads/thrd_equal.h"
+#include "src/threads/thrd_join.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
+
+thrd_t child_thread;
+mtx_t mutex;
+
+static int child_func(void *arg) {
+  __llvm_libc::mtx_lock(&mutex);
+  int *ret = reinterpret_cast<int *>(arg);
+  auto self = __llvm_libc::thrd_current();
+  *ret = __llvm_libc::thrd_equal(child_thread, self);
+  __llvm_libc::mtx_unlock(&mutex);
+  return 0;
+}
+
+int main() {
+  // We init and lock the mutex so that we guarantee that the child thread is
+  // waiting after startup.
+  ASSERT_EQ(__llvm_libc::mtx_init(&mutex, mtx_plain), int(thrd_success));
+  ASSERT_EQ(__llvm_libc::mtx_lock(&mutex), int(thrd_success));
+
+  auto main_thread = __llvm_libc::thrd_current();
+
+  // The idea here is that, we start a child thread which will immediately
+  // wait on |mutex|. The main thread will update the global |child_thread| var
+  // and unlock |mutex|. This will give the child thread a chance to compare
+  // the result of thrd_self with the |child_thread|. The result of the
+  // comparison is returned in the thread arg.
+  int result = 0;
+  thrd_t th;
+  ASSERT_EQ(__llvm_libc::thrd_create(&th, child_func, &result),
+            int(thrd_success));
+  // This new thread should of course not be equal to the main thread.
+  ASSERT_EQ(__llvm_libc::thrd_equal(th, main_thread), 0);
+
+  // Set the |child_thread| global var and unlock to allow the child to perform
+  // the comparison.
+  child_thread = th;
+  ASSERT_EQ(__llvm_libc::mtx_unlock(&mutex), int(thrd_success));
+
+  int retval;
+  ASSERT_EQ(__llvm_libc::thrd_join(&th, &retval), int(thrd_success));
+  ASSERT_EQ(retval, 0);
+  // The child thread should see that thrd_current return value is the same as
+  // |child_thread|.
+  ASSERT_NE(result, 0);
+
+  __llvm_libc::mtx_destroy(&mutex);
+  return 0;
+}