Index: lib/Fuzzer/FuzzerDriver.cpp
===================================================================
--- lib/Fuzzer/FuzzerDriver.cpp
+++ lib/Fuzzer/FuzzerDriver.cpp
@@ -462,14 +462,24 @@
 
   StartRssThread(F, Flags.rss_limit_mb);
 
-  Options.HandleAbrt = Flags.handle_abrt;
-  Options.HandleBus = Flags.handle_bus;
-  Options.HandleFpe = Flags.handle_fpe;
-  Options.HandleIll = Flags.handle_ill;
-  Options.HandleInt = Flags.handle_int;
-  Options.HandleSegv = Flags.handle_segv;
-  Options.HandleTerm = Flags.handle_term;
-  SetSignalHandler(Options);
+  HandlerOptions HandlerOpt;
+  if (Flags.handle_abrt)
+    HandlerOpt.HandlerAbrt = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_bus)
+    HandlerOpt.HandlerBus = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_fpe)
+    HandlerOpt.HandlerFpe = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_ill)
+    HandlerOpt.HandlerIll = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_int)
+    HandlerOpt.HandlerInt = Fuzzer::StaticInterruptCallback;
+  if (Flags.handle_segv)
+    HandlerOpt.HandlerSegv = Fuzzer::StaticCrashSignalCallback;
+  if (Flags.handle_term)
+    HandlerOpt.HandlerTerm = Fuzzer::StaticInterruptCallback;
+  SetSignalHandler(HandlerOpt);
+
+  SetTimer(Options.UnitTimeoutSec / 2 + 1, Fuzzer::StaticAlarmCallback);
 
   if (Flags.minimize_crash_internal_step)
     return MinimizeCrashInputInternalStep(F, Corpus);
Index: lib/Fuzzer/FuzzerOptions.h
===================================================================
--- lib/Fuzzer/FuzzerOptions.h
+++ lib/Fuzzer/FuzzerOptions.h
@@ -53,13 +53,6 @@
   bool PrintCoverage = false;
   bool DetectLeaks = true;
   int  TraceMalloc = 0;
-  bool HandleAbrt = false;
-  bool HandleBus = false;
-  bool HandleFpe = false;
-  bool HandleIll = false;
-  bool HandleInt = false;
-  bool HandleSegv = false;
-  bool HandleTerm = false;
 };
 
 }  // namespace fuzzer
Index: lib/Fuzzer/Support/Util.h
===================================================================
--- lib/Fuzzer/Support/Util.h
+++ lib/Fuzzer/Support/Util.h
@@ -36,7 +36,20 @@
   return CloneArgsWithoutX(Args, X, X);
 }
 
-void SetSignalHandler(const FuzzingOptions& Options);
+struct HandlerOptions {
+  typedef void (*CB)(void);
+  CB HandlerAbrt = nullptr;
+  CB HandlerBus = nullptr;
+  CB HandlerFpe = nullptr;
+  CB HandlerIll = nullptr;
+  CB HandlerInt = nullptr;
+  CB HandlerSegv = nullptr;
+  CB HandlerTerm = nullptr;
+};
+
+void SetSignalHandler(const HandlerOptions& Options);
+
+void SetTimer(int Seconds, void (*Cb)(void));
 
 void SleepSeconds(int Seconds);
 
Index: lib/Fuzzer/Support/UtilPosix.cpp
===================================================================
--- lib/Fuzzer/Support/UtilPosix.cpp
+++ lib/Fuzzer/Support/UtilPosix.cpp
@@ -28,17 +28,7 @@
 
 namespace fuzzer {
 
-static void AlarmHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticAlarmCallback();
-}
-
-static void CrashHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticCrashSignalCallback();
-}
-
-static void InterruptHandler(int, siginfo_t *, void *) {
-  Fuzzer::StaticInterruptCallback();
-}
+static HandlerOptions HandlerOpt;
 
 static void SetSigaction(int signum,
                          void (*callback)(int, siginfo_t *, void *)) {
@@ -51,7 +41,10 @@
   }
 }
 
-void SetTimer(int Seconds) {
+static void (*AlarmCB)(void) = nullptr;
+
+void SetTimer(int Seconds, void (*Cb)(void)) {
+  AlarmCB = Cb;
   struct itimerval T {
     {Seconds, 0}, { Seconds, 0 }
   };
@@ -59,26 +52,25 @@
     Printf("libFuzzer: setitimer failed with %d\n", errno);
     exit(1);
   }
-  SetSigaction(SIGALRM, AlarmHandler);
+  SetSigaction(SIGALRM, [](int, siginfo_t *, void *) {AlarmCB();});
 }
 
 void SetSignalHandler(const FuzzingOptions& Options) {
-  if (Options.UnitTimeoutSec > 0)
-    SetTimer(Options.UnitTimeoutSec / 2 + 1);
-  if (Options.HandleInt)
-    SetSigaction(SIGINT, InterruptHandler);
-  if (Options.HandleTerm)
-    SetSigaction(SIGTERM, InterruptHandler);
-  if (Options.HandleSegv)
-    SetSigaction(SIGSEGV, CrashHandler);
-  if (Options.HandleBus)
-    SetSigaction(SIGBUS, CrashHandler);
-  if (Options.HandleAbrt)
-    SetSigaction(SIGABRT, CrashHandler);
-  if (Options.HandleIll)
-    SetSigaction(SIGILL, CrashHandler);
-  if (Options.HandleFpe)
-    SetSigaction(SIGFPE, CrashHandler);
+  HandlerOpt = Options;
+  if (Options.HandlerInt)
+    SetSigaction(SIGINT, [](int,siginfo_t*,void*){HandlerOpt.HandlerInt()});
+  if (Options.HandlerTerm)
+    SetSigaction(SIGTERM, [](int,siginfo_t*,void*){HandlerOpt.HandlerTerm()});
+  if (Options.HandlerSegv)
+    SetSigaction(SIGSEGV, [](int,siginfo_t*,void*){HandlerOpt.HandlerSegv()});
+  if (Options.HandlerBus)
+    SetSigaction(SIGBUS, [](int,siginfo_t*,void*){HandlerOpt.HandlerBus()});
+  if (Options.HandlerAbrt)
+    SetSigaction(SIGABRT, [](int,siginfo_t*,void*){HandlerOpt.HandlerAbrt()});
+  if (Options.HandlerIll)
+    SetSigaction(SIGILL, [](int,siginfo_t*,void*){HandlerOpt.HandlerIll()});
+  if (Options.HandlerFpe)
+    SetSigaction(SIGFPE, [](int,siginfo_t*,void*){HandlerOpt.HandlerFpe()});
 }
 
 void SleepSeconds(int Seconds) {
Index: lib/Fuzzer/Support/UtilWindows.cpp
===================================================================
--- lib/Fuzzer/Support/UtilWindows.cpp
+++ lib/Fuzzer/Support/UtilWindows.cpp
@@ -10,6 +10,7 @@
 //===----------------------------------------------------------------------===//
 #include "Platform.h"
 #if LIBFUZZER_WINDOWS
+#include "Util.h"
 #include "UtilIO.h"
 #include <cassert>
 #include <chrono>
@@ -25,25 +26,25 @@
 
 namespace fuzzer {
 
-static const FuzzingOptions* HandlerOpt = nullptr;
+static HandlerOptions HandlerOpt;
 
 LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo) {
   switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
     case EXCEPTION_ACCESS_VIOLATION:
     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
     case EXCEPTION_STACK_OVERFLOW:
-      if (HandlerOpt->HandleSegv)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerSegv)
+        HandlerOpt.HandlerSegv();
       break;
     case EXCEPTION_DATATYPE_MISALIGNMENT:
     case EXCEPTION_IN_PAGE_ERROR:
-      if (HandlerOpt->HandleBus)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerBus)
+        HandlerOpt.HandlerBus();
       break;
     case EXCEPTION_ILLEGAL_INSTRUCTION:
     case EXCEPTION_PRIV_INSTRUCTION:
-      if (HandlerOpt->HandleIll)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerIll)
+        HandlerOpt.HandlerIll();
       break;
     case EXCEPTION_FLT_DENORMAL_OPERAND:
     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
@@ -54,8 +55,8 @@
     case EXCEPTION_FLT_UNDERFLOW:
     case EXCEPTION_INT_DIVIDE_BY_ZERO:
     case EXCEPTION_INT_OVERFLOW:
-      if (HandlerOpt->HandleFpe)
-        Fuzzer::StaticCrashSignalCallback();
+      if (HandlerOpt.HandlerFpe)
+        HandlerOpt.HandlerFpe();
       break;
   }
   return EXCEPTION_CONTINUE_SEARCH;
@@ -64,19 +65,21 @@
 BOOL WINAPI CtrlHandler(DWORD dwCtrlType) {
   switch (dwCtrlType) {
     case CTRL_C_EVENT:
-      if (HandlerOpt->HandleInt)
-        Fuzzer::StaticInterruptCallback();
+      if (HandlerOpt.HandlerInt)
+        HandlerOpt.HandlerInt();
       return TRUE;
     case CTRL_BREAK_EVENT:
-      if (HandlerOpt->HandleTerm)
-        Fuzzer::StaticInterruptCallback();
+      if (HandlerOpt.HandlerTerm)
+        HandlerOpt.HandlerTerm();
       return TRUE;
   }
   return FALSE;
 }
 
+static void (*AlarmCB)(void) = nullptr;
 void CALLBACK AlarmHandler(PVOID, BOOLEAN) {
-  Fuzzer::StaticAlarmCallback();
+  if (AlarmCB)
+    AlarmCB();
 }
 
 class TimerQ {
@@ -106,15 +109,20 @@
 
 static TimerQ Timer;
 
-static void CrashHandler(int) { Fuzzer::StaticCrashSignalCallback(); }
+static void AbrtHandler(int) {
+  if (HandlerOpt.HandlerAbrt)
+    HandlerOpt.HandlerAbrt();
+}
 
-void SetSignalHandler(const FuzzingOptions& Options) {
-  HandlerOpt = &Options;
+void SetTimer(int Seconds, void (*Cb)(void)) {
+  AlarmCB = Cb;
+  Timer.SetTimer(Seconds);
+}
 
-  if (Options.UnitTimeoutSec > 0)
-    Timer.SetTimer(Options.UnitTimeoutSec / 2 + 1);
+void SetSignalHandler(const HandlerOptions& Options) {
+  HandlerOpt = Options;
 
-  if (Options.HandleInt || Options.HandleTerm)
+  if (Options.HandlerInt || Options.HandlerTerm)
     if (!SetConsoleCtrlHandler(CtrlHandler, TRUE)) {
       DWORD LastError = GetLastError();
       Printf("libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu).\n",
@@ -122,15 +130,15 @@
       exit(1);
     }
 
-  if (Options.HandleSegv || Options.HandleBus || Options.HandleIll ||
-      Options.HandleFpe)
+  if (Options.HandlerSegv || Options.HandlerBus || Options.HandlerIll ||
+      Options.HandlerFpe)
     if (!AddVectoredExceptionHandler(1, ExceptionHandler)) {
       Printf("libFuzzer: AddVectoredExceptionHandler failed.\n");
       exit(1);
     }
 
-  if (Options.HandleAbrt)
-    if (SIG_ERR == signal(SIGABRT, CrashHandler)) {
+  if (Options.HandlerAbrt)
+    if (SIG_ERR == signal(SIGABRT, AbrtHandler)) {
       Printf("libFuzzer: signal failed with %d\n", errno);
       exit(1);
     }