[compiler-rt] Use SignalContext in ErrorStackOverflow and ErrorDeadlySignal

[vitalybuka]

Summary

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

[alekseyshl]

compiler-rt/lib/asan/asan_errors.h

31

Can you rename it to 'signal'?

[vitalybuka]

Renamed sig to signal

compiler-rt/lib/asan/asan_errors.h

 struct ErrorBase {
   ErrorBase() = default;
   explicit ErrorBase(u32 tid_) : tid(tid_) {}
   ScarinessScoreBase scariness;
   u32 tid;
 };
 
 struct ErrorStackOverflow : ErrorBase {
-  uptr addr, pc, bp, sp;
-  // ErrorStackOverflow never owns the context.
-  void *context;
+  SignalContext sig;
   // VS2013 doesn't implement unrestricted unions, so we need a trivial default
   // constructor
   ErrorStackOverflow() = default;
   ErrorStackOverflow(u32 tid, const SignalContext &sig)
-      : ErrorBase(tid),
-        addr(sig.addr),
-        pc(sig.pc),
-        bp(sig.bp),
-        sp(sig.sp),
-        context(sig.context) {
+      : ErrorBase(tid), sig(sig) {
     scariness.Clear();
     scariness.Scare(10, "stack-overflow");
   }
   void Print();
 };
 
 struct ErrorDeadlySignal : ErrorBase {
-  uptr addr, pc, bp, sp;
-  // ErrorDeadlySignal never owns the context.
-  void *context;
-  int signo;
-  SignalContext::WriteFlag write_flag;
-  bool is_memory_access;
+  SignalContext sig;
   // VS2013 doesn't implement unrestricted unions, so we need a trivial default
   // constructor
   ErrorDeadlySignal() = default;
   ErrorDeadlySignal(u32 tid, const SignalContext &sig)
-      : ErrorBase(tid),
-        addr(sig.addr),
-        pc(sig.pc),
-        bp(sig.bp),
-        sp(sig.sp),
-        context(sig.context),
-        signo(sig.Get()),
-        write_flag(sig.write_flag),
-        is_memory_access(sig.is_memory_access) {
+      : ErrorBase(tid), sig(sig) {
     scariness.Clear();
-    if (is_memory_access) {
-      if (addr < GetPageSizeCached()) {
+    if (sig.is_memory_access) {
+      if (sig.addr < GetPageSizeCached()) {
         scariness.Scare(10, "null-deref");
-      } else if (addr == pc) {
+      } else if (sig.addr == sig.pc) {
         scariness.Scare(60, "wild-jump");
-      } else if (write_flag == SignalContext::WRITE) {
+      } else if (sig.write_flag == SignalContext::WRITE) {
         scariness.Scare(30, "wild-addr-write");
-      } else if (write_flag == SignalContext::READ) {
+      } else if (sig.write_flag == SignalContext::READ) {
         scariness.Scare(20, "wild-addr-read");
       } else {
         scariness.Scare(25, "wild-addr");
       }
     } else {
       scariness.Scare(10, "signal");
     }
   }

compiler-rt/lib/asan/asan_errors.cc

 
 namespace __asan {
 
 void ErrorStackOverflow::Print() {
   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 *)addr, (void *)pc, (void *)bp, (void *)sp, tid);
+      " (pc %p bp %p sp %p T%d)\n",
+      scariness.GetDescription(), (void *)sig.addr, (void *)sig.pc,
+      (void *)sig.bp, (void *)sig.sp, tid);
   Printf("%s", d.Default());
   scariness.Print();
   BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, context,
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, sig.pc, sig.bp,
+                                  sig.context,
                                   common_flags()->fast_unwind_on_fatal);
   stack.Print();
   ReportErrorSummary(scariness.GetDescription(), &stack);
 }
 
 void ErrorDeadlySignal::Print() {
   Decorator d;
   Printf("%s", d.Warning());
-  const char *description = __sanitizer::DescribeSignalOrException(signo);
+  const char *description = sig.Describe();
   Report(
       "ERROR: AddressSanitizer: %s on unknown address %p (pc %p bp %p sp %p "
       "T%d)\n",
-      description, (void *)addr, (void *)pc, (void *)bp, (void *)sp, tid);
+      description, (void *)sig.addr, (void *)sig.pc, (void *)sig.bp,
+      (void *)sig.sp, tid);
   Printf("%s", d.Default());
-  if (pc < GetPageSizeCached()) Report("Hint: pc points to the zero page.\n");
-  if (is_memory_access) {
+  if (sig.pc < GetPageSizeCached())
+    Report("Hint: pc points to the zero page.\n");
+  if (sig.is_memory_access) {
     const char *access_type =
-        write_flag == SignalContext::WRITE
+        sig.write_flag == SignalContext::WRITE
             ? "WRITE"
-            : (write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
+            : (sig.write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
     Report("The signal is caused by a %s memory access.\n", access_type);
-    if (addr < GetPageSizeCached())
+    if (sig.addr < GetPageSizeCached())
       Report("Hint: address points to the zero page.\n");
   }
-  MaybeReportNonExecRegion(pc);
+  MaybeReportNonExecRegion(sig.pc);
   scariness.Print();
   BufferedStackTrace stack;
-  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, context,
+  GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, sig.pc, sig.bp,
+                                  sig.context,
                                   common_flags()->fast_unwind_on_fatal);
   stack.Print();
-  MaybeDumpInstructionBytes(pc);
-  MaybeDumpRegisters(context);
+  MaybeDumpInstructionBytes(sig.pc);
+  MaybeDumpRegisters(sig.context);
   Printf("AddressSanitizer can not provide additional info.\n");
   ReportErrorSummary(description, &stack);
 }
 
 void ErrorDoubleFree::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 // (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);
 void InstallDeadlySignalHandlers(SignalHandlerType handler);
-const char *DescribeSignalOrException(int signo);
 // Signal reporting.
 void StartReportDeadlySignal();
 bool IsStackOverflow(const SignalContext &sig);
 // FIXME: Hide after moving more signal handling code into common.
 void MaybeReportNonExecRegion(uptr pc);
 void MaybeDumpInstructionBytes(uptr pc);
 void MaybeDumpRegisters(void *context);
 // Alternative signal stack (POSIX-only).
struct SignalContext {
 
   // Returns true if the "context" indicates a memory write.
   static WriteFlag GetWriteFlag(void *context);
 
   // Type of signal e.g. SIGSEGV or EXCEPTION_ACCESS_VIOLATION.
   int Get() const;
 
   // String description of the signal.
-  const char *Describe() const { return DescribeSignalOrException(Get()); }
+  const char *Describe() const;
 };
 
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
 
 void MaybeReexec();
 
 template <typename Fn>
 class RunOnDestruction {

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

 void InstallDeadlySignalHandlers(SignalHandlerType handler) {}
 void SetAlternateSignalStack() {}
 void UnsetAlternateSignalStack() {}
 void InitTlsSize() {}
 
 void PrintModuleMap() {}
 
 void SignalContext::DumpAllRegisters(void *context) { UNIMPLEMENTED(); }
-const char *DescribeSignalOrException(int signo) { UNIMPLEMENTED(); }
+const char *SignalContext::Describe() const { UNIMPLEMENTED(); }
 
 struct UnwindTraceArg {
   BufferedStackTrace *stack;
   u32 max_depth;
 };
 
 _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
   UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

SignalContext SignalContext::Create(void *siginfo, void *context) {
   return SignalContext(siginfo, context, addr, pc, sp, bp, is_memory_access,
                        write_flag);
 }
 
 int SignalContext::Get() const {
   return static_cast<const siginfo_t *>(siginfo)->si_signo;
 }
 
-const char *DescribeSignalOrException(int signo) {
-  switch (signo) {
+const char *SignalContext::Describe() const {
+  switch (Get()) {
     case SIGFPE:
       return "FPE";
     case SIGILL:
       return "ILL";
     case SIGABRT:
       return "ABRT";
     case SIGSEGV:
       return "SEGV";

compiler-rt/lib/sanitizer_common/sanitizer_win.cc

switch (exceptionCode) {
     case EXCEPTION_FLT_UNDERFLOW:
     case EXCEPTION_INT_DIVIDE_BY_ZERO:
     case EXCEPTION_INT_OVERFLOW:
       return common_flags()->handle_sigfpe;
   }
   return false;
 }
 
-const char *DescribeSignalOrException(int signo) {
-  unsigned code = signo;
-  // Get the string description of the exception if this is a known deadly
-  // exception.
-  switch (code) {
-    case EXCEPTION_ACCESS_VIOLATION: return "access-violation";
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return "array-bounds-exceeded";
-    case EXCEPTION_STACK_OVERFLOW: return "stack-overflow";
-    case EXCEPTION_DATATYPE_MISALIGNMENT: return "datatype-misalignment";
-    case EXCEPTION_IN_PAGE_ERROR: return "in-page-error";
-    case EXCEPTION_ILLEGAL_INSTRUCTION: return "illegal-instruction";
-    case EXCEPTION_PRIV_INSTRUCTION: return "priv-instruction";
-    case EXCEPTION_BREAKPOINT: return "breakpoint";
-    case EXCEPTION_FLT_DENORMAL_OPERAND: return "flt-denormal-operand";
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "flt-divide-by-zero";
-    case EXCEPTION_FLT_INEXACT_RESULT: return "flt-inexact-result";
-    case EXCEPTION_FLT_INVALID_OPERATION: return "flt-invalid-operation";
-    case EXCEPTION_FLT_OVERFLOW: return "flt-overflow";
-    case EXCEPTION_FLT_STACK_CHECK: return "flt-stack-check";
-    case EXCEPTION_FLT_UNDERFLOW: return "flt-underflow";
-    case EXCEPTION_INT_DIVIDE_BY_ZERO: return "int-divide-by-zero";
-    case EXCEPTION_INT_OVERFLOW: return "int-overflow";
-  }
-  return "unknown exception";
-}
-
 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   SYSTEM_INFO si;
   GetNativeSystemInfo(&si);
   uptr page_size = si.dwPageSize;
   uptr page_mask = ~(page_size - 1);
 
   for (uptr page = beg & page_mask, end = (beg + size - 1) & page_mask;
        page <= end;) {

 void SignalContext::DumpAllRegisters(void *context) {
   // FIXME: Implement this.
 }
 
 int SignalContext::Get() const {
   return static_cast<const EXCEPTION_RECORD *>(siginfo)->ExceptionCode;
 }
 
+const char *SignalContext::Describe() const {
+  unsigned code = signo;
+  // Get the string description of the exception if this is a known deadly
+  // exception.
+  switch (code) {
+    case EXCEPTION_ACCESS_VIOLATION:
+      return "access-violation";
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+      return "array-bounds-exceeded";
+    case EXCEPTION_STACK_OVERFLOW:
+      return "stack-overflow";
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+      return "datatype-misalignment";
+    case EXCEPTION_IN_PAGE_ERROR:
+      return "in-page-error";
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+      return "illegal-instruction";
+    case EXCEPTION_PRIV_INSTRUCTION:
+      return "priv-instruction";
+    case EXCEPTION_BREAKPOINT:
+      return "breakpoint";
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+      return "flt-denormal-operand";
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+      return "flt-divide-by-zero";
+    case EXCEPTION_FLT_INEXACT_RESULT:
+      return "flt-inexact-result";
+    case EXCEPTION_FLT_INVALID_OPERATION:
+      return "flt-invalid-operation";
+    case EXCEPTION_FLT_OVERFLOW:
+      return "flt-overflow";
+    case EXCEPTION_FLT_STACK_CHECK:
+      return "flt-stack-check";
+    case EXCEPTION_FLT_UNDERFLOW:
+      return "flt-underflow";
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      return "int-divide-by-zero";
+    case EXCEPTION_INT_OVERFLOW:
+      return "int-overflow";
+  }
+  return "unknown exception";
+}
+
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
   // FIXME: Actually implement this function.
   CHECK_GT(buf_len, 0);
   buf[0] = 0;
   return 0;
 }
 
 uptr ReadLongProcessName(/*out*/char *buf, uptr buf_len) {