[asan] Remove ErrorStackOverflow

[vitalybuka]

Summary

The only difference from ErrorDeadlySignal is reporting code and it lives in
sanitizer common.

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

compiler-rt/trunk/lib/asan/asan_errors.h

 
 struct ErrorBase {
   ErrorBase() = default;
   explicit ErrorBase(u32 tid_) : tid(tid_) {}
   ScarinessScoreBase scariness;
   u32 tid;
 };
 
-struct ErrorStackOverflow : ErrorBase {
-  SignalContext signal;
-  // VS2013 doesn't implement unrestricted unions, so we need a trivial default
-  // constructor
-  ErrorStackOverflow() = default;
-  ErrorStackOverflow(u32 tid, const SignalContext &sig)
-      : ErrorBase(tid), signal(sig) {
-    scariness.Clear();
-    scariness.Scare(10, "stack-overflow");
-  }
-  void Print();
-};
-
 struct ErrorDeadlySignal : ErrorBase {
   SignalContext signal;
   // VS2013 doesn't implement unrestricted unions, so we need a trivial default
   // constructor
   ErrorDeadlySignal() = default;
   ErrorDeadlySignal(u32 tid, const SignalContext &sig)
       : ErrorBase(tid), signal(sig) {
     scariness.Clear();
-    if (signal.is_memory_access) {
-      if (signal.addr < GetPageSizeCached()) {
-        scariness.Scare(10, "null-deref");
-      } else if (signal.addr == signal.pc) {
-        scariness.Scare(60, "wild-jump");
-      } else if (signal.write_flag == SignalContext::WRITE) {
-        scariness.Scare(30, "wild-addr-write");
-      } else if (signal.write_flag == SignalContext::READ) {
-        scariness.Scare(20, "wild-addr-read");
-      } else {
-        scariness.Scare(25, "wild-addr");
-      }
-    } else {
-      scariness.Scare(10, "signal");
-    }
+    if (signal.IsStackOverflow()) {
+      scariness.Scare(10, "stack-overflow");
+    } else if (!signal.is_memory_access) {
+      scariness.Scare(10, "signal");
+    } else if (signal.addr < GetPageSizeCached()) {
   }
   void Print();
 };
 
 struct ErrorDoubleFree : ErrorBase {
   // ErrorDoubleFree doesn't own the stack trace.
   const BufferedStackTrace *second_free_stack;
   HeapAddressDescription addr_description;
struct ErrorGeneric : ErrorBase {
   ErrorGeneric() = default;
   ErrorGeneric(u32 tid, uptr addr, uptr pc_, uptr bp_, uptr sp_, bool is_write_,
                uptr access_size_);
   void Print();
 };
 
 // clang-format off
 #define ASAN_FOR_EACH_ERROR_KIND(macro)         \
-  macro(StackOverflow)                          \
   macro(DeadlySignal)                           \
   macro(DoubleFree)                             \
   macro(NewDeleteSizeMismatch)                  \
   macro(FreeNotMalloced)                        \
   macro(AllocTypeMismatch)                      \
   macro(MallocUsableSizeNotOwned)               \
   macro(SanitizerGetAllocatedSizeNotOwned)      \
   macro(StringFunctionMemoryRangesOverlap)      \

compiler-rt/trunk/lib/asan/asan_errors.cc

 #include "asan_descriptions.h"
 #include "asan_mapping.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 
 namespace __asan {
 
-void ErrorStackOverflow::Print() {
+void ErrorDeadlySignal::Print() {
+  if (signal.IsStackOverflow()) {
     Decorator d;
     Printf("%s", d.Warning());
     Report(
         "ERROR: AddressSanitizer: %s on address %p"
         " (pc %p bp %p sp %p T%d)\n",
         scariness.GetDescription(), (void *)signal.addr, (void *)signal.pc,
         (void *)signal.bp, (void *)signal.sp, tid);
     Printf("%s", d.Default());
     scariness.Print();
     BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, signal.pc, signal.bp,
-                                  signal.context,
+    GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, signal.pc,
+                                    signal.bp, signal.context,
                                     common_flags()->fast_unwind_on_fatal);
     stack.Print();
     ReportErrorSummary(scariness.GetDescription(), &stack);
-}
-
-void ErrorDeadlySignal::Print() {
+  } else {
     Decorator d;
     Printf("%s", d.Warning());
     const char *description = signal.Describe();
     Report(
         "ERROR: AddressSanitizer: %s on unknown address %p (pc %p bp %p sp %p "
         "T%d)\n",
         description, (void *)signal.addr, (void *)signal.pc, (void *)signal.bp,
         (void *)signal.sp, tid);
     Printf("%s", d.Default());
     if (signal.pc < GetPageSizeCached())
       Report("Hint: pc points to the zero page.\n");
     if (signal.is_memory_access) {
       const char *access_type =
           signal.write_flag == SignalContext::WRITE
               ? "WRITE"
               : (signal.write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
       Report("The signal is caused by a %s memory access.\n", access_type);
       if (signal.addr < GetPageSizeCached())
         Report("Hint: address points to the zero page.\n");
     }
     MaybeReportNonExecRegion(signal.pc);
     scariness.Print();
     BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, signal.pc, signal.bp,
-                                  signal.context,
+    GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, signal.pc,
+                                    signal.bp, signal.context,
                                     common_flags()->fast_unwind_on_fatal);
     stack.Print();
     MaybeDumpInstructionBytes(signal.pc);
     MaybeDumpRegisters(signal.context);
     Printf("AddressSanitizer can not provide additional info.\n");
     ReportErrorSummary(description, &stack);
   }
+}
 
 void ErrorDoubleFree::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];
   Report(
       "ERROR: AddressSanitizer: attempting %s on %p in "
       "thread T%d%s:\n",

compiler-rt/trunk/lib/asan/asan_posix.cc

 #include <unistd.h>
 
 namespace __asan {
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   ScopedDeadlySignal signal_scope(GetCurrentThread());
   StartReportDeadlySignal();
   SignalContext sig(siginfo, context);
-  if (sig.IsStackOverflow())
-    ReportStackOverflow(sig);
-  else
-    ReportDeadlySignal(sig);
 }
 
 // ---------------------- TSD ---------------- {{{1
 
 static pthread_key_t tsd_key;
 static bool tsd_key_inited = false;
 void AsanTSDInit(void (*destructor)(void *tsd)) {
   CHECK(!tsd_key_inited);

compiler-rt/trunk/lib/asan/asan_report.h

 // The following functions prints address description depending
 // on the memory type (shadow/heap/stack/global).
 bool ParseFrameDescription(const char *frame_descr,
                            InternalMmapVector<StackVarDescr> *vars);
 
 // Different kinds of error reports.
 void ReportGenericError(uptr pc, uptr bp, uptr sp, uptr addr, bool is_write,
                         uptr access_size, u32 exp, bool fatal);
-void ReportStackOverflow(const SignalContext &sig);
 void ReportDeadlySignal(const SignalContext &sig);
 void ReportNewDeleteSizeMismatch(uptr addr, uptr delete_size,
                                  BufferedStackTrace *free_stack);
 void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack);
 void ReportFreeNotMalloced(uptr addr, BufferedStackTrace *free_stack);
 void ReportAllocTypeMismatch(uptr addr, BufferedStackTrace *free_stack,
                              AllocType alloc_type,
                              AllocType dealloc_type);

compiler-rt/trunk/lib/asan/asan_report.cc

private:
   static ErrorDescription current_error_;
   bool halt_on_error_;
 };
 
 StaticSpinMutex ScopedInErrorReport::lock_;
 u32 ScopedInErrorReport::reporting_thread_tid_ = kInvalidTid;
 ErrorDescription ScopedInErrorReport::current_error_;
 
-void ReportStackOverflow(const SignalContext &sig) {
-  ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorStackOverflow error(GetCurrentTidOrInvalid(), sig);
-  in_report.ReportError(error);
-}
-
 void ReportDeadlySignal(const SignalContext &sig) {
   ScopedInErrorReport in_report(/*fatal*/ true);
   ErrorDeadlySignal error(GetCurrentTidOrInvalid(), sig);
   in_report.ReportError(error);
 }
 
 void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;