From b8931c1cf4075d9d79ad2ae44dadc3d3d1d29568 Mon Sep 17 00:00:00 2001
From: JF Bastien <jfb@google.com>
Date: Wed, 16 May 2018 04:36:37 +0000
Subject: Revert "Signal handling should be signal-safe"

Some bots don't have double-pointer width compare-and-exchange. Revert for now.q

llvm-svn: 332429
---
 llvm/lib/Support/Signals.cpp | 47 +++++++++++---------------------------------
 1 file changed, 12 insertions(+), 35 deletions(-)

(limited to 'llvm/lib/Support/Signals.cpp')

diff --git a/llvm/lib/Support/Signals.cpp b/llvm/lib/Support/Signals.cpp
index 6270a9bbef5..414619bc3c9 100644
--- a/llvm/lib/Support/Signals.cpp
+++ b/llvm/lib/Support/Signals.cpp
@@ -36,42 +36,19 @@
 
 using namespace llvm;
 
-// Use explicit storage to avoid accessing cl::opt in a signal handler.
-static bool DisableSymbolicationFlag = false;
-static cl::opt<bool, true>
+static cl::opt<bool>
     DisableSymbolication("disable-symbolication",
                          cl::desc("Disable symbolizing crash backtraces."),
-                         cl::location(DisableSymbolicationFlag), cl::Hidden);
-
-// Callbacks to run in signal handler must be lock-free because a signal handler
-// could be running as we add new callbacks. We don't add unbounded numbers of
-// callbacks, an array is therefore sufficient.
-// Assume two pointers are always lock-free.
-struct LLVM_ALIGNAS(sizeof(void *) * 2) CallbackAndCookie {
-  sys::SignalHandlerCallback Callback;
-  void *Cookie;
-};
-static constexpr size_t MaxSignalHandlerCallbacks = 8;
-static std::atomic<CallbackAndCookie> CallBacksToRun[MaxSignalHandlerCallbacks];
-
-void sys::RunSignalHandlers() { // Signal-safe.
-  for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) {
-    CallbackAndCookie DoNothing{nullptr, nullptr};
-    auto Entry = CallBacksToRun[I].exchange(DoNothing);
-    if (Entry.Callback)
-      (*Entry.Callback)(Entry.Cookie);
-  }
-}
-
-static void insertSignalHandler(sys::SignalHandlerCallback FnPtr,
-                                void *Cookie) { // Signal-safe.
-  CallbackAndCookie Entry = CallbackAndCookie{FnPtr, Cookie};
-  for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) {
-    CallbackAndCookie Expected{nullptr, nullptr};
-    if (CallBacksToRun[I].compare_exchange_strong(Expected, Entry))
-      return;
-  }
-  llvm_unreachable("too many signal callbacks already registered");
+                         cl::init(false), cl::Hidden);
+
+static ManagedStatic<std::vector<std::pair<void (*)(void *), void *>>>
+    CallBacksToRun;
+void sys::RunSignalHandlers() {
+  if (!CallBacksToRun.isConstructed())
+    return;
+  for (auto &I : *CallBacksToRun)
+    I.first(I.second);
+  CallBacksToRun->clear();
 }
 
 static bool findModulesAndOffsets(void **StackTrace, int Depth,
@@ -91,7 +68,7 @@ static FormattedNumber format_ptr(void *PC) {
 LLVM_ATTRIBUTE_USED
 static bool printSymbolizedStackTrace(StringRef Argv0, void **StackTrace,
                                       int Depth, llvm::raw_ostream &OS) {
-  if (DisableSymbolicationFlag)
+  if (DisableSymbolication)
     return false;
 
   // Don't recursively invoke the llvm-symbolizer binary.
-- 
cgit v1.2.3