Revamp llvm::once_flag to be closer to std::once_flag

[krytarowski]

Summary

Make this interface reusable similarly to std::call_once and std::once_flag interface.

This makes porting LLDB to NetBSD easier as there was in the original approach a portable way to specify a non-static once_flag. With this change translating std::once_flag to llvm::once_flag is mechanical.

Sponsored by <The NetBSD Foundation>

[mehdi_amini]

include/llvm/Support/Threading.h

71

If I understand correctly, this wrapper is only here to ensure that the status is always initialized right? Then this should be enough:

struct once_flag {
  volatile sys::cas_flag status = Uninitialized;
}

Also comment the struct.

[krytarowski]

Turn once_flag into struct.

Document once_flag.

Build tested with LLDB.

[mehdi_amini]

LGTM (see 1 inline comment)

include/llvm/Support/Threading.h

70

I meant: document the fact that we have this structure for the sole purpose of forcing initialization.

(also on a side note we deprecate the use of \brief by enabling auto-brief in doxygen)

[krytarowski]

Document autoinitialization purpose of llvm::once_flag.

For now leave \brief as it is, to be consistent with the rest of this file.

include/llvm/CodeGen/Passes.h

 #define INITIALIZE_TM_PASS_END(passName, arg, name, cfg, analysis)             \
   PassInfo *PI = new PassInfo(                                                 \
       name, arg, &passName::ID,                                                \
       PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis,        \
       PassInfo::TargetMachineCtor_t(callTargetMachineCtor<passName>));         \
   Registry.registerPass(*PI, true);                                            \
   return PI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
+  static llvm::once_flag Initialize##passName##PassFlag;                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
     llvm::call_once(Initialize##passName##PassFlag,                            \
                     initialize##passName##PassOnce, std::ref(Registry));       \
   }
 
 /// This initializer registers TargetMachine constructor, so the pass being
 /// initialized can use target dependent interfaces. Please do not move this
 /// macro to be together with INITIALIZE_PASS, which is a complete target
 /// independent initializer, and we don't want to make libScalarOpts depend
 /// on libCodeGen.
 #define INITIALIZE_TM_PASS(passName, arg, name, cfg, analysis)                 \
   INITIALIZE_TM_PASS_BEGIN(passName, arg, name, cfg, analysis)                 \
   INITIALIZE_TM_PASS_END(passName, arg, name, cfg, analysis)
 
 #endif

include/llvm/PassSupport.h

 #define INITIALIZE_PASS(passName, arg, name, cfg, analysis)                    \
   static void *initialize##passName##PassOnce(PassRegistry &Registry) {        \
     PassInfo *PI = new PassInfo(                                               \
         name, arg, &passName::ID,                                              \
         PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis);     \
     Registry.registerPass(*PI, true);                                          \
     return PI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
+  static llvm::once_flag Initialize##passName##PassFlag;                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
     llvm::call_once(Initialize##passName##PassFlag,                            \
                     initialize##passName##PassOnce, std::ref(Registry));       \
   }
 
 #define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)              \
   static void *initialize##passName##PassOnce(PassRegistry &Registry) {
 
 #define INITIALIZE_PASS_DEPENDENCY(depName) initialize##depName##Pass(Registry);
 #define INITIALIZE_AG_DEPENDENCY(depName)                                      \
   initialize##depName##AnalysisGroup(Registry);
 
 #define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)                \
   PassInfo *PI = new PassInfo(                                                 \
       name, arg, &passName::ID,                                                \
       PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis);       \
   Registry.registerPass(*PI, true);                                            \
   return PI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
+  static llvm::once_flag Initialize##passName##PassFlag;                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
     llvm::call_once(Initialize##passName##PassFlag,                            \
                     initialize##passName##PassOnce, std::ref(Registry));       \
   }
 
 #define INITIALIZE_PASS_WITH_OPTIONS(PassName, Arg, Name, Cfg, Analysis)       \
   INITIALIZE_PASS_BEGIN(PassName, Arg, Name, Cfg, Analysis)                    \
   PassName::registerOptions();                                                 \

 
 #define INITIALIZE_ANALYSIS_GROUP(agName, name, defaultPass)                   \
   static void *initialize##agName##AnalysisGroupOnce(PassRegistry &Registry) { \
     initialize##defaultPass##Pass(Registry);                                   \
     PassInfo *AI = new PassInfo(name, &agName::ID);                            \
     Registry.registerAnalysisGroup(&agName::ID, 0, *AI, false, true);          \
     return AI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##agName##AnalysisGroupFlag);                \
+  static llvm::once_flag Initialize##agName##AnalysisGroupFlag;                \
   void llvm::initialize##agName##AnalysisGroup(PassRegistry &Registry) {       \
     llvm::call_once(Initialize##agName##AnalysisGroupFlag,                     \
                     initialize##agName##AnalysisGroupOnce,                     \
                     std::ref(Registry));                                       \
   }
 
 #define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def)    \
   static void *initialize##passName##PassOnce(PassRegistry &Registry) {        \
     if (!def)                                                                  \
       initialize##agName##AnalysisGroup(Registry);                             \
     PassInfo *PI = new PassInfo(                                               \
         name, arg, &passName::ID,                                              \
         PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis);     \
     Registry.registerPass(*PI, true);                                          \
                                                                                \
     PassInfo *AI = new PassInfo(name, &agName::ID);                            \
     Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def,       \
                                    true);                                      \
     return AI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
+  static llvm::once_flag Initialize##passName##PassFlag;                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
     llvm::call_once(Initialize##passName##PassFlag,                            \
                     initialize##passName##PassOnce, std::ref(Registry));       \
   }
 
 #define INITIALIZE_AG_PASS_BEGIN(passName, agName, arg, n, cfg, analysis, def) \
   static void *initialize##passName##PassOnce(PassRegistry &Registry) {        \
     if (!def)                                                                  \
       initialize##agName##AnalysisGroup(Registry);
 
 #define INITIALIZE_AG_PASS_END(passName, agName, arg, n, cfg, analysis, def)   \
   PassInfo *PI = new PassInfo(                                                 \
       n, arg, &passName::ID,                                                   \
       PassInfo::NormalCtor_t(callDefaultCtor<passName>), cfg, analysis);       \
   Registry.registerPass(*PI, true);                                            \
                                                                                \
   PassInfo *AI = new PassInfo(n, &agName::ID);                                 \
   Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, true);  \
   return AI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
+  static llvm::once_flag Initialize##passName##PassFlag;                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
     llvm::call_once(Initialize##passName##PassFlag,                            \
                     initialize##passName##PassOnce, std::ref(Registry));       \
   }
 
 //===---------------------------------------------------------------------------
 /// PassRegistrationListener class - This class is meant to be derived from by
 /// clients that are interested in which passes get registered and unregistered

include/llvm/Support/Threading.h

namespace llvm {
   /// the thread stack.
   void llvm_execute_on_thread(void (*UserFn)(void*), void *UserData,
                               unsigned RequestedStackSize = 0);
 
 #if LLVM_THREADING_USE_STD_CALL_ONCE
 
   typedef std::once_flag once_flag;
 
-  /// This macro is the only way you should define your once flag for LLVM's
-  /// call_once.
-#define LLVM_DEFINE_ONCE_FLAG(flag) static once_flag flag
-
 #else
 
   enum InitStatus { Uninitialized = 0, Wait = 1, Done = 2 };
-  typedef volatile sys::cas_flag once_flag;
 
-  /// This macro is the only way you should define your once flag for LLVM's
-  /// call_once.
-#define LLVM_DEFINE_ONCE_FLAG(flag) \
-  static ::llvm::once_flag flag = ::llvm::Uninitialized
+  /// \brief 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;
+  };
 
 #endif
 
   /// \brief Execute the function specified as a parameter once.
   ///
   /// Typical usage:
   /// \code
   ///   void foo() {...};
   ///   ...
-  ///   LLVM_DEFINE_ONCE_FLAG(flag);
+  ///   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, Wait, Uninitialized);
+    sys::cas_flag old_val = sys::CompareAndSwap(&flag.status, Wait, Uninitialized);
     if (old_val == Uninitialized) {
       std::forward<Function>(F)(std::forward<Args>(ArgList)...);
       sys::MemoryFence();
       TsanIgnoreWritesBegin();
-      TsanHappensBefore(&flag);
-      flag = Done;
+      TsanHappensBefore(&flag.status);
+      flag.status = Done;
       TsanIgnoreWritesEnd();
     } else {
       // Wait until any thread doing the call has finished.
-      sys::cas_flag tmp = flag;
+      sys::cas_flag tmp = flag.status;
       sys::MemoryFence();
       while (tmp != Done) {
-        tmp = flag;
+        tmp = flag.status;
         sys::MemoryFence();
       }
     }
-    TsanHappensAfter(&flag);
+    TsanHappensAfter(&flag.status);
 #endif
   }
 
   /// Get the amount of currency to use for tasks requiring significant
   /// memory or other resources. Currently based on physical cores, if
   /// available for the host system, otherwise falls back to
   /// thread::hardware_concurrency().
   /// Returns 1 when LLVM is configured with LLVM_ENABLE_THREADS=OFF
   unsigned heavyweight_hardware_concurrency();
 }
 
 #endif

lib/CodeGen/TargetPassConfig.cpp

bool TargetPassConfig::getOptimizeRegAlloc() const {
   llvm_unreachable("Invalid optimize-regalloc state");
 }
 
 /// RegisterRegAlloc's global Registry tracks allocator registration.
 MachinePassRegistry RegisterRegAlloc::Registry;
 
 /// A dummy default pass factory indicates whether the register allocator is
 /// overridden on the command line.
-LLVM_DEFINE_ONCE_FLAG(InitializeDefaultRegisterAllocatorFlag);
+static llvm::once_flag InitializeDefaultRegisterAllocatorFlag;
 static FunctionPass *useDefaultRegisterAllocator() { return nullptr; }
 static RegisterRegAlloc
 defaultRegAlloc("default",
                 "pick register allocator based on -O option",
                 useDefaultRegisterAllocator);
 
 /// -regalloc=... command line option.
 static cl::opt<RegisterRegAlloc::FunctionPassCtor, false,

lib/Support/ManagedStatic.cpp

 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
 using namespace llvm;
 
 static const ManagedStaticBase *StaticList = nullptr;
 static sys::Mutex *ManagedStaticMutex = nullptr;
-LLVM_DEFINE_ONCE_FLAG(mutex_init_flag);
+static llvm::once_flag mutex_init_flag;
 
 static void initializeMutex() {
   ManagedStaticMutex = new sys::Mutex();
 }
 
 static sys::Mutex* getManagedStaticMutex() {
   // We need to use a function local static here, since this can get called
   // during a static constructor and we need to guarantee that it's initialized

lib/Target/X86/X86InstrFMA3Info.cpp

 #include "llvm/Support/Threading.h"
 #include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
 /// This flag is used in the method llvm::call_once() used below to make the
 /// initialization of the map 'OpcodeToGroup' thread safe.
-LLVM_DEFINE_ONCE_FLAG(InitGroupsOnceFlag);
+static llvm::once_flag InitGroupsOnceFlag;
 
 static ManagedStatic<X86InstrFMA3Info> X86InstrFMA3InfoObj;
 X86InstrFMA3Info *X86InstrFMA3Info::getX86InstrFMA3Info() {
   return &*X86InstrFMA3InfoObj;
 }
 
 void X86InstrFMA3Info::initRMGroup(const uint16_t *RegOpcodes,
                                    const uint16_t *MemOpcodes, unsigned Attr) {