Cleaning up more static initializers in Signals.inc by converting them to ManagedStatic.

[beanz]

Summary

This patch converts three static globals that have non-trivial initializers to ManagedStatic objects to avoid load-time static initialization.

lib/Support/Unix/Signals.inc

 // Unix signals occurring while your program is running.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Unix.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/UniqueLock.h"
+#include "llvm/Support/ManagedStatic.h"
 #include <algorithm>
 #include <string>
 #include <vector>
 #if HAVE_EXECINFO_H
 # include <execinfo.h>         // For backtrace().
 #endif
 #if HAVE_SIGNAL_H
 #include <signal.h>

 #if HAVE_MACH_MACH_H
 #include <mach/mach.h>
 #endif
 
 using namespace llvm;
 
 static RETSIGTYPE SignalHandler(int Sig);  // defined below.
 
-static SmartMutex<true> SignalsMutex;
+static ManagedStatic<SmartMutex<true> > SignalsMutex;
 
 /// InterruptFunction - The function to call if ctrl-c is pressed.
 static void (*InterruptFunction)() = nullptr;
 
-static std::vector<std::string> FilesToRemove;
-static std::vector<std::pair<void(*)(void*), void*> > CallBacksToRun;
+static ManagedStatic<std::vector<std::string>> FilesToRemove;
+static ManagedStatic<std::vector<std::pair<void (*)(void *), void *>>>
+    CallBacksToRun;
 
 // IntSigs - Signals that represent requested termination. There's no bug
 // or failure, or if there is, it's not our direct responsibility. For whatever
 // reason, our continued execution is no longer desirable.
 static const int IntSigs[] = {
   SIGHUP, SIGINT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
 };
 

 
 /// RemoveFilesToRemove - Process the FilesToRemove list. This function
 /// should be called with the SignalsMutex lock held.
 /// NB: This must be an async signal safe function. It cannot allocate or free
 /// memory, even in debug builds.
 static void RemoveFilesToRemove() {
   // We avoid iterators in case of debug iterators that allocate or release
   // memory.
-  for (unsigned i = 0, e = FilesToRemove.size(); i != e; ++i) {
+  for (unsigned i = 0, e = FilesToRemove->size(); i != e; ++i) {
     // We rely on a std::string implementation for which repeated calls to
     // 'c_str()' don't allocate memory. We pre-call 'c_str()' on all of these
     // strings to try to ensure this is safe.
-    const char *path = FilesToRemove[i].c_str();
+    const char *path = (*FilesToRemove)[i].c_str();
 
     // Get the status so we can determine if it's a file or directory. If we
     // can't stat the file, ignore it.
     struct stat buf;
     if (stat(path, &buf) != 0)
       continue;
 
     // If this is not a regular file, ignore it. We want to prevent removal of
static RETSIGTYPE SignalHandler(int Sig) {
   UnregisterHandlers();
 
   // Unmask all potentially blocked kill signals.
   sigset_t SigMask;
   sigfillset(&SigMask);
   sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
 
   {
-    unique_lock<SmartMutex<true>> Guard(SignalsMutex);
+    unique_lock<SmartMutex<true>> Guard(*SignalsMutex);
     RemoveFilesToRemove();
 
     if (std::find(std::begin(IntSigs), std::end(IntSigs), Sig)
         != std::end(IntSigs)) {
       if (InterruptFunction) {
         void (*IF)() = InterruptFunction;
         Guard.unlock();
         InterruptFunction = nullptr;
         IF();        // run the interrupt function.
         return;
       }
 
       Guard.unlock();
       raise(Sig);   // Execute the default handler.
       return;
    }
   }
 
   // Otherwise if it is a fault (like SEGV) run any handler.
-  for (unsigned i = 0, e = CallBacksToRun.size(); i != e; ++i)
-    CallBacksToRun[i].first(CallBacksToRun[i].second);
+  for (unsigned i = 0, e = CallBacksToRun->size(); i != e; ++i)
+    (*CallBacksToRun)[i].first((*CallBacksToRun)[i].second);
 
 #ifdef __s390__
   // On S/390, certain signals are delivered with PSW Address pointing to
   // *after* the faulting instruction.  Simply returning from the signal
   // handler would continue execution after that point, instead of
   // re-raising the signal.  Raise the signal manually in those cases.
   if (Sig == SIGILL || Sig == SIGFPE || Sig == SIGTRAP)
     raise(Sig);
 #endif
 }
 
 void llvm::sys::RunInterruptHandlers() {
-  sys::SmartScopedLock<true> Guard(SignalsMutex);
+  sys::SmartScopedLock<true> Guard(*SignalsMutex);
   RemoveFilesToRemove();
 }
 
 void llvm::sys::SetInterruptFunction(void (*IF)()) {
   {
-    sys::SmartScopedLock<true> Guard(SignalsMutex);
+    sys::SmartScopedLock<true> Guard(*SignalsMutex);
     InterruptFunction = IF;
   }
   RegisterHandlers();
 }
 
 // RemoveFileOnSignal - The public API
 bool llvm::sys::RemoveFileOnSignal(StringRef Filename,
                                    std::string* ErrMsg) {
   {
-    sys::SmartScopedLock<true> Guard(SignalsMutex);
-    std::string *OldPtr = FilesToRemove.empty() ? nullptr : &FilesToRemove[0];
-    FilesToRemove.push_back(Filename);
+    sys::SmartScopedLock<true> Guard(*SignalsMutex);
+    std::string *OldPtr =
+        FilesToRemove->empty() ? nullptr : &(*FilesToRemove)[0];
+    FilesToRemove->push_back(Filename);
 
     // We want to call 'c_str()' on every std::string in this vector so that if
     // the underlying implementation requires a re-allocation, it happens here
     // rather than inside of the signal handler. If we see the vector grow, we
     // have to call it on every entry. If it remains in place, we only need to
     // call it on the latest one.
-    if (OldPtr == &FilesToRemove[0])
-      FilesToRemove.back().c_str();
+    if (OldPtr == &(*FilesToRemove)[0])
+      FilesToRemove->back().c_str();
     else
-      for (unsigned i = 0, e = FilesToRemove.size(); i != e; ++i)
-        FilesToRemove[i].c_str();
+      for (unsigned i = 0, e = FilesToRemove->size(); i != e; ++i)
+        (*FilesToRemove)[i].c_str();
   }
 
   RegisterHandlers();
   return false;
 }
 
 // DontRemoveFileOnSignal - The public API
 void llvm::sys::DontRemoveFileOnSignal(StringRef Filename) {
-  sys::SmartScopedLock<true> Guard(SignalsMutex);
+  sys::SmartScopedLock<true> Guard(*SignalsMutex);
   std::vector<std::string>::reverse_iterator RI =
-    std::find(FilesToRemove.rbegin(), FilesToRemove.rend(), Filename);
-  std::vector<std::string>::iterator I = FilesToRemove.end();
-  if (RI != FilesToRemove.rend())
-    I = FilesToRemove.erase(RI.base()-1);
+    std::find(FilesToRemove->rbegin(), FilesToRemove->rend(), Filename);
+  std::vector<std::string>::iterator I = FilesToRemove->end();
+  if (RI != FilesToRemove->rend())
+    I = FilesToRemove->erase(RI.base()-1);
 
   // We need to call c_str() on every element which would have been moved by
   // the erase. These elements, in a C++98 implementation where c_str()
   // requires a reallocation on the first call may have had the call to c_str()
   // made on insertion become invalid by being copied down an element.
-  for (std::vector<std::string>::iterator E = FilesToRemove.end(); I != E; ++I)
+  for (std::vector<std::string>::iterator E = FilesToRemove->end(); I != E; ++I)
     I->c_str();
 }
 
 /// AddSignalHandler - Add a function to be called when a signal is delivered
 /// to the process.  The handler can have a cookie passed to it to identify
 /// what instance of the handler it is.
 void llvm::sys::AddSignalHandler(void (*FnPtr)(void *), void *Cookie) {
-  CallBacksToRun.push_back(std::make_pair(FnPtr, Cookie));
+  CallBacksToRun->push_back(std::make_pair(FnPtr, Cookie));
   RegisterHandlers();
 }
 
 
 // PrintStackTrace - In the case of a program crash or fault, print out a stack
 // trace so that the user has an indication of why and where we died.
 //
 // On glibc systems we have the 'backtrace' function, which works nicely, but