[compiler-rt] Move IsStackOverflow from asan into sanitizer_common

[vitalybuka]

Summary

Part of https://github.com/google/sanitizers/issues/637

[alekseyshl]

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

324

What about this #if?

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

218

Looks like an unnecessary change

compiler-rt/lib/tsan/go/buildgo.sh

48

What prompted it?

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

324

#if allows to aviid sanitizer_platform_limits_posix.cc in lib/tsan/go/buildgo.sh

compiler-rt/lib/tsan/go/buildgo.sh

48

IsStackOverflow needs some constants from the file.
I don't like #ifs in the code, but maybe safer just to keep them instead of new file here.
What would be your preference here?

[vitalybuka]

use #ifs instead of new cc files

[alekseyshl]

compiler-rt/lib/tsan/go/buildgo.sh

48

Well, if we need IsStackOverflow in Go mode, we have to add this file, if we do not need IsStackOverflow (and, maybe, some other functions from sanitizer_posix.cc), we should split it out into a separate file and do not link it here.

[vitalybuka]

Rebase

compiler-rt/lib/asan/asan_posix.cc

 #include <sys/time.h>
 #include <sys/resource.h>
 #include <unistd.h>
 
 namespace __asan {
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   ScopedDeadlySignal signal_scope(GetCurrentThread());
-  int code = (int)((siginfo_t*)siginfo)->si_code;
   // Write the first message using fd=2, just in case.
   // It may actually fail to write in case stderr is closed.
   internal_write(2, "ASAN:DEADLYSIGNAL\n", 18);
   SignalContext sig = SignalContext::Create(siginfo, context);
-
-  // Access at a reasonable offset above SP, or slightly below it (to account
-  // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is
-  // probably a stack overflow.
-#ifdef __s390__
-  // On s390, the fault address in siginfo points to start of the page, not
-  // to the precise word that was accessed.  Mask off the low bits of sp to
-  // take it into account.
-  bool IsStackAccess = sig.addr >= (sig.sp & ~0xFFF) &&
-                       sig.addr < sig.sp + 0xFFFF;
-#else
-  bool IsStackAccess = sig.addr + 512 > sig.sp && sig.addr < sig.sp + 0xFFFF;
-#endif
-
-#if __powerpc__
-  // Large stack frames can be allocated with e.g.
-  //   lis r0,-10000
-  //   stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000
-  // If the store faults then sp will not have been updated, so test above
-  // will not work, because the fault address will be more than just "slightly"
-  // below sp.
-  if (!IsStackAccess && IsAccessibleMemoryRange(sig.pc, 4)) {
-    u32 inst = *(unsigned *)sig.pc;
-    u32 ra = (inst >> 16) & 0x1F;
-    u32 opcd = inst >> 26;
-    u32 xo = (inst >> 1) & 0x3FF;
-    // Check for store-with-update to sp. The instructions we accept are:
-    //   stbu rs,d(ra)          stbux rs,ra,rb
-    //   sthu rs,d(ra)          sthux rs,ra,rb
-    //   stwu rs,d(ra)          stwux rs,ra,rb
-    //   stdu rs,ds(ra)         stdux rs,ra,rb
-    // where ra is r1 (the stack pointer).
-    if (ra == 1 &&
-        (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 ||
-         (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181))))
-      IsStackAccess = true;
-  }
-#endif // __powerpc__
-
-  // We also check si_code to filter out SEGV caused by something else other
-  // then hitting the guard page or unmapped memory, like, for example,
-  // unaligned memory access.
-  if (IsStackAccess && (code == si_SEGV_MAPERR || code == si_SEGV_ACCERR))
+  if (IsStackOverflow(((siginfo_t *)siginfo)->si_code, sig))
     ReportStackOverflow(sig);
   else
     ReportDeadlySignal(signo, sig);
 }
 
 // ---------------------- TSD ---------------- {{{1
 
 static pthread_key_t tsd_key;

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 // 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 *);
 HandleSignalMode GetHandleSignalMode(int signum);
+bool IsStackOverflow(int code, const struct SignalContext &sig);
 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;

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

switch (signo) {
     case SIGSEGV:
       return "SEGV";
     case SIGBUS:
       return "BUS";
   }
   return "UNKNOWN SIGNAL";
 }
 
+//#if !SANITIZER_GO
+bool IsStackOverflow(int code, const SignalContext &sig) {
+  // Access at a reasonable offset above SP, or slightly below it (to account
+  // for x86_64 or PowerPC redzone, ARM push of multiple registers, etc) is
+  // probably a stack overflow.
+#ifdef __s390__
+  // On s390, the fault address in siginfo points to start of the page, not
+  // to the precise word that was accessed.  Mask off the low bits of sp to
+  // take it into account.
+  bool IsStackAccess =
+      sig.addr >= (sig.sp & ~0xFFF) && sig.addr < sig.sp + 0xFFFF;
+#else
+  bool IsStackAccess = sig.addr + 512 > sig.sp && sig.addr < sig.sp + 0xFFFF;
+#endif
+
+#if __powerpc__
+  // Large stack frames can be allocated with e.g.
+  //   lis r0,-10000
+  //   stdux r1,r1,r0 # store sp to [sp-10000] and update sp by -10000
+  // If the store faults then sp will not have been updated, so test above
+  // will not work, because the fault address will be more than just "slightly"
+  // below sp.
+  if (!IsStackAccess && IsAccessibleMemoryRange(sig.pc, 4)) {
+    u32 inst = *(unsigned *)sig.pc;
+    u32 ra = (inst >> 16) & 0x1F;
+    u32 opcd = inst >> 26;
+    u32 xo = (inst >> 1) & 0x3FF;
+    // Check for store-with-update to sp. The instructions we accept are:
+    //   stbu rs,d(ra)          stbux rs,ra,rb
+    //   sthu rs,d(ra)          sthux rs,ra,rb
+    //   stwu rs,d(ra)          stwux rs,ra,rb
+    //   stdu rs,ds(ra)         stdux rs,ra,rb
+    // where ra is r1 (the stack pointer).
+    if (ra == 1 &&
+        (opcd == 39 || opcd == 45 || opcd == 37 || opcd == 62 ||
+         (opcd == 31 && (xo == 247 || xo == 439 || xo == 183 || xo == 181))))
+      IsStackAccess = true;
+  }
+#endif  // __powerpc__
+
+  // We also check si_code to filter out SEGV caused by something else other
+  // then hitting the guard page or unmapped memory, like, for example,
+  // unaligned memory access.
+  return IsStackAccess && (code == si_SEGV_MAPERR || code == si_SEGV_ACCERR);
+}
+//#endif  //!SANITIZER_GO
+
 } // namespace __sanitizer
 
 #endif // SANITIZER_POSIX

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   // will be actually set only once.
   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
   MaybeInstallSigaction(SIGSEGV, handler);
   MaybeInstallSigaction(SIGBUS, handler);
   MaybeInstallSigaction(SIGABRT, handler);
   MaybeInstallSigaction(SIGFPE, handler);
   MaybeInstallSigaction(SIGILL, handler);
 }
+
 #endif  // SANITIZER_GO
 
 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   uptr page_size = GetPageSizeCached();
   // Checking too large memory ranges is slow.
   CHECK_LT(size, page_size * 10);
   int sock_pair[2];
   if (pipe(sock_pair))

compiler-rt/lib/tsan/go/buildgo.sh

 
 if [ "`uname -a | grep Linux`" != "" ]; then
   SUFFIX="linux_amd64"
   OSCFLAGS="-fPIC -ffreestanding -Wno-maybe-uninitialized -Wno-unused-const-variable -Werror -Wno-unknown-warning-option"
   OSLDFLAGS="-lpthread -fPIC -fpie"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_linux.cc
+    ../../sanitizer_common/sanitizer_platform_limits_posix.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_procmaps_linux.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
   "
 elif [ "`uname -a | grep FreeBSD`" != "" ]; then
   SUFFIX="freebsd_amd64"
   OSCFLAGS="-fno-strict-aliasing -fPIC -Werror"
   OSLDFLAGS="-lpthread -fPIC -fpie"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_linux.cc
+    ../../sanitizer_common/sanitizer_platform_limits_posix.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_procmaps_freebsd.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
   "
 elif [ "`uname -a | grep Darwin`" != "" ]; then
   SUFFIX="darwin_amd64"
   OSCFLAGS="-fPIC -Wno-unused-const-variable -Wno-unknown-warning-option -isysroot $(xcodebuild -version -sdk macosx Path) -mmacosx-version-min=10.7"
   OSLDFLAGS="-lpthread -fPIC -fpie -mmacosx-version-min=10.7"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_mac.cc
     ../../sanitizer_common/sanitizer_mac.cc
+    ../../sanitizer_common/sanitizer_platform_limits_posix.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_mac.cc
   "
 elif [ "`uname -a | grep MINGW`" != "" ]; then
   SUFFIX="windows_amd64"
   OSCFLAGS="-Wno-error=attributes -Wno-attributes -Wno-unused-const-variable -Wno-unknown-warning-option"
   OSLDFLAGS=""