[libc] Remove the remaining uses of stdatomic.h.

[sivachandra]

Summary

New methods to the Atomic class have been added as required. Futex
related types have been consolidated at a common place.

libc/config/linux/api.td

 }
 
 def SignalAPI : PublicAPI<"signal.h"> {
   let Types = ["struct sigaction", "__sighandler_t"];
 }
 
 def ThreadsAPI : PublicAPI<"threads.h"> {
   let Macros = [
-    SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
+    SimpleMacroDef<"ONCE_FLAG_INIT", "{0}">,
   ];
 
   let Types = [
     "__call_once_func_t",
     "once_flag",
     "cnd_t",
     "mtx_t",
     "thrd_t",

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(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(cnd_t HDR cnd_t.h)
 add_header(double_t HDR double_t.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(mode_t HDR mode_t.h)
-add_header(mtx_t HDR mtx_t.h)
+add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word)
 add_header(off_t HDR off_t.h)
-add_header(once_flag HDR once_flag.h)
+add_header(once_flag HDR once_flag.h DEPENDS .__futex_word)
 add_header(size_t HDR size_t.h)
 add_header(ssize_t HDR ssize_t.h)
 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)
 add_header(time_t HDR time_t.h)
 add_header(__atexithandler_t HDR __atexithandler_t.h)

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

+//===-- Definition of type which can represent a futex word ---------------===//
+//
+// 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_FUTEX_WORD_H__
+#define __LLVM_LIBC_TYPES_FUTEX_WORD_H__
+
+typedef struct {
+#if defined(__unix__) && (defined(__x86_64__) || defined(__aarch64__))
+  // Futex word should be aligned appropriately to allow target atomic
+  // instructions. This declaration mimics the internal setup.
+  _Alignas(sizeof(unsigned int) > _Alignof(unsigned int)
+               ? sizeof(unsigned int)
+               : _Alignof(unsigned int)) unsigned int __word;
+#else
+#error "A type to represent a futex word is not available for the target arch."
+#endif
+} __futex_word;
+
+#endif // __LLVM_LIBC_TYPES_FUTEX_WORD_H__

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

 //===-- Definition of mtx_t type ------------------------------------------===//
 //
 // 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_MTX_T_H__
 #define __LLVM_LIBC_TYPES_MTX_T_H__
 
+#include <llvm-libc-types/__futex_word.h>
+
 typedef struct {
-#if defined(__x86_64__) || defined(__aarch64__)
-  // Futex word should be aligned appropriately to allow target atomic
-  // instructions. This declaration mimics the internal setup.
-  struct {
-    _Alignas(sizeof(unsigned int) > _Alignof(unsigned int)
-                 ? sizeof(unsigned int)
-                 : _Alignof(unsigned int)) unsigned int __word;
-  } __futex_word;
+#ifdef __unix__
+  __futex_word __ftxw;
 #else
-#error "Mutex type mtx_t is not available for the target architecture."
+#error "mtx_t type not defined for the target platform."
 #endif
   int __mtx_type;
 } mtx_t;
 
 #endif // __LLVM_LIBC_TYPES_MTX_T_H__

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

 //===-- Definition of once_flag type --------------------------------------===//
 //
 // 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_ONCE_FLAG_H__
 #define __LLVM_LIBC_TYPES_ONCE_FLAG_H__
 
-typedef unsigned int once_flag;
+#include <llvm-libc-types/__futex_word.h>
 
-#endif // __LLVM_LIBC_TYPES_ONCE_FLAg_H__
+#ifdef __unix__
+typedef __futex_word once_flag;
+#else
+#error "Once flag type not defined for the target platform."
+#endif
+
+#endif // __LLVM_LIBC_TYPES_ONCE_FLAG_H__

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

 //===-- Definition of thrd_t type -----------------------------------------===//
 //
 // 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_THRD_T_H__
 #define __LLVM_LIBC_TYPES_THRD_T_H__
 
+#include <llvm-libc-types/__futex_word.h>
+
 typedef struct {
-  unsigned char __clear_tid[4];
+  __futex_word __clear_tid;
   int __tid;
   void *__stack;
   int __stack_size;
   int __retval;
 } thrd_t;
 
 #endif // __LLVM_LIBC_TYPES_THRD_T_H__

libc/src/__support/CPP/atomic.h

public:
   using value_type = T;
 
   // We keep the internal value public so that it can be addressable.
   // This is useful in places like the Linux futex operations where
   // we need pointers to the memory of the atomic values. Load and store
   // operations should be performed using the atomic methods however.
   alignas(ALIGNMENT) value_type val;
 
+  constexpr Atomic() = default;
+
   // Intializes the value without using atomic operations.
   constexpr Atomic(value_type v) : val(v) {}
 
   Atomic(const Atomic &) = delete;
   Atomic &operator=(const Atomic &) = delete;
 
   // Atomic load
   operator T() { return __atomic_load_n(&val, int(MemoryOrder::SEQ_CST)); }
public:
 
   // Atomic compare exchange
   bool compare_exchange_strong(T &expected, T desired,
                                MemoryOrder mem_ord = MemoryOrder::SEQ_CST) {
     return __atomic_compare_exchange_n(&val, &expected, desired, false,
                                        int(mem_ord), int(mem_ord));
   }
 
+  T exchange(T desired, MemoryOrder mem_ord = MemoryOrder::SEQ_CST) {
+    return __atomic_exchange_n(&val, desired, int(mem_ord));
+  }
+
+  T fetch_add(T increment, MemoryOrder mem_ord = MemoryOrder::SEQ_CST) {
+    return __atomic_fetch_add(&val, increment, int(mem_ord));
+  }
+
+  T fetch_sub(T decrement, MemoryOrder mem_ord = MemoryOrder::SEQ_CST) {
+    return __atomic_fetch_sub(&val, decrement, int(mem_ord));
+  }
+
   // Set the value without using an atomic operation. This is useful
   // in initializing atomic values without a constructor.
   void set(T rhs) { val = rhs; }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_ATOMIC_H

libc/src/threads/linux/CMakeLists.txt

add_entrypoint_object(
   SRCS
     call_once.cpp
   HDRS
     ../call_once.h
   DEPENDS
     .threads_utils
     libc.include.sys_syscall
     libc.include.threads
+    libc.src.__support.CPP.atomic
     libc.src.__support.OSUtil.osutil
 )
 
 add_header_library(
   threads_utils
   HDRS
     CndVar.h
     Futex.h
add_entrypoint_object(
   SRCS
     thrd_join.cpp
   HDRS
     ../thrd_join.h
   DEPENDS
     .threads_utils
     libc.include.sys_syscall
     libc.include.threads
+    libc.src.__support.CPP.atomic
     libc.src.__support.common
     libc.src.__support.OSUtil.osutil
     libc.src.sys.mman.munmap
 )
 
 add_entrypoint_object(
   mtx_init
   SRCS

libc/src/threads/linux/Futex.h

 //===-- Linux futex related definitions -------------------------*- 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_LINUX_FUTEX_H
 #define LLVM_LIBC_SRC_THREADS_LINUX_FUTEX_H
 
-#include <stdatomic.h>
+#include "src/__support/architectures.h" // Architecture macros
 
 namespace __llvm_libc {
 
+#if (defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_X86_64))
 // The futex data has to be exactly 4 bytes long. However, we use a uint type
-// here as we do not want to use `_Atomic uint32_t` as the _Atomic keyword which
-// is C only. The header stdatomic.h does not define an atomic type
-// corresponding to `uint32_t` or to something which is exactly 4 bytes wide.
-using FutexWord = atomic_uint;
-static_assert(sizeof(atomic_uint) == 4,
-              "Size of the `atomic_uint` type is not 4 bytes on your platform. "
-              "The implementation of the standard threads library for linux "
-              "requires that size of `atomic_uint` be 4 bytes.");
+// here as we do not want to use `uint32_t` type to match the public definitions
+// of types which include a field for a futex word. With public definitions, we
+// cannot include <stdint.h> so we stick to the `unsigned int` type for x86_64
+// and aarch64
+using FutexWordType = unsigned int;
+static_assert(sizeof(FutexWordType) == 4,
+              "Unexpected size of unsigned int type.");
+#else
+#error "Futex word base type not defined for the target architecture."
+#endif
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_LINUX_FUTEX_H

libc/src/threads/linux/Mutex.h

 //===-- Utility mutex classes -----------------------------------*- 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_LINUX_MUTEX_H
 #define LLVM_LIBC_SRC_THREADS_LINUX_MUTEX_H
 
+#include "Futex.h"
+
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "include/threads.h"              // For values like thrd_success etc.
 #include "src/__support/CPP/atomic.h"     // For atomics support
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 
 #include <linux/futex.h> // For futex operations.
 
 namespace __llvm_libc {
 
-#if (defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_X86_64))
-static_assert(sizeof(unsigned int) == 4,
-              "Unexpected size of unsigned int type.");
-typedef unsigned int FutexWordType;
-#else
-#error "Futex word base type not defined for the target architecture."
-#endif
-
 struct Mutex {
   enum Status : FutexWordType {
     MS_Free,
     MS_Locked,
     MS_Waiting,
   };
 
   cpp::Atomic<FutexWordType> futex_word;

libc/src/threads/linux/Thread.h

 //===-- Linux specific definitions for threads implementations. --*- 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_LINUX_THREAD_UTILS_H
 #define LLVM_LIBC_SRC_THREADS_LINUX_THREAD_UTILS_H
 
 #include "thread_start_args.h"
 
-#include <stdatomic.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 struct ThreadParams {
   static constexpr uintptr_t DEFAULT_STACK_SIZE = 1 << 16; // 64 KB
   static constexpr uint32_t CLEAR_TID_VALUE = 0xABCD1234;
 };
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_LINUX_THREAD_UTILS_H

libc/src/threads/linux/call_once.cpp

 //===-- Linux implementation of the call_once 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/call_once.h"
+#include "Futex.h"
+
 #include "include/sys/syscall.h" // For syscall numbers.
 #include "include/threads.h"     // For call_once related type definition.
+#include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 #include "src/__support/common.h"
+#include "src/threads/call_once.h"
 #include "src/threads/linux/Futex.h"
 
 #include <limits.h>
 #include <linux/futex.h>
-#include <stdatomic.h>
 
 namespace __llvm_libc {
 
-static constexpr unsigned START = 0x11;
-static constexpr unsigned WAITING = 0x22;
-static constexpr unsigned FINISH = 0x33;
+static constexpr FutexWordType START = 0x11;
+static constexpr FutexWordType WAITING = 0x22;
+static constexpr FutexWordType FINISH = 0x33;
+static constexpr once_flag ONCE_FLAG_INIT_VAL = ONCE_FLAG_INIT;
 
 LLVM_LIBC_FUNCTION(void, call_once,
                    (once_flag * flag, __call_once_func_t func)) {
-  FutexWord *futex_word = reinterpret_cast<FutexWord *>(flag);
-  unsigned int not_called = ONCE_FLAG_INIT;
+  auto *futex_word = reinterpret_cast<cpp::Atomic<FutexWordType> *>(flag);
+  static_assert(sizeof(*futex_word) == sizeof(once_flag));
+
+  FutexWordType not_called = ONCE_FLAG_INIT_VAL.__word;
 
   // The C standard wording says:
   //
   //     The completion of the function func synchronizes with all
   //     previous or subsequent calls to call_once with the same
   //     flag variable.
   //
   // What this means is that, the call_once call can return only after
   // the called function |func| returns. So, we use futexes to synchronize
   // calls with the same flag value.
-  if (::atomic_compare_exchange_strong(futex_word, &not_called, START)) {
+  if (futex_word->compare_exchange_strong(not_called, START)) {
     func();
-    auto status = ::atomic_exchange(futex_word, FINISH);
+    auto status = futex_word->exchange(FINISH);
     if (status == WAITING) {
-      __llvm_libc::syscall(SYS_futex, futex_word, FUTEX_WAKE_PRIVATE,
+      __llvm_libc::syscall(SYS_futex, &futex_word->val, FUTEX_WAKE_PRIVATE,
                            INT_MAX, // Wake all waiters.
                            0, 0, 0);
     }
     return;
   }
 
-  unsigned int status = START;
-  if (::atomic_compare_exchange_strong(futex_word, &status, WAITING) ||
+  FutexWordType status = START;
+  if (futex_word->compare_exchange_strong(status, WAITING) ||
       status == WAITING) {
-    __llvm_libc::syscall(SYS_futex, futex_word, FUTEX_WAIT_PRIVATE,
+    __llvm_libc::syscall(SYS_futex, &futex_word->val, FUTEX_WAIT_PRIVATE,
                          WAITING, // Block only if status is still |WAITING|.
                          0, 0, 0);
   }
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/thrd_create.cpp

 //===-- Linux implementation of the thrd_create 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_create.h"
+#include "Futex.h"
+
 #include "include/errno.h"                // For E* error values.
 #include "include/sys/mman.h"             // For PROT_* and MAP_* definitions.
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "include/threads.h"              // For thrd_* type definitions.
 #include "src/__support/OSUtil/syscall.h" // For syscall function.
 #include "src/__support/common.h"
 #include "src/errno/llvmlibc_errno.h"
 #include "src/sys/mman/mmap.h"
 #include "src/sys/mman/munmap.h"
-#include "src/threads/linux/Futex.h"
 #include "src/threads/linux/Thread.h"
+#include "src/threads/thrd_create.h"
 
 #include <linux/sched.h> // For CLONE_* flags.
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 struct StartArgs {
   thrd_t *thread;
void *stack = __llvm_libc::mmap(nullptr, ThreadParams::DEFAULT_STACK_SIZE,
                                   PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   if (stack == MAP_FAILED)
     return llvmlibc_errno == ENOMEM ? thrd_nomem : thrd_error;
 
   thread->__stack = stack;
   thread->__stack_size = ThreadParams::DEFAULT_STACK_SIZE;
   thread->__retval = -1;
-  FutexWord *clear_tid_address =
-      reinterpret_cast<FutexWord *>(thread->__clear_tid);
+  FutexWordType *clear_tid_address = &thread->__clear_tid.__word;
   *clear_tid_address = ThreadParams::CLEAR_TID_VALUE;
 
   // When the new thread is spawned by the kernel, the new thread gets the
   // stack we pass to the clone syscall. However, this stack is empty and does
   // not have any local vars present in this function. Hence, one cannot
   // pass arguments to the thread start function, or use any local vars from
   // here. So, we pack them into the new stack from where the thread can sniff
   // them out.

libc/src/threads/linux/thrd_join.cpp

 //===-- Linux implementation of the thrd_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 "src/threads/thrd_join.h"
-#include "include/sys/syscall.h"          // For syscall numbers.
-#include "include/threads.h"              // For thrd_* type definitions.
+#include "Futex.h"
+
+#include "include/sys/syscall.h" // For syscall numbers.
+#include "include/threads.h"     // For thrd_* type definitions.
+#include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall function.
 #include "src/__support/common.h"
 #include "src/sys/mman/munmap.h"
-#include "src/threads/linux/Futex.h"
 #include "src/threads/linux/Thread.h"
+#include "src/threads/thrd_join.h"
 
 #include <linux/futex.h> // For futex operations.
-#include <stdatomic.h>   // For atomic_load.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, thrd_join, (thrd_t * thread, int *retval)) {
-  FutexWord *clear_tid_address =
-      reinterpret_cast<FutexWord *>(thread->__clear_tid);
+  auto *clear_tid_address =
+      reinterpret_cast<cpp::Atomic<FutexWordType> *>(&thread->__clear_tid);
 
   // The kernel should set the value at the clear tid address to zero.
   // If not, it is a spurious wake and we should continue to wait on
   // the futex.
-  while (atomic_load(clear_tid_address) != 0) {
+  while (clear_tid_address->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_address, FUTEX_WAIT,
+    __llvm_libc::syscall(SYS_futex, &clear_tid_address->val, FUTEX_WAIT,
                          ThreadParams::CLEAR_TID_VALUE, nullptr);
   }
 
   *retval = thread->__retval;
 
   if (__llvm_libc::munmap(thread->__stack, thread->__stack_size) == -1)
     return thrd_error;
 
   return thrd_success;
 }
 
 } // namespace __llvm_libc

libc/test/src/threads/CMakeLists.txt

DEPENDS
     libc.include.threads
     libc.src.threads.call_once
     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_join
+    libc.src.__support.CPP.atomic
 )
 
 add_libc_unittest(
   thrd_test
   SUITE
     libc_threads_unittests
   SRCS
     thrd_test.cpp

libc/test/src/threads/call_once_test.cpp

 //===-- Unittests for call_once -------------------------------------------===//
 //
 // 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 "include/threads.h"
+#include "src/__support/CPP/atomic.h"
 #include "src/threads/call_once.h"
 #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_join.h"
 #include "utils/UnitTest/Test.h"
 
-#include <stdatomic.h>
-
 static constexpr unsigned int NUM_THREADS = 5;
-static atomic_uint thread_count;
+static __llvm_libc::cpp::Atomic<unsigned int> thread_count;
 
 static unsigned int call_count;
 static void call_once_func() { ++call_count; }
 
 static int func(void *) {
   static once_flag flag = ONCE_FLAG_INIT;
   __llvm_libc::call_once(&flag, call_once_func);
 
-  ++thread_count; // This is a an atomic update.
+  thread_count.fetch_add(1);
 
   return 0;
 }
 
 TEST(LlvmLibcCallOnceTest, CallFrom5Threads) {
   // Ensure the call count and thread count are 0 to begin with.
   call_count = 0;
   thread_count = 0;
 
   thrd_t threads[NUM_THREADS];
   for (unsigned int i = 0; i < NUM_THREADS; ++i) {
     ASSERT_EQ(__llvm_libc::thrd_create(threads + i, func, nullptr),
               static_cast<int>(thrd_success));
   }
 
   for (unsigned int i = 0; i < NUM_THREADS; ++i) {
     int retval;
     ASSERT_EQ(__llvm_libc::thrd_join(threads + i, &retval),
               static_cast<int>(thrd_success));
     ASSERT_EQ(retval, 0);
   }
 
-  EXPECT_EQ(static_cast<unsigned int>(thread_count), 5U);
+  EXPECT_EQ(thread_count.val, 5U);
   EXPECT_EQ(call_count, 1U);
 }
 
 static mtx_t once_func_blocker;
 static void blocking_once_func() {
   __llvm_libc::mtx_lock(&once_func_blocker);
   __llvm_libc::mtx_unlock(&once_func_blocker);
 }
 
-static atomic_uint start_count;
-static atomic_uint done_count;
+static __llvm_libc::cpp::Atomic<unsigned int> start_count;
+static __llvm_libc::cpp::Atomic<unsigned int> done_count;
 static int once_func_caller(void *) {
   static once_flag flag;
-  ++start_count;
+  start_count.fetch_add(1);
   __llvm_libc::call_once(&flag, blocking_once_func);
-  ++done_count;
+  done_count.fetch_add(1);
   return 0;
 }
 
 // Test the synchronization aspect of the call_once function.
 // This is not a fool proof test, but something which might be
 // useful when we add a flakiness detection scheme to UnitTest.
 TEST(LlvmLibcCallOnceTest, TestSynchronization) {
   start_count = 0;
   done_count = 0;
 
   ASSERT_EQ(__llvm_libc::mtx_init(&once_func_blocker, mtx_plain),
             static_cast<int>(thrd_success));
   // Lock the blocking mutex so that the once func blocks.
   ASSERT_EQ(__llvm_libc::mtx_lock(&once_func_blocker),
             static_cast<int>(thrd_success));
 
   thrd_t t1, t2;
   ASSERT_EQ(__llvm_libc::thrd_create(&t1, once_func_caller, nullptr),
             static_cast<int>(thrd_success));
   ASSERT_EQ(__llvm_libc::thrd_create(&t2, once_func_caller, nullptr),
             static_cast<int>(thrd_success));
 
-  while (start_count != 2)
+  while (start_count.load() != 2)
     ; // Spin until both threads start.
 
   // Since the once func is blocked, the threads should not be done yet.
-  EXPECT_EQ(static_cast<unsigned int>(done_count), 0U);
+  EXPECT_EQ(done_count.val, 0U);
 
   // Unlock the blocking mutex so that the once func blocks.
   ASSERT_EQ(__llvm_libc::mtx_unlock(&once_func_blocker),
             static_cast<int>(thrd_success));
 
   int retval;
   ASSERT_EQ(__llvm_libc::thrd_join(&t1, &retval),
             static_cast<int>(thrd_success));
   ASSERT_EQ(retval, 0);
   ASSERT_EQ(__llvm_libc::thrd_join(&t2, &retval),
             static_cast<int>(thrd_success));
   ASSERT_EQ(retval, 0);
 
-  ASSERT_EQ(static_cast<unsigned int>(done_count), 2U);
+  ASSERT_EQ(done_count.val, 2U);
 
   __llvm_libc::mtx_destroy(&once_func_blocker);
 }

libc/test/src/threads/cnd_test.cpp

 //===-- Unittests for condition variable broadcast fucntionality ----------===//
 //
 // 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 <stdatomic.h>
-
 #include "include/threads.h"
+#include "src/__support/CPP/atomic.h"
 #include "src/threads/cnd_broadcast.h"
 #include "src/threads/cnd_destroy.h"
 #include "src/threads/cnd_init.h"
 #include "src/threads/cnd_signal.h"
 #include "src/threads/cnd_wait.h"
 #include "src/threads/mtx_destroy.h"
 #include "src/threads/mtx_init.h"
 #include "src/threads/mtx_lock.h"

 // variable |broadcast_cnd|. After spawing the threads, it waits on another
 // condition variable |threads_ready_cnd| which will be signalled by the last
 // thread before it starts waiting on |broadcast_cnd|. On signalled by the
 // last thread, the main thread then wakes up to broadcast to all waiting
 // threads to wake up. Each of the THRD_COUNT child threads increment
 // |broadcast_count| by 1 before they start waiting on |broadcast_cnd|, and
 // decrement it by 1 after getting signalled on |broadcast_cnd|.
 
-constexpr int THRD_COUNT = 10000;
+constexpr unsigned int THRD_COUNT = 10000;
 
-static atomic_uint broadcast_count = 0;
+static __llvm_libc::cpp::Atomic<unsigned int> broadcast_count(0);
 static cnd_t broadcast_cnd, threads_ready_cnd;
 static mtx_t broadcast_mtx, threads_ready_mtx;
 
 int broadcast_thread_func(void *) {
   __llvm_libc::mtx_lock(&broadcast_mtx);
-  int oldval = atomic_fetch_add(&broadcast_count, 1);
+  int oldval = broadcast_count.fetch_add(1);
   if (oldval == THRD_COUNT - 1) {
     __llvm_libc::mtx_lock(&threads_ready_mtx);
     __llvm_libc::cnd_signal(&threads_ready_cnd);
     __llvm_libc::mtx_unlock(&threads_ready_mtx);
   }
 
   __llvm_libc::cnd_wait(&broadcast_cnd, &broadcast_mtx);
   __llvm_libc::mtx_unlock(&broadcast_mtx);
-  atomic_fetch_sub(&broadcast_count, 1);
+  broadcast_count.fetch_sub(1);
   return 0;
 }
 
 TEST(LlvmLibcCndVarTest, WaitNotifyBroadcastTest) {
   __llvm_libc::cnd_init(&broadcast_cnd);
   __llvm_libc::cnd_init(&threads_ready_cnd);
   __llvm_libc::mtx_init(&broadcast_mtx, mtx_plain);
   __llvm_libc::mtx_init(&threads_ready_mtx, mtx_plain);
 
   __llvm_libc::mtx_lock(&threads_ready_mtx);
   thrd_t threads[THRD_COUNT];
   for (unsigned int i = 0; i < THRD_COUNT; ++i)
     __llvm_libc::thrd_create(&threads[i], broadcast_thread_func, nullptr);
 
   __llvm_libc::cnd_wait(&threads_ready_cnd, &threads_ready_mtx);
   __llvm_libc::mtx_unlock(&threads_ready_mtx);
 
   __llvm_libc::mtx_lock(&broadcast_mtx);
-  ASSERT_EQ(int(broadcast_count), THRD_COUNT);
+  ASSERT_EQ(broadcast_count.val, THRD_COUNT);
   __llvm_libc::cnd_broadcast(&broadcast_cnd);
   __llvm_libc::mtx_unlock(&broadcast_mtx);
 
   for (unsigned int i = 0; i < THRD_COUNT; ++i) {
     int retval = 0xBAD;
     __llvm_libc::thrd_join(&threads[i], &retval);
     ASSERT_EQ(retval, 0);
   }
 
-  ASSERT_EQ(int(broadcast_count), 0);
+  ASSERT_EQ(broadcast_count.val, 0U);
 
   __llvm_libc::cnd_destroy(&broadcast_cnd);
   __llvm_libc::cnd_destroy(&threads_ready_cnd);
   __llvm_libc::mtx_destroy(&broadcast_mtx);
   __llvm_libc::mtx_destroy(&threads_ready_mtx);
 }
 
 } // namespace wait_notify_broadcast_test