[LPM] Revert r271781 which was a re-commit of r271652.

There appears to be a strange exception thrown and crash using call_once
on a PPC build bot, and a *really* weird windows link error for
GCMetadata.obj. Still need to investigate the cause of both problems.

Original change summary:
[LPM] Reinstate r271652 to replace the CALL_ONCE_... macro in the legacy
pass manager with the new llvm::call_once facility.

llvm-svn: 271788

5 files changed, 55 insertions, 52 deletions

diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h
index 6c85c250cbb..1e01d66a2ce 100644
--- a/llvm/include/llvm/CodeGen/Passes.h
+++ b/llvm/include/llvm/CodeGen/Passes.h
@@ -377,10 +377,8 @@ namespace llvm {
   Registry.registerPass(*PI, true);                                            \
   return PI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
-    llvm::call_once(Initialize##passName##PassFlag,                            \
-                    initialize##passName##PassOnce, std::ref(Registry));       \
+    CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce)                   \
   }
 
 /// This initializer registers TargetMachine constructor, so the pass being
diff --git a/llvm/include/llvm/PassSupport.h b/llvm/include/llvm/PassSupport.h
index ba6d84f04ba..f205c001f53 100644
--- a/llvm/include/llvm/PassSupport.h
+++ b/llvm/include/llvm/PassSupport.h
@@ -26,13 +26,31 @@
 #include "llvm/PassInfo.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/Support/Atomic.h"
-#include "llvm/Support/Threading.h"
-#include <functional>
 
 namespace llvm {
 
 class TargetMachine;
 
+#define CALL_ONCE_INITIALIZATION(function)                                     \
+  static volatile sys::cas_flag initialized = 0;                               \
+  sys::cas_flag old_val = sys::CompareAndSwap(&initialized, 1, 0);             \
+  if (old_val == 0) {                                                          \
+    function(Registry);                                                        \
+    sys::MemoryFence();                                                        \
+    TsanIgnoreWritesBegin();                                                   \
+    TsanHappensBefore(&initialized);                                           \
+    initialized = 2;                                                           \
+    TsanIgnoreWritesEnd();                                                     \
+  } else {                                                                     \
+    sys::cas_flag tmp = initialized;                                           \
+    sys::MemoryFence();                                                        \
+    while (tmp != 2) {                                                         \
+      tmp = initialized;                                                       \
+      sys::MemoryFence();                                                      \
+    }                                                                          \
+  }                                                                            \
+  TsanHappensAfter(&initialized);
+
 #define INITIALIZE_PASS(passName, arg, name, cfg, analysis)                    \
   static void *initialize##passName##PassOnce(PassRegistry &Registry) {        \
     PassInfo *PI = new PassInfo(                                               \
@@ -41,10 +59,8 @@ class TargetMachine;
     Registry.registerPass(*PI, true);                                          \
     return PI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
-    llvm::call_once(Initialize##passName##PassFlag,                            \
-                    initialize##passName##PassOnce, std::ref(Registry));       \
+    CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce)                   \
   }
 
 #define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)              \
@@ -61,10 +77,8 @@ class TargetMachine;
   Registry.registerPass(*PI, true);                                            \
   return PI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
-    llvm::call_once(Initialize##passName##PassFlag,                            \
-                    initialize##passName##PassOnce, std::ref(Registry));       \
+    CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce)                   \
   }
 
 #define INITIALIZE_PASS_WITH_OPTIONS(PassName, Arg, Name, Cfg, Analysis)       \
@@ -152,11 +166,8 @@ struct RegisterAnalysisGroup : public RegisterAGBase {
     Registry.registerAnalysisGroup(&agName::ID, 0, *AI, false, true);          \
     return AI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##agName##AnalysisGroupFlag);                \
   void llvm::initialize##agName##AnalysisGroup(PassRegistry &Registry) {       \
-    llvm::call_once(Initialize##agName##AnalysisGroupFlag,                     \
-                    initialize##agName##AnalysisGroupOnce,                     \
-                    std::ref(Registry));                                       \
+    CALL_ONCE_INITIALIZATION(initialize##agName##AnalysisGroupOnce)            \
   }
 
 #define INITIALIZE_AG_PASS(passName, agName, arg, name, cfg, analysis, def)    \
@@ -173,10 +184,8 @@ struct RegisterAnalysisGroup : public RegisterAGBase {
                                    true);                                      \
     return AI;                                                                 \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
-    llvm::call_once(Initialize##passName##PassFlag,                            \
-                    initialize##passName##PassOnce, std::ref(Registry));       \
+    CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce)                   \
   }
 
 #define INITIALIZE_AG_PASS_BEGIN(passName, agName, arg, n, cfg, analysis, def) \
@@ -194,10 +203,8 @@ struct RegisterAnalysisGroup : public RegisterAGBase {
   Registry.registerAnalysisGroup(&agName::ID, &passName::ID, *AI, def, true);  \
   return AI;                                                                   \
   }                                                                            \
-  LLVM_DEFINE_ONCE_FLAG(Initialize##passName##PassFlag);                       \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) {              \
-    llvm::call_once(Initialize##passName##PassFlag,                            \
-                    initialize##passName##PassOnce, std::ref(Registry));       \
+    CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce)                   \
   }
 
 //===---------------------------------------------------------------------------
diff --git a/llvm/include/llvm/Support/Threading.h b/llvm/include/llvm/Support/Threading.h
index 9804dd8aff6..b51d1f97fa9 100644
--- a/llvm/include/llvm/Support/Threading.h
+++ b/llvm/include/llvm/Support/Threading.h
@@ -16,9 +16,7 @@
 #define LLVM_SUPPORT_THREADING_H
 
 #include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
-#include "llvm/Support/Compiler.h"
 #include <ciso646> // So we can check the C++ standard lib macros.
-#include <functional>
 
 // We use std::call_once on all Unix platforms except for NetBSD with
 // libstdc++. That platform has a bug they are working to fix, and they'll
@@ -86,34 +84,7 @@ namespace llvm {
   ///
   /// \param flag Flag used for tracking whether or not this has run.
   /// \param UserFn 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);
-    if (old_val == Uninitialized) {
-      std::forward<Function>(F)(std::forward<Args>(ArgList)...);
-      sys::MemoryFence();
-      TsanIgnoreWritesBegin();
-      TsanHappensBefore(&flag);
-      flag = Done;
-      TsanIgnoreWritesEnd();
-    } else {
-      // Wait until any thread doing the call has finished.
-      sys::cas_flag tmp = flag;
-      sys::MemoryFence();
-      while (tmp != Done) {
-        tmp = flag;
-        sys::MemoryFence();
-      }
-    }
-    TsanHappensAfter(&flag);
-#endif
-  }
+  void call_once(once_flag &flag, void (*UserFn)(void));
 }
 
 #endif
diff --git a/llvm/lib/Support/ManagedStatic.cpp b/llvm/lib/Support/ManagedStatic.cpp
index bc4fe954e22..b1feddc09ec 100644
--- a/llvm/lib/Support/ManagedStatic.cpp
+++ b/llvm/lib/Support/ManagedStatic.cpp
@@ -32,7 +32,7 @@ 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
   // correctly.
-  llvm::call_once(mutex_init_flag, initializeMutex);
+  call_once(mutex_init_flag, initializeMutex);
   return ManagedStaticMutex;
 }
 
diff --git a/llvm/lib/Support/Threading.cpp b/llvm/lib/Support/Threading.cpp
index e8f5622d0e5..de2ff6b4fae 100644
--- a/llvm/lib/Support/Threading.cpp
+++ b/llvm/lib/Support/Threading.cpp
@@ -116,3 +116,30 @@ void llvm::llvm_execute_on_thread(void (*Fn)(void*), void *UserData,
 }
 
 #endif
+
+void llvm::call_once(once_flag &flag, void (*fptr)(void)) {
+#if LLVM_THREADING_USE_STD_CALL_ONCE
+  std::call_once(flag, fptr);
+#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);
+  if (old_val == Uninitialized) {
+    fptr();
+    sys::MemoryFence();
+    TsanIgnoreWritesBegin();
+    TsanHappensBefore(&flag);
+    flag = Done;
+    TsanIgnoreWritesEnd();
+  } else {
+    // Wait until any thread doing the call has finished.
+    sys::cas_flag tmp = flag;
+    sys::MemoryFence();
+    while (tmp != Done) {
+      tmp = flag;
+      sys::MemoryFence();
+    }
+  }
+  TsanHappensAfter(&flag);
+#endif
+}