[compiler-rt] Add siginfo into SignalContext

[vitalybuka]

Summary

Information stored there is often been passed along with SignalContext.

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

[vitalybuka]

undo unneeded change

[alekseyshl]

compiler-rt/lib/sanitizer_common/sanitizer_common.h

799

We never own or outlive those two pointers, right? Can you add a comment explaining that to the ctor?

808–811

Make it private.

828

Then let's call it GetType() or GetSignalType()

[vitalybuka]

rename and comment about ownership

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common.h

808–811

I'd like to replace static create with regular constructor, but in new patch. So I'd keep it as is for now.

compiler-rt/lib/asan/asan_errors.h

struct ErrorDeadlySignal : ErrorBase {
   // ErrorDeadlySignal never owns the context.
   void *context;
   int signo;
   SignalContext::WriteFlag write_flag;
   bool is_memory_access;
   // VS2013 doesn't implement unrestricted unions, so we need a trivial default
   // constructor
   ErrorDeadlySignal() = default;
-  ErrorDeadlySignal(u32 tid, const SignalContext &sig, int signo_)
+  ErrorDeadlySignal(u32 tid, const SignalContext &sig)
       : ErrorBase(tid),
         addr(sig.addr),
         pc(sig.pc),
         bp(sig.bp),
         sp(sig.sp),
         context(sig.context),
-        signo(signo_),
+        signo(sig.Get()),
         write_flag(sig.write_flag),
         is_memory_access(sig.is_memory_access) {
     scariness.Clear();
     if (is_memory_access) {
       if (addr < GetPageSizeCached()) {
         scariness.Scare(10, "null-deref");
       } else if (addr == pc) {
         scariness.Scare(60, "wild-jump");

compiler-rt/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 = SignalContext::Create(siginfo, context);
-  if (IsStackOverflow(((siginfo_t *)siginfo)->si_code, sig))
+  if (IsStackOverflow(sig))
     ReportStackOverflow(sig);
   else
-    ReportDeadlySignal(signo, sig);
+    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/lib/asan/asan_report.h

 // 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(int signo, 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);
 void ReportMallocUsableSizeNotOwned(uptr addr, BufferedStackTrace *stack);

compiler-rt/lib/asan/asan_report.cc

 ErrorDescription ScopedInErrorReport::current_error_;
 
 void ReportStackOverflow(const SignalContext &sig) {
   ScopedInErrorReport in_report(/*fatal*/ true);
   ErrorStackOverflow error(GetCurrentTidOrInvalid(), sig);
   in_report.ReportError(error);
 }
 
-void ReportDeadlySignal(int signo, const SignalContext &sig) {
+void ReportDeadlySignal(const SignalContext &sig) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorDeadlySignal error(GetCurrentTidOrInvalid(), sig, signo);
+  ErrorDeadlySignal error(GetCurrentTidOrInvalid(), sig);
   in_report.ReportError(error);
 }
 
 void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
   ErrorDoubleFree error(GetCurrentTidOrInvalid(), free_stack, addr);
   in_report.ReportError(error);
 }

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 
 // 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(int code, const SignalContext &sig);
+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).
 void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
 

 #if defined(_MSC_VER) && !defined(__clang__)
   _ReadWriteBarrier();
 #else
   __asm__ __volatile__("" : : "r" (arg) : "memory");
 #endif
 }
 
 struct SignalContext {
+  void *siginfo;
   void *context;
   uptr addr;
   uptr pc;
   uptr sp;
   uptr bp;
   bool is_memory_access;
 
   enum WriteFlag { UNKNOWN, READ, WRITE } write_flag;
 
-  SignalContext(void *context, uptr addr, uptr pc, uptr sp, uptr bp,
-                bool is_memory_access, WriteFlag write_flag)
-      : context(context),
+  SignalContext(void *siginfo, void *context, uptr addr, uptr pc, uptr sp,
+                uptr bp, bool is_memory_access, WriteFlag write_flag)
+      : siginfo(siginfo),
+        context(context),
         addr(addr),
         pc(pc),
         sp(sp),
         bp(bp),
         is_memory_access(is_memory_access),
         write_flag(write_flag) {}
 
   static void DumpAllRegisters(void *context);
 
   // Creates signal context in a platform-specific manner.
   static SignalContext Create(void *siginfo, void *context);
 
   // 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()); }
 };
 
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
 
 void MaybeReexec();
 
 template <typename Fn>
 class RunOnDestruction {

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

if (segment.IsExecutable() &&
       *end = segment.end;
       return true;
     }
   }
   return false;
 }
 
 SignalContext SignalContext::Create(void *siginfo, void *context) {
-  auto si = (siginfo_t *)siginfo;
+  auto si = static_cast<const siginfo_t *>(siginfo);
   uptr addr = (uptr)si->si_addr;
   uptr pc, sp, bp;
   GetPcSpBp(context, &pc, &sp, &bp);
   WriteFlag write_flag = GetWriteFlag(context);
   bool is_memory_access = si->si_signo == SIGSEGV;
-  return SignalContext(context, addr, pc, sp, bp, is_memory_access, write_flag);
+  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) {
     case SIGFPE:
       return "FPE";
     case SIGILL:
       return "ILL";

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
   MaybeInstallSigaction(SIGSEGV, handler);
   MaybeInstallSigaction(SIGBUS, handler);
   MaybeInstallSigaction(SIGABRT, handler);
   MaybeInstallSigaction(SIGFPE, handler);
   MaybeInstallSigaction(SIGILL, handler);
 }
 
-bool IsStackOverflow(int code, const SignalContext &sig) {
+bool IsStackOverflow(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 =
if (ra == 1 &&
          (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);
+  auto si = static_cast<const siginfo_t *>(sig.siginfo);
+  return IsStackAccess &&
+         (si->si_code == si_SEGV_MAPERR || si->si_code == si_SEGV_ACCERR);
 }
 
 void StartReportDeadlySignal() {
   // Write the first message using fd=2, just in case.
   // It may actually fail to write in case stderr is closed.
   internal_write(2, SanitizerToolName, internal_strlen(SanitizerToolName));
   static const char kDeadlySignal[] = ":DEADLYSIGNAL\n";
   internal_write(2, kDeadlySignal, sizeof(kDeadlySignal) - 1);

compiler-rt/lib/sanitizer_common/sanitizer_win.cc

#endif
   // second element is the faulting address.
   WriteFlag write_flag = SignalContext::UNKNOWN;
   switch (exception_record->ExceptionInformation[0]) {
   case 0: write_flag = SignalContext::READ; break;
   case 1: write_flag = SignalContext::WRITE; break;
   case 8: write_flag = SignalContext::UNKNOWN; break;
   }
   bool is_memory_access = write_flag != SignalContext::UNKNOWN;
-  return SignalContext(context, access_addr, pc, sp, bp, is_memory_access,
-                       write_flag);
+  return SignalContext(siginfo, context, access_addr, pc, sp, bp,
+                       is_memory_access, write_flag);
 }
 
 void SignalContext::DumpAllRegisters(void *context) {
   // FIXME: Implement this.
 }
 
+int SignalContext::Get() const {
+  return static_cast<const EXCEPTION_RECORD *>(siginfo)->ExceptionCode;
+}
+
 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) {

compiler-rt/test/sanitizer_common/TestCases/Posix/dump_instruction_bytes.cc

 // Check that sanitizer prints the faulting instruction bytes on
 // dump_instruction_bytes=1
 // RUN: %clangxx  %s -o %t
 // RUN: %env_tool_opts=dump_instruction_bytes=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-DUMP
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NODUMP
-//
+
 // REQUIRES: x86-target-arch
 // XFAIL: lsan, msan, tsan, ubsan
 
 int main() {
 #if defined(__x86_64__)
   asm("movq $0, %rax");
   asm("movl $0xcafebabe, 0x0(%rax)");
 #elif defined(i386)
   asm("movl $0, %eax");
   asm("movl $0xcafebabe, 0x0(%eax)");
 #endif
   // CHECK-DUMP: First 16 instruction bytes at pc: c7 00 be ba fe ca
   // CHECK-NODUMP-NOT: First 16 instruction bytes
   return 0;
 }