[libc] Partially implement `atexit` on the GPU

[jhuber6]

Summary

The atexit function controls registering functions to call at the end
of the program. This is difficult to do in general on the GPU because of
the lack of a real mutex implementation. We primarily provide this for
testing where we can explicitly restrict how the atexit registration
functions are called. So we simply create a passthrough Mutex to get
past the usage of it as per @sivachandra's suggestion.

Depends on D149225

[sivachandra]

I will assume that the correctness on the GPU side will be ensured by other means.

libc/src/__support/threads/gpu/mutex.h

18

s/locks/lock

libc/config/gpu/api.td

 include "config/public_api.td"
 
 include "spec/stdc.td"
 
 def StringAPI : PublicAPI<"string.h"> {
   let Types = ["size_t"];
 }
+
+def StdlibAPI : PublicAPI<"stdlib.h"> {
+  let Types = [
+    "size_t",
+    "__atexithandler_t",
+  ];
+}

libc/config/gpu/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.string.strrchr
     libc.src.string.strspn
     libc.src.string.strstr
     libc.src.string.strtok
     libc.src.string.strtok_r
 
     # stdlib.h entrypoints
     libc.src.stdlib.atoi
+    libc.src.stdlib.atexit
 
     # Only implemented in the test suite
     libc.src.stdlib.malloc
+    libc.src.stdlib.aligned_alloc
     libc.src.stdlib.realloc
     libc.src.stdlib.free
 
     # errno.h entrypoints
     libc.src.errno.errno
 )
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
 )
 

libc/src/__support/threads/gpu/CMakeLists.txt

+add_header_library(
+  mutex
+  HDRS
+    mutex.h
+)

libc/src/__support/threads/gpu/mutex.h

+//===--- Implementation of a GPU mutex 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_THREAD_GPU_MUTEX_H
+#define LLVM_LIBC_SRC_SUPPORT_THREAD_GPU_MUTEX_H
+
+#include "src/__support/macros/attributes.h"
+#include "src/__support/threads/mutex_common.h"
+
+namespace __llvm_libc {
+
+/// Implementation of a simple passthrough mutex which guards nothing. A
+/// complete Mutex locks in general cannot be implemented on the GPU. We simply
+/// define the Mutex interface and require that only a single thread executes
+/// code requiring a mutex lock.
+struct Mutex {
+  LIBC_INLINE constexpr Mutex(bool, bool, bool) {}
+
+  LIBC_INLINE MutexError lock() { return MutexError::NONE; }
+  LIBC_INLINE MutexError unlock() { return MutexError::NONE; }
+  LIBC_INLINE MutexError reset() { return MutexError::NONE; }
+};
+
+} // namespace __llvm_libc
+
+#endif

libc/src/__support/threads/mutex.h

 //===--- A platform independent abstraction layer for mutexes ---*- 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_THREAD_MUTEX_H
 #define LLVM_LIBC_SRC_SUPPORT_THREAD_MUTEX_H
 
+#include "src/__support/macros/properties/architectures.h"
+
 // Platform independent code will include this header file which pulls
 // the platfrom specific specializations using platform macros.
 //
 // The platform specific specializations should define a class by name
 // Mutex with non-static methods having the following signature:
 //
 // MutexError lock();
 // MutexError trylock();

 // All of the static and non-static methods should ideally be implemented
 // as inline functions so that implementations of public functions can
 // call them without a function call overhead.
 //
 // Another point to keep in mind that is that the libc internally needs a
 // few global locks. So, to avoid static initialization order fiasco, we
 // want the constructors of the Mutex classes to be constexprs.
 
-#ifdef __unix__
+#if defined(__unix__)
 #include "linux/mutex.h"
+#elif defined(LIBC_TARGET_ARCH_IS_GPU)
+#include "gpu/mutex.h"
 #endif // __unix__
 
 namespace __llvm_libc {
 
 // An RAII class for easy locking and unlocking of mutexes.
 class MutexLock {
   Mutex *mutex;