[compiler-rt] Replace "bool IsHandledDeadlySignal" with "int GetHandleDeadlySignal"

[eugenis]

lib/sanitizer_common/sanitizer_linux.cc

1397

If you insist on a tri-state flag, this must be an enum.
With validation in the flag parser (in the other CL).

lib/asan/asan_interceptors.cc

 
 DEFINE_REAL_PTHREAD_FUNCTIONS
 #endif  // ASAN_INTERCEPT_PTHREAD_CREATE
 
 #if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION
 
 #if SANITIZER_ANDROID
 INTERCEPTOR(void*, bsd_signal, int signum, void *handler) {
-  if (!IsHandledDeadlySignal(signum) ||
+  if (!GetHandleDeadlySignal(signum) ||
       common_flags()->allow_user_segv_handler) {
     return REAL(bsd_signal)(signum, handler);
   }
   return 0;
 }
 #endif
 
 INTERCEPTOR(void*, signal, int signum, void *handler) {
-  if (!IsHandledDeadlySignal(signum) ||
+  if (!GetHandleDeadlySignal(signum) ||
       common_flags()->allow_user_segv_handler) {
     return REAL(signal)(signum, handler);
   }
   return nullptr;
 }
 
 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
                             struct sigaction *oldact) {
-  if (!IsHandledDeadlySignal(signum) ||
+  if (!GetHandleDeadlySignal(signum) ||
       common_flags()->allow_user_segv_handler) {
     return REAL(sigaction)(signum, act, oldact);
   }
   return 0;
 }
 
 namespace __sanitizer {
 int real_sigaction(int signum, const void *act, void *oldact) {

lib/sanitizer_common/sanitizer_common.h

 // Callback will be called if soft_rss_limit_mb is given and the limit is
 // exceeded (exceeded==true) or if rss went down below the limit
 // (exceeded==false).
 // The callback should be registered once at the tool init time.
 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded));
 
 // Functions related to signal handling.
 typedef void (*SignalHandlerType)(int, void *, void *);
-bool IsHandledDeadlySignal(int signum);
+int GetHandleDeadlySignal(int signum);
 void InstallDeadlySignalHandlers(SignalHandlerType handler);
 const char *DescribeSignalOrException(int signo);
 // Alternative signal stack (POSIX-only).
 void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
 
 // We don't want a summary too long.
 const int kMaxSummaryLength = 1024;

lib/sanitizer_common/sanitizer_linux.cc

AndroidApiLevel AndroidGetApiLevel() {
   if (level) return level;
   level = AndroidDetectApiLevel();
   atomic_store(&android_api_level, level, memory_order_relaxed);
   return level;
 }
 
 #endif
 
-bool IsHandledDeadlySignal(int signum) {
+int GetHandleDeadlySignal(int signum) {
   switch (signum) {
     case SIGABRT:
       return common_flags()->handle_abort;
     case SIGILL:
       return common_flags()->handle_sigill;
     case SIGFPE:
       return common_flags()->handle_sigfpe;
     case SIGSEGV:
       return common_flags()->handle_segv;
     case SIGBUS:
       return common_flags()->handle_sigbus;
   }
-  return false;
+  return 0;
 }
 
 #if !SANITIZER_GO
 void *internal_start_thread(void(*func)(void *arg), void *arg) {
   // Start the thread with signals blocked, otherwise it can steal user signals.
   __sanitizer_sigset_t set, old;
   internal_sigfillset(&set);
 #if SANITIZER_LINUX && !SANITIZER_ANDROID

lib/sanitizer_common/sanitizer_mac.cc

 }
 
 void ListOfModules::init() {
   clear();
   MemoryMappingLayout memory_mapping(false);
   memory_mapping.DumpListOfModules(&modules_);
 }
 
-bool IsHandledDeadlySignal(int signum) {
+int GetHandleDeadlySignal(int signum) {
   if ((SANITIZER_WATCHOS || SANITIZER_TVOS) && !(SANITIZER_IOSSIM)) {
     // Handling fatal signals on watchOS and tvOS devices is disallowed.
     return false;
   }
   switch (signum) {
     case SIGABRT:
       return common_flags()->handle_abort;
     case SIGILL:
       return common_flags()->handle_sigill;
     case SIGFPE:
       return common_flags()->handle_sigfpe;
     case SIGSEGV:
       return common_flags()->handle_segv;
     case SIGBUS:
       return common_flags()->handle_sigbus;
   }
-  return false;
+  return 0;
 }
 
 MacosVersion cached_macos_version = MACOS_VERSION_UNINITIALIZED;
 
 MacosVersion GetMacosVersionInternal() {
   int mib[2] = { CTL_KERN, KERN_OSRELEASE };
   char version[100];
   uptr len = 0, maxlen = sizeof(version) / sizeof(version[0]);

lib/sanitizer_common/sanitizer_posix_libcdep.cc

 
 void SleepForMillis(int millis) {
   usleep(millis * 1000);
 }
 
 void Abort() {
 #if !SANITIZER_GO
   // If we are handling SIGABRT, unhandle it first.
-  if (IsHandledDeadlySignal(SIGABRT)) {
+  if (GetHandleDeadlySignal(SIGABRT)) {
     struct sigaction sigact;
     internal_memset(&sigact, 0, sizeof(sigact));
     sigact.sa_sigaction = (sa_sigaction_t)SIG_DFL;
     internal_sigaction(SIGABRT, &sigact, nullptr);
   }
 #endif
 
   abort();
void UnsetAlternateSignalStack() {
   altstack.ss_flags = SS_DISABLE;
   altstack.ss_size = kAltStackSize;  // Some sane value required on Darwin.
   CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
   UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
 }
 
 static void MaybeInstallSigaction(int signum,
                                   SignalHandlerType handler) {
-  if (!IsHandledDeadlySignal(signum))
-    return;
+  if (!GetHandleDeadlySignal(signum)) return;
   struct sigaction sigact;
   if (common_flags()->allow_user_segv_handler) {
     internal_memset(&sigact, 0, sizeof(sigact));
     CHECK_EQ(0, internal_sigaction(signum, nullptr, &sigact));
     if (sigact.sa_flags & SA_SIGINFO) {
       if (sigact.sa_sigaction) return;
     } else {
       if (sigact.sa_handler != SIG_DFL && sigact.sa_handler != SIG_IGN &&

lib/sanitizer_common/sanitizer_win.cc

void UnsetAlternateSignalStack() {
   // FIXME: Decide what to do on Windows.
 }
 
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   (void)handler;
   // FIXME: Decide what to do on Windows.
 }
 
-bool IsHandledDeadlySignal(int signum) {
+int GetHandleDeadlySignal(int signum) {
   // FIXME: Decide what to do on Windows.
-  return false;
+  return 0;
 }
 
 // Check based on flags if we should handle this exception.
 bool IsHandledDeadlyException(DWORD exceptionCode) {
   switch (exceptionCode) {
     case EXCEPTION_ACCESS_VIOLATION:
     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
     case EXCEPTION_STACK_OVERFLOW: