[asan] Rename allow_user_segv_handler into allow_user_sig_handler

[vitalybuka]

Summary

allow_user_segv_handler already controls various signals, not just SEGV

[eugenis]

This will break all the users.

[vitalybuka]

In D32444#735907, @eugenis wrote:

This will break all the users.

Usually it used to set it to true, but after https://reviews.llvm.org/D32443 it would not be necessary.

[eugenis]

If the default value is changed to true, I guess I'm fine with this. Never liked this flag anyway.
Kostya, WDYT?

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) ||
-      common_flags()->allow_user_segv_handler) {
+      common_flags()->allow_user_signal_handler) {
     return REAL(bsd_signal)(signum, handler);
   }
   return 0;
 }
 #endif
 
 INTERCEPTOR(void*, signal, int signum, void *handler) {
   if (!IsHandledDeadlySignal(signum) ||
-      common_flags()->allow_user_segv_handler) {
+      common_flags()->allow_user_signal_handler) {
     return REAL(signal)(signum, handler);
   }
   return nullptr;
 }
 
 INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
                             struct sigaction *oldact) {
   if (!IsHandledDeadlySignal(signum) ||
-      common_flags()->allow_user_segv_handler) {
+      common_flags()->allow_user_signal_handler) {
     return REAL(sigaction)(signum, act, oldact);
   }
   return 0;
 }
 
 namespace __sanitizer {
 int real_sigaction(int signum, const void *act, void *oldact) {
   return REAL(sigaction)(signum, (const struct sigaction *)act,

lib/asan/asan_win.cc

static long WINAPI SEHHandler(EXCEPTION_POINTERS *info) {
   if (default_seh_handler)
     return default_seh_handler(info);
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
 INTERCEPTOR_WINAPI(LPTOP_LEVEL_EXCEPTION_FILTER, SetUnhandledExceptionFilter,
     LPTOP_LEVEL_EXCEPTION_FILTER ExceptionFilter) {
   CHECK(REAL(SetUnhandledExceptionFilter));
-  if (ExceptionFilter == &SEHHandler || common_flags()->allow_user_segv_handler)
+  if (ExceptionFilter == &SEHHandler ||
+      common_flags()->allow_user_signal_handler) {
     return REAL(SetUnhandledExceptionFilter)(ExceptionFilter);
+  }
   // We record the user provided exception handler to be called for all the
   // exceptions unhandled by asan.
   Swap(ExceptionFilter, user_seh_handler);
   return ExceptionFilter;
 }
 
 INTERCEPTOR_WINAPI(void, RtlRaiseException, EXCEPTION_RECORD *ExceptionRecord) {
   CHECK(REAL(RtlRaiseException));

lib/sanitizer_common/sanitizer_flags.inc

 COMMON_FLAG(bool, handle_sigbus, true,
             "If set, registers the tool's custom SIGBUS handler.")
 COMMON_FLAG(bool, handle_abort, false,
             "If set, registers the tool's custom SIGABRT handler.")
 COMMON_FLAG(bool, handle_sigill, false,
             "If set, registers the tool's custom SIGILL handler.")
 COMMON_FLAG(bool, handle_sigfpe, true,
             "If set, registers the tool's custom SIGFPE handler.")
-COMMON_FLAG(bool, allow_user_segv_handler, true,
-            "If set, allows user to register a SEGV handler even if the tool "
+COMMON_FLAG(bool, allow_user_signal_handler, true,
+            "If set, allows user to register a signal handler even if the tool "
             "registers one.")
 COMMON_FLAG(bool, use_sigaltstack, true,
             "If set, uses alternate stack for signal handling.")
 COMMON_FLAG(bool, detect_deadlocks, false,
             "If set, deadlock detection is enabled.")
 COMMON_FLAG(
     uptr, clear_shadow_mmap_threshold, 64 * 1024,
     "Large shadow regions are zero-filled using mmap(NORESERVE) instead of "

test/asan/TestCases/Posix/allow_user_segv.cc

 // Regression test for
 // https://code.google.com/p/address-sanitizer/issues/detail?id=180
 
-// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=allow_user_signal_handler=true not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=allow_user_signal_handler=true not %run %t 2>&1 | FileCheck %s
 
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 struct sigaction original_sigaction_sigbus;
 struct sigaction original_sigaction_sigsegv;
 

test/sanitizer_common/TestCases/Linux/signal_segv_handler.cc

-// RUN: %clangxx -O1 %s -o %t && TSAN_OPTIONS="flush_memory_ms=1 memory_limit_mb=1" ASAN_OPTIONS="handle_segv=0 allow_user_segv_handler=1" %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -O1 %s -o %t && TSAN_OPTIONS="flush_memory_ms=1 memory_limit_mb=1" ASAN_OPTIONS="handle_segv=0 allow_user_signal_handler=1" %run %t 2>&1 | FileCheck %s
 
 // JVM uses SEGV to preempt threads. All threads do a load from a known address
 // periodically. When runtime needs to preempt threads, it unmaps the page.
 // Threads start triggering SEGV one by one. The signal handler blocks
 // threads while runtime does its thing. Then runtime maps the page again
 // and resumes the threads.
 // Previously this pattern conflicted with stop-the-world machinery,
 // because it briefly reset SEGV handler to SIG_DFL.