[lldb] Refactor CrashReason

[DavidSpickett]

Summary

So that there is only one function that NativeThreads call,
which takes a siginfo. Everything else is an internal detail.

[DavidSpickett]

Or in other words "make it look like UnixSignals on the inside".

[JDevlieghere]

LGTM

[mysterymath]

Hey, it looks like the reland of this is causing issues with the Fuchsia toolchain build: https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8786444992328058977/overview
Seems that it's only legal to call AppendBounds if you first check for the definition of si_lower and si_upper, since these guard the definition of AppendBounds.

lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.cpp

void NativeThreadFreeBSD::SetStoppedBySignal(uint32_t signo,
 
   m_stop_description.clear();
   if (info) {
     switch (signo) {
     case SIGSEGV:
     case SIGBUS:
     case SIGFPE:
     case SIGILL:
-      const auto reason = GetCrashReason(*info);
-      m_stop_description = GetCrashReasonString(reason, *info);
+      m_stop_description = GetCrashReasonString(*info);
       break;
     }
   }
 }
 
 void NativeThreadFreeBSD::SetStoppedByBreakpoint() {
   SetStopped();
   m_stop_info.reason = StopReason::eStopReasonBreakpoint;

lldb/source/Plugins/Process/Linux/NativeThreadLinux.h

private:
   // Private interface
   void MaybeLogStateChange(lldb::StateType new_state);
 
   void SetStopped();
 
   /// Extend m_stop_description with logical and allocation tag values.
   /// If there is an error along the way just add the information we were able
   /// to get.
-  void AnnotateSyncTagCheckFault(const siginfo_t *info);
+  void AnnotateSyncTagCheckFault(lldb::addr_t fault_addr);
 
   // Member Variables
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
   std::unique_ptr<NativeRegisterContextLinux> m_reg_context_up;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
   WatchpointIndexMap m_hw_break_index_map;
   std::unique_ptr<SingleStepWorkaround> m_step_workaround;
 };
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

void NativeThreadLinux::SetStoppedBySignal(uint32_t signo,
 
   m_stop_description.clear();
   if (info) {
     switch (signo) {
     case SIGSEGV:
     case SIGBUS:
     case SIGFPE:
     case SIGILL:
-      const auto reason = GetCrashReason(*info);
-      m_stop_description = GetCrashReasonString(reason, *info);
-
-      if (reason == CrashReason::eSyncTagCheckFault) {
-        AnnotateSyncTagCheckFault(info);
-      }
-
+      m_stop_description = GetCrashReasonString(*info);
+#ifndef SEGV_MTESERR
+#define SEGV_MTESERR 9
+#endif
+      if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTESERR)
+        AnnotateSyncTagCheckFault(
+            reinterpret_cast<lldb::addr_t>(info->si_addr));
       break;
     }
   }
 }
 
-void NativeThreadLinux::AnnotateSyncTagCheckFault(const siginfo_t *info) {
+void NativeThreadLinux::AnnotateSyncTagCheckFault(lldb::addr_t fault_addr) {
   int32_t allocation_tag_type = 0;
   switch (GetProcess().GetArchitecture().GetMachine()) {
   // aarch64_32 deliberately not here because there's no 32 bit MTE
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
     allocation_tag_type = MemoryTagManagerAArch64MTE::eMTE_allocation;
     break;
   default:
     return;
   }
 
   auto details =
       GetRegisterContext().GetMemoryTaggingDetails(allocation_tag_type);
   if (!details) {
     llvm::consumeError(details.takeError());
     return;
   }
 
   // We assume that the stop description is currently:
   // signal SIGSEGV: sync tag check fault (fault address: <addr>)
   // Remove the closing )
   m_stop_description.pop_back();
 
   std::stringstream ss;
-  lldb::addr_t fault_addr = reinterpret_cast<uintptr_t>(info->si_addr);
   std::unique_ptr<MemoryTagManager> manager(std::move(details->manager));
 
   ss << " logical tag: 0x" << std::hex << manager->GetLogicalTag(fault_addr);
 
   std::vector<uint8_t> allocation_tag_data;
   // The fault address may not be granule aligned. ReadMemoryTags will granule
   // align any range you give it, potentially making it larger.
   // To prevent this set len to 1. This always results in a range that is at

lldb/source/Plugins/Process/NetBSD/NativeThreadNetBSD.cpp

void NativeThreadNetBSD::SetStoppedBySignal(uint32_t signo,
 
   m_stop_description.clear();
   if (info) {
     switch (signo) {
     case SIGSEGV:
     case SIGBUS:
     case SIGFPE:
     case SIGILL:
-      const auto reason = GetCrashReason(*info);
-      m_stop_description = GetCrashReasonString(reason, *info);
+      m_stop_description = GetCrashReasonString(*info);
       break;
     }
   }
 }
 
 void NativeThreadNetBSD::SetStoppedByBreakpoint() {
   SetStopped();
   m_stop_info.reason = StopReason::eStopReasonBreakpoint;

lldb/source/Plugins/Process/POSIX/CrashReason.h

 #define liblldb_CrashReason_H_
 
 #include "lldb/lldb-types.h"
 
 #include <csignal>
 
 #include <string>
 
-enum class CrashReason {
-  eInvalidCrashReason,
-
-  // SIGSEGV crash reasons.
-  eInvalidAddress,
-  ePrivilegedAddress,
-  eBoundViolation,
-  eAsyncTagCheckFault,
-  eSyncTagCheckFault,
-
-  // SIGILL crash reasons.
-  eIllegalOpcode,
-  eIllegalOperand,
-  eIllegalAddressingMode,
-  eIllegalTrap,
-  ePrivilegedOpcode,
-  ePrivilegedRegister,
-  eCoprocessorError,
-  eInternalStackError,
-
-  // SIGBUS crash reasons,
-  eIllegalAlignment,
-  eIllegalAddress,
-  eHardwareError,
-
-  // SIGFPE crash reasons,
-  eIntegerDivideByZero,
-  eIntegerOverflow,
-  eFloatDivideByZero,
-  eFloatOverflow,
-  eFloatUnderflow,
-  eFloatInexactResult,
-  eFloatInvalidOperation,
-  eFloatSubscriptRange
-};
-
-std::string GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr);
-std::string GetCrashReasonString(CrashReason reason, const siginfo_t &info);
-
-CrashReason GetCrashReason(const siginfo_t &info);
+std::string GetCrashReasonString(const siginfo_t &info);
 
 #endif // #ifndef liblldb_CrashReason_H_

lldb/source/Plugins/Process/POSIX/CrashReason.cpp

 //===-- CrashReason.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CrashReason.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 #include <sstream>
 
+enum class CrashReason {
+  eInvalidCrashReason,
+
+  // SIGSEGV crash reasons.
+  eInvalidAddress,
+  ePrivilegedAddress,
+  eBoundViolation,
+  eAsyncTagCheckFault,
+  eSyncTagCheckFault,
+
+  // SIGILL crash reasons.
+  eIllegalOpcode,
+  eIllegalOperand,
+  eIllegalAddressingMode,
+  eIllegalTrap,
+  ePrivilegedOpcode,
+  ePrivilegedRegister,
+  eCoprocessorError,
+  eInternalStackError,
+
+  // SIGBUS crash reasons,
+  eIllegalAlignment,
+  eIllegalAddress,
+  eHardwareError,
+
+  // SIGFPE crash reasons,
+  eIntegerDivideByZero,
+  eIntegerOverflow,
+  eFloatDivideByZero,
+  eFloatOverflow,
+  eFloatUnderflow,
+  eFloatInexactResult,
+  eFloatInvalidOperation,
+  eFloatSubscriptRange
+};
+
 static void AppendFaultAddr(std::string &str, lldb::addr_t addr) {
   std::stringstream ss;
   ss << " (fault address: 0x" << std::hex << addr << ")";
   str += ss.str();
 }
 
 #if defined(si_lower) && defined(si_upper)
 static void AppendBounds(std::string &str, lldb::addr_t lower_bound,
static void AppendBounds(std::string &str, lldb::addr_t lower_bound,
   stream.write_hex(lower_bound);
   stream << ", upper bound: 0x";
   stream.write_hex(upper_bound);
   stream << ")";
   stream.flush();
 }
 #endif
 
-static CrashReason GetCrashReasonForSIGSEGV(const siginfo_t &info) {
-  assert(info.si_signo == SIGSEGV);
-
-  switch (info.si_code) {
+static CrashReason GetCrashReasonForSIGSEGV(int code) {
+  switch (code) {
 #ifdef SI_KERNEL
   case SI_KERNEL:
     // Some platforms will occasionally send nonstandard spurious SI_KERNEL
     // codes. One way to get this is via unaligned SIMD loads.
     return CrashReason::eInvalidAddress; // for lack of anything better
 #endif
   case SEGV_MAPERR:
     return CrashReason::eInvalidAddress;
#endif
   case SEGV_MTESERR:
     return CrashReason::eSyncTagCheckFault;
 #endif // __linux__
   }
 
   return CrashReason::eInvalidCrashReason;
 }
 
-static CrashReason GetCrashReasonForSIGILL(const siginfo_t &info) {
-  assert(info.si_signo == SIGILL);
-
-  switch (info.si_code) {
+static CrashReason GetCrashReasonForSIGILL(int code) {
+  switch (code) {
   case ILL_ILLOPC:
     return CrashReason::eIllegalOpcode;
   case ILL_ILLOPN:
     return CrashReason::eIllegalOperand;
   case ILL_ILLADR:
     return CrashReason::eIllegalAddressingMode;
   case ILL_ILLTRP:
     return CrashReason::eIllegalTrap;
   case ILL_PRVOPC:
     return CrashReason::ePrivilegedOpcode;
   case ILL_PRVREG:
     return CrashReason::ePrivilegedRegister;
   case ILL_COPROC:
     return CrashReason::eCoprocessorError;
   case ILL_BADSTK:
     return CrashReason::eInternalStackError;
   }
 
   return CrashReason::eInvalidCrashReason;
 }
 
-static CrashReason GetCrashReasonForSIGFPE(const siginfo_t &info) {
-  assert(info.si_signo == SIGFPE);
-
-  switch (info.si_code) {
+static CrashReason GetCrashReasonForSIGFPE(int code) {
+  switch (code) {
   case FPE_INTDIV:
     return CrashReason::eIntegerDivideByZero;
   case FPE_INTOVF:
     return CrashReason::eIntegerOverflow;
   case FPE_FLTDIV:
     return CrashReason::eFloatDivideByZero;
   case FPE_FLTOVF:
     return CrashReason::eFloatOverflow;
   case FPE_FLTUND:
     return CrashReason::eFloatUnderflow;
   case FPE_FLTRES:
     return CrashReason::eFloatInexactResult;
   case FPE_FLTINV:
     return CrashReason::eFloatInvalidOperation;
   case FPE_FLTSUB:
     return CrashReason::eFloatSubscriptRange;
   }
 
   return CrashReason::eInvalidCrashReason;
 }
 
-static CrashReason GetCrashReasonForSIGBUS(const siginfo_t &info) {
-  assert(info.si_signo == SIGBUS);
-
-  switch (info.si_code) {
+static CrashReason GetCrashReasonForSIGBUS(int code) {
+  switch (code) {
   case BUS_ADRALN:
     return CrashReason::eIllegalAlignment;
   case BUS_ADRERR:
     return CrashReason::eIllegalAddress;
   case BUS_OBJERR:
     return CrashReason::eHardwareError;
   }
 
   return CrashReason::eInvalidCrashReason;
 }
 
-std::string GetCrashReasonString(CrashReason reason, const siginfo_t &info) {
-  std::string str;
-
-// make sure that siginfo_t has the bound fields available.
-#if defined(si_lower) && defined(si_upper)
-  if (reason == CrashReason::eBoundViolation) {
-    str = "signal SIGSEGV";
-    AppendBounds(str, reinterpret_cast<uintptr_t>(info.si_lower),
-                 reinterpret_cast<uintptr_t>(info.si_upper),
-                 reinterpret_cast<uintptr_t>(info.si_addr));
-    return str;
-  }
-#endif
-
-  return GetCrashReasonString(reason,
-                              reinterpret_cast<uintptr_t>(info.si_addr));
-}
-
-std::string GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr) {
+static std::string GetCrashReasonString(CrashReason reason,
+                                        lldb::addr_t fault_addr) {
   std::string str;
 
   switch (reason) {
   default:
     str = "unknown crash reason";
     break;
 
   case CrashReason::eInvalidAddress:
static std::string GetCrashReasonString(CrashReason reason,
   case CrashReason::eFloatSubscriptRange:
     str = "signal SIGFPE: invalid floating point subscript range";
     break;
   }
 
   return str;
 }
 
-CrashReason GetCrashReason(const siginfo_t &info) {
-  switch (info.si_signo) {
+static CrashReason GetCrashReason(int signo, int code) {
+  switch (signo) {
   case SIGSEGV:
-    return GetCrashReasonForSIGSEGV(info);
+    return GetCrashReasonForSIGSEGV(code);
   case SIGBUS:
-    return GetCrashReasonForSIGBUS(info);
+    return GetCrashReasonForSIGBUS(code);
   case SIGFPE:
-    return GetCrashReasonForSIGFPE(info);
+    return GetCrashReasonForSIGFPE(code);
   case SIGILL:
-    return GetCrashReasonForSIGILL(info);
+    return GetCrashReasonForSIGILL(code);
   }
 
   assert(false && "unexpected signal");
   return CrashReason::eInvalidCrashReason;
 }
+
+static std::string GetCrashReasonString(int signo, int code, lldb::addr_t addr,
+                                        std::optional<lldb::addr_t> lower,
+                                        std::optional<lldb::addr_t> upper) {
+  CrashReason reason = GetCrashReason(signo, code);
+
+  if (lower && upper) {
+    std::string str;
+    if (reason == CrashReason::eBoundViolation) {
+      str = "signal SIGSEGV";
+      AppendBounds(str, reinterpret_cast<uintptr_t>(*lower),
+                   reinterpret_cast<uintptr_t>(*upper),
+                   reinterpret_cast<uintptr_t>(addr));
+      return str;
+    }
+  }
+
+  return GetCrashReasonString(reason, addr);
+}
+
+std::string GetCrashReasonString(const siginfo_t &info) {
+#if defined(si_lower) && defined(si_upper)
+  std::optional<lldb::addr_t> lower =
+      reinterpret_cast<lldb::addr_t>(info.si_lower);
+  std::optional<lldb::addr_t> upper =
+      reinterpret_cast<lldb::addr_t>(info.si_upper);
+#else
+  std::optional<lldb::addr_t> lower;
+  std::optional<lldb::addr_t> upper;
+#endif
+  return GetCrashReasonString(info.si_signo, info.si_code,
+                              reinterpret_cast<uintptr_t>(info.si_addr), lower,
+                              upper);
+}