[libc] Use the constexpr constructor to initialize exit handlers mutex.

[abrachet]

libc/src/stdlib/CMakeLists.txt

280

Why is this necessary?

[michaelrj]

libc/src/stdlib/atexit.cpp

18

this seems like it won't work if linux/mutex.h isn't included, should this be locked down by host OS?

[sivachandra]

Remove an optimization setting which is not required just yet.

libc/src/stdlib/CMakeLists.txt

280

This is actually required for a follow up change. Removed it now.

libc/src/stdlib/atexit.cpp

18

At that level, it was already that way. For, the functions __llvm_libc::mtx_lock etc are only available for the linux target. The way to look at this is that, the code in this file does not depend or use an OS specific piece directly - threads/mutex.h is the abstraction layer.

libc/src/stdlib/CMakeLists.txt

 
 add_entrypoint_object(
   atexit
   SRCS
     atexit.cpp
   HDRS
     atexit.h
   DEPENDS
     libc.src.__support.CPP.vector
-    libc.src.threads.mtx_init
-    libc.src.threads.mtx_lock
-    libc.src.threads.mtx_unlock
+    libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
   exit
   SRCS
     exit.cpp
   HDRS
     exit.h

libc/src/stdlib/atexit.cpp

 //===-- Implementation of atexit ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/atexit.h"
 #include "src/__support/CPP/vector.h"
 #include "src/__support/common.h"
-#include "src/threads/mtx_init.h"
-#include "src/threads/mtx_lock.h"
-#include "src/threads/mtx_unlock.h"
+#include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
 namespace {
 
-mtx_t lock;
-// TODO need an easier way to use mtx_t internally, or use pthread_mutex_t
-// with PTHREAD_MUTEX_INITIALIZER when it lands.
-struct Init {
-  Init() { __llvm_libc::mtx_init(&lock, mtx_plain); }
-} init;
+Mutex handler_list_mtx(false, false, false);
 
 // TOOD should we make cpp::vector like llvm::SmallVector<T, N> where it will
 // allocate at least N before needing dynamic allocation?
 static cpp::vector<void (*)(void)> handlers;
 
 } // namespace
 
 namespace internal {
 
 void call_exit_handlers() {
-  __llvm_libc::mtx_lock(&lock);
+  handler_list_mtx.lock();
   // TODO: implement rbegin() + rend() for cpp::vector
   for (int i = handlers.size() - 1; i >= 0; i--) {
-    __llvm_libc::mtx_unlock(&lock);
+    handler_list_mtx.unlock();
     handlers[i]();
-    __llvm_libc::mtx_lock(&lock);
+    handler_list_mtx.lock();
   }
 }
 
 } // namespace internal
 
 LLVM_LIBC_FUNCTION(int, atexit, (void (*function)())) {
-  __llvm_libc::mtx_lock(&lock);
+  handler_list_mtx.lock();
   handlers.push_back(function);
-  __llvm_libc::mtx_unlock(&lock);
+  handler_list_mtx.unlock();
   return 0;
 }
 
 } // namespace __llvm_libc