[llvm][Support] Use std::atomic for llvm::call_once

[efriedma]

This code is basically untested; I'd rather not touch it until we eventually kill it off. (See the definition of LLVM_THREADING_USE_STD_CALL_ONCE.)

[jfb]

is this code still relevant?

#if defined(_MSC_VER)
// MSVC's call_once implementation worked since VS 2015, which is the minimum
// supported version as of this writing.
#define LLVM_THREADING_USE_STD_CALL_ONCE 1
#elif defined(LLVM_ON_UNIX) &&                                                 \
    (defined(_LIBCPP_VERSION) ||                                               \
     !(defined(__NetBSD__) || defined(__OpenBSD__) ||                          \
       (defined(__ppc__) || defined(__PPC__))))
// std::call_once from libc++ is used on all Unix platforms. Other
// implementations like libstdc++ are known to have problems on NetBSD,
// OpenBSD and PowerPC.
#define LLVM_THREADING_USE_STD_CALL_ONCE 1
#elif defined(LLVM_ON_UNIX) &&                                                 \
    ((defined(__ppc__) || defined(__PPC__)) && defined(__LITTLE_ENDIAN__))
#define LLVM_THREADING_USE_STD_CALL_ONCE 1
#else
#define LLVM_THREADING_USE_STD_CALL_ONCE 0
#endif

Seems like something that's probably aged out? Check with @brad since it's from 2016 in b4f6ebf80695. What's the actual problem?

[brad]

OpenBSD 6.7 is just wrapping up and will be released in a few days. We have switched to Clang for our PowerPC system compiler and thus libc++. It should be Ok to remove OpenBSD from that bit of code.

The original issue as far as I remember is that because we don't have TLS support it was exposing another code path that could sometimes have deadlocks.

llvm/include/llvm/Support/Threading.h

 #define LLVM_THREADING_USE_STD_CALL_ONCE 1
 #else
 #define LLVM_THREADING_USE_STD_CALL_ONCE 0
 #endif
 
 #if LLVM_THREADING_USE_STD_CALL_ONCE
 #include <mutex>
 #else
-#include "llvm/Support/Atomic.h"
+#include <atomic>
 #endif
 
 namespace llvm {
 class Twine;
 
 /// Returns true if LLVM is compiled with support for multi-threading, and
 /// false otherwise.
 bool llvm_is_multithreaded();
#else
   enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
 
   /// The llvm::once_flag structure
   ///
   /// This type is modeled after std::once_flag to use with llvm::call_once.
   /// This structure must be used as an opaque object. It is a struct to force
   /// autoinitialization and behave like std::once_flag.
   struct once_flag {
-    volatile sys::cas_flag status = Uninitialized;
+    std::atomic<InitStatus> status(Uninitialized);
   };
 
 #endif
 
   /// Execute the function specified as a parameter once.
   ///
   /// Typical usage:
   /// \code
   ///   void foo() {...};
   ///   ...
   ///   static once_flag flag;
   ///   call_once(flag, foo);
   /// \endcode
   ///
   /// \param flag Flag used for tracking whether or not this has run.
   /// \param F Function to call once.
   template <typename Function, typename... Args>
   void call_once(once_flag &flag, Function &&F, Args &&... ArgList) {
 #if LLVM_THREADING_USE_STD_CALL_ONCE
     std::call_once(flag, std::forward<Function>(F),
                    std::forward<Args>(ArgList)...);
 #else
-    // For other platforms we use a generic (if brittle) version based on our
-    // atomics.
-    sys::cas_flag old_val = sys::CompareAndSwap(&flag.status, Wait, Uninitialized);
-    if (old_val == Uninitialized) {
+    switch (flag.status.compare_exchange_strong(Uninitialized, Wait)) {
+    case Uninitialized:
+      // This is the first time the function is invoked.
       std::forward<Function>(F)(std::forward<Args>(ArgList)...);
-      sys::MemoryFence();
-      TsanIgnoreWritesBegin();
-      TsanHappensBefore(&flag.status);
-      flag.status = Done;
-      TsanIgnoreWritesEnd();
-    } else {
-      // Wait until any thread doing the call has finished.
-      sys::cas_flag tmp = flag.status;
-      sys::MemoryFence();
-      while (tmp != Done) {
-        tmp = flag.status;
-        sys::MemoryFence();
+      flag.status.store(Done);
+      break;
+
+    case Wait:
+      while (flag.status.load() != Done) {
+        // Wait for function to finish.
       }
+      break;
+
+    case Done:
+      break;
     }
     TsanHappensAfter(&flag.status);
 #endif
   }
 
   /// This tells how a thread pool will be used
   class ThreadPoolStrategy {
   public: