[lldb/crashlog] Improve exception reporting for interactive mode

[mib]

Summary

This patch improve exception reporting when loading a crash report in a
scripted process. Now, we parse the exception dictionary from the
crash report use it the create a higher fidelity MachException stop info.

This patch also updates the test to reflect that change.

rdar://97096486

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

527–544

Just double checking: I assume these are always defined, even when mach/exception.h is not included?

569–570

580–612

Seems like a good candidate for a StringSwitch: https://llvm.org/doxygen/classllvm_1_1StringSwitch.html

[mib]

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

527–544

no, I'm getting the following error if I don't include mach/exception.h

llvm.org/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp:525:8: error: use of undeclared identifier 'EXC_BAD_ACCESS'
  case EXC_BAD_ACCESS:
       ^

[mib]

Use llvm::StringSwitch to get the exception code with the name

[mib]

Remove the comment from MachException::ExceptionCode since the function returns now an llvm::Optional

[mib]

Reflect changes from D131719

[JDevlieghere]

LGTM assuming this compiles on non-apple hosts

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

527–544

So doesn't that mean this won't compile on a non-apple platform? Is this whole block APPLE only?

lldb/examples/python/scripted_process/crashlog_scripted_process.py

class CrashLogScriptedProcess(ScriptedProcess):
     def parse_crashlog(self):
         crashlog_parser = CrashLogParser(self.dbg, self.crashlog_path, False)
         crash_log = crashlog_parser.parse()
 
         self.pid = crash_log.process_id
         self.addr_mask = crash_log.addr_mask
         self.crashed_thread_idx = crash_log.crashed_thread_idx
         self.loaded_images = []
+        self.exception = crash_log.exception
 
         def load_images(self, images):
             #TODO: Add to self.loaded_images and load images in lldb
             if images:
                 for image in images:
                     if image not in self.loaded_images:
                         if image.uuid == uuid.UUID(int=0):
                             continue
def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
             if load_all_images.GetType() == lldb.eStructuredDataTypeBoolean:
                 self.load_all_images = load_all_images.GetBooleanValue()
 
         if not self.load_all_images:
             self.load_all_images = False
 
         self.pid = super().get_process_id()
         self.crashed_thread_idx = 0
+        self.exception = None
         self.parse_crashlog()
 
     def get_memory_region_containing_address(self, addr: int) -> lldb.SBMemoryRegionInfo:
         return None
 
     def get_thread_with_id(self, tid: int):
         return {}
 
class CrashLogScriptedThread(ScriptedThread):
 
     def get_state(self):
         if not self.has_crashed:
             return lldb.eStateStopped
         return lldb.eStateCrashed
 
     def get_stop_reason(self) -> Dict[str, Any]:
         if not self.has_crashed:
-            return { "type": lldb.eStopReasonNone, "data": {  }}
+            return { "type": lldb.eStopReasonNone }
         # TODO: Investigate what stop reason should be reported when crashed
-        return { "type": lldb.eStopReasonException, "data": { "desc": "EXC_BAD_ACCESS" }}
+        stop_reason = { "type": lldb.eStopReasonException, "data": {  }}
+        if self.scripted_process.exception:
+            stop_reason['data']['mach_exception'] = self.scripted_process.exception
+        return stop_reason
 
     def get_register_context(self) -> str:
         if not self.register_ctx:
             self.register_ctx = self.create_register_ctx()
 
         return struct.pack("{}Q".format(len(self.register_ctx)), *self.register_ctx.values())

lldb/source/Plugins/Process/Utility/StopInfoMachException.h

 //===-- StopInfoMachException.h ---------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_STOPINFOMACHEXCEPTION_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_STOPINFOMACHEXCEPTION_H
 
 #include <string>
 
 #include "lldb/Target/StopInfo.h"
 
+#if defined(__APPLE__)
+// Needed for the EXC_* defines
+#include <mach/exception.h>
+#endif
+
 namespace lldb_private {
 
 class StopInfoMachException : public StopInfo {
   /// Determine the pointer-authentication related failure that caused this
   /// exception. Returns true and fills out the failure description if there
   /// is auth-related failure, and returns false otherwise.
   bool DeterminePtrauthFailure(ExecutionContext &exe_ctx);
 
 public:
   // Constructors and Destructors
   StopInfoMachException(Thread &thread, uint32_t exc_type,
                         uint32_t exc_data_count, uint64_t exc_code,
                         uint64_t exc_subcode)
       : StopInfo(thread, exc_type), m_exc_data_count(exc_data_count),
         m_exc_code(exc_code), m_exc_subcode(exc_subcode) {}
 
   ~StopInfoMachException() override = default;
 
   lldb::StopReason GetStopReason() const override {
     return lldb::eStopReasonException;
   }
 
   const char *GetDescription() override;
 
+#if defined(__APPLE__)
+  struct MachException {
+    static const char *Name(exception_type_t exc_type);
+    static llvm::Optional<exception_type_t> ExceptionCode(const char *name);
+  };
+#endif
+
   // Since some mach exceptions will be reported as breakpoints, signals,
   // or trace, we use this static accessor which will translate the mach
   // exception into the correct StopInfo.
   static lldb::StopInfoSP CreateStopReasonWithMachException(
       Thread &thread, uint32_t exc_type, uint32_t exc_data_count,
       uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code,
       bool pc_already_adjusted = true, bool adjust_pc_if_needed = false);
 

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

if (bp_sp && bp_sp->IsEnabled()) {
       return StopInfo::CreateStopReasonWithBreakpointSiteID(thread,
                                                             bp_sp->GetID());
     }
   }
 
   return nullptr;
 }
 
+#if defined(__APPLE__)
+const char *
+StopInfoMachException::MachException::Name(exception_type_t exc_type) {
+  switch (exc_type) {
+  case EXC_BAD_ACCESS:
+    return "EXC_BAD_ACCESS";
+  case EXC_BAD_INSTRUCTION:
+    return "EXC_BAD_INSTRUCTION";
+  case EXC_ARITHMETIC:
+    return "EXC_ARITHMETIC";
+  case EXC_EMULATION:
+    return "EXC_EMULATION";
+  case EXC_SOFTWARE:
+    return "EXC_SOFTWARE";
+  case EXC_BREAKPOINT:
+    return "EXC_BREAKPOINT";
+  case EXC_SYSCALL:
+    return "EXC_SYSCALL";
+  case EXC_MACH_SYSCALL:
+    return "EXC_MACH_SYSCALL";
+  case EXC_RPC_ALERT:
+    return "EXC_RPC_ALERT";
+#ifdef EXC_CRASH
+  case EXC_CRASH:
+    return "EXC_CRASH";
+#endif
+  case EXC_RESOURCE:
+    return "EXC_RESOURCE";
+#ifdef EXC_GUARD
+  case EXC_GUARD:
+    return "EXC_GUARD";
+#endif
+#ifdef EXC_CORPSE_NOTIFY
+  case EXC_CORPSE_NOTIFY:
+    return "EXC_CORPSE_NOTIFY";
+#endif
+#ifdef EXC_CORPSE_VARIANT_BIT
+  case EXC_CORPSE_VARIANT_BIT:
+    return "EXC_CORPSE_VARIANT_BIT";
+#endif
+  default:
+    break;
+  }
+  return NULL;
+}
+
+llvm::Optional<exception_type_t>
+StopInfoMachException::MachException::ExceptionCode(const char *name) {
+  return llvm::StringSwitch<llvm::Optional<exception_type_t>>(name)
+      .Case("EXC_BAD_ACCESS", EXC_BAD_ACCESS)
+      .Case("EXC_BAD_INSTRUCTION", EXC_BAD_INSTRUCTION)
+      .Case("EXC_ARITHMETIC", EXC_ARITHMETIC)
+      .Case("EXC_EMULATION", EXC_EMULATION)
+      .Case("EXC_SOFTWARE", EXC_SOFTWARE)
+      .Case("EXC_BREAKPOINT", EXC_BREAKPOINT)
+      .Case("EXC_SYSCALL", EXC_SYSCALL)
+      .Case("EXC_MACH_SYSCALL", EXC_MACH_SYSCALL)
+      .Case("EXC_RPC_ALERT", EXC_RPC_ALERT)
+#ifdef EXC_CRASH
+      .Case("EXC_CRASH", EXC_CRASH)
+#endif
+      .Case("EXC_RESOURCE", EXC_RESOURCE)
+#ifdef EXC_GUARD
+      .Case("EXC_GUARD", EXC_GUARD)
+#endif
+#ifdef EXC_CORPSE_NOTIFY
+      .Case("EXC_CORPSE_NOTIFY", EXC_CORPSE_NOTIFY)
+#endif
+      .Default(llvm::None);
+}
+#endif
+
 StopInfoSP StopInfoMachException::CreateStopReasonWithMachException(
     Thread &thread, uint32_t exc_type, uint32_t exc_data_count,
     uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code,
     bool pc_already_adjusted, bool adjust_pc_if_needed) {
   if (exc_type == 0)
     return StopInfoSP();
 
   uint32_t pc_decrement = 0;
   ExecutionContext exe_ctx(thread.shared_from_this());
   Target *target = exe_ctx.GetTargetPtr();
   const llvm::Triple::ArchType cpu =
       target ? target->GetArchitecture().GetMachine()
              : llvm::Triple::UnknownArch;
 
   switch (exc_type) {
   case 1: // EXC_BAD_ACCESS
   case 2: // EXC_BAD_INSTRUCTION
   case 3: // EXC_ARITHMETIC
   case 4: // EXC_EMULATION
     break;
 
   case 5:                    // EXC_SOFTWARE
     if (exc_code == 0x10003) // EXC_SOFT_SIGNAL
     {

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

 //===-- ScriptedThread.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 "ScriptedThread.h"
 
 #include "Plugins/Process/Utility/RegisterContextThreadMemory.h"
+#include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBLog.h"
 #include <memory>
case lldb::eStopReasonSignal: {
     llvm::StringRef description;
     data_dict->GetValueForKeyAsInteger("signal", signal,
                                        LLDB_INVALID_SIGNAL_NUMBER);
     data_dict->GetValueForKeyAsString("desc", description);
     stop_info_sp =
         StopInfo::CreateStopReasonWithSignal(*this, signal, description.data());
   } break;
   case lldb::eStopReasonException: {
-    llvm::StringRef description;
-    data_dict->GetValueForKeyAsString("desc", description);
+#if defined(__APPLE__)
+    StructuredData::Dictionary *mach_exception;
+    if (data_dict->GetValueForKeyAsDictionary("mach_exception",
+                                              mach_exception)) {
+      llvm::StringRef value;
+      mach_exception->GetValueForKeyAsString("type", value);
+      auto exc_type =
+          StopInfoMachException::MachException::ExceptionCode(value.data());
+
+      if (!exc_type)
+        return false;
+
+      uint32_t exc_data_size = 0;
+      llvm::SmallVector<uint64_t, 3> raw_codes;
+
+      StructuredData::Array *exc_rawcodes;
+      mach_exception->GetValueForKeyAsArray("rawCodes", exc_rawcodes);
+      if (exc_rawcodes) {
+        auto fetch_data = [&raw_codes](StructuredData::Object *obj) {
+          if (!obj)
+            return false;
+          raw_codes.push_back(obj->GetIntegerValue());
+          return true;
+        };
+
+        exc_rawcodes->ForEach(fetch_data);
+        exc_data_size = raw_codes.size();
+      }
+
+      stop_info_sp = StopInfoMachException::CreateStopReasonWithMachException(
+          *this, *exc_type, exc_data_size,
+          exc_data_size >= 1 ? raw_codes[0] : 0,
+          exc_data_size >= 2 ? raw_codes[1] : 0,
+          exc_data_size >= 3 ? raw_codes[2] : 0);
 
+      break;
+    }
+#endif
     stop_info_sp =
-        StopInfo::CreateStopReasonWithException(*this, description.data());
+        StopInfo::CreateStopReasonWithException(*this, "EXC_BAD_ACCESS");
   } break;
   default:
     return ScriptedInterface::ErrorWithMessage<bool>(
         LLVM_PRETTY_FUNCTION,
         llvm::Twine("Unsupported stop reason type (" +
                     llvm::Twine(stop_reason_type) + llvm::Twine(")."))
             .str(),
         error, LLDBLog::Thread);

lldb/test/Shell/ScriptInterpreter/Python/Crashlog/scripted_crashlog_json.test

 # REQUIRES: python, native && target-aarch64 && system-darwin
 
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj %S/Inputs/interactive_crashlog/multithread-test.yaml > %t.dir/multithread-test
 # RUN: %lldb -o 'command script import lldb.macosx.crashlog' \
 # RUN: -o 'crashlog -a -i -t %t.dir/multithread-test %S/Inputs/interactive_crashlog/multithread-test.ips' \
 # RUN: -o "thread list" -o "bt all" 2>&1 | FileCheck %s
 
 # CHECK: "crashlog" {{.*}} commands have been installed, use the "--help" options on these commands
 
 # CHECK: (lldb) process status
 # CHECK-NEXT: Process 22511 stopped
-# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:     frame #0: 0x0000000100ec58f4 multithread-test`bar
 
 # CHECK: (lldb) thread backtrace
-# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:   * frame #0: 0x0000000100ec58f4 multithread-test`bar{{.*}} [artificial]
 # CHECK-NEXT:     frame #1: 0x0000000100ec591b multithread-test`foo{{.*}} [artificial]
 # CHECK-NEXT:     frame #2: 0x0000000100ec5a87 multithread-test`compute_pow{{.*}} [artificial]
 
 # CHECK: (lldb) thread list
 # CHECK-NEXT: Process 22511 stopped
 # CHECK-NEXT:   thread #1: tid = 0x23c7fe, 0x000000019cc40b84{{.*}}, queue = 'com.apple.main-thread'
 # CHECK-NEXT:   thread #2: tid = 0x23c800, 0x000000019cc42c9c{{.*}}
-# CHECK-NEXT: * thread #3: tid = 0x23c801, 0x0000000100ec58f4 multithread-test`bar{{.*}}, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT: * thread #3: tid = 0x23c801, 0x0000000100ec58f4 multithread-test`bar{{.*}}, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 
 # CHECK: (lldb) bt all
 # CHECK:  thread #1, queue = 'com.apple.main-thread'
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc40b84{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x0000000100ec5b3b multithread-test`main{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x00000002230f8da7{{.*}} [artificial]
 # CHECK-NEXT:  thread #2
 # CHECK-NEXT:    frame #0: 0x000000019cc42c9c{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x0000000100ec5957 multithread-test`call_and_wait{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc7e06b{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc78e2b{{.*}} [artificial]
-# CHECK-NEXT:* thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT:* thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:  * frame #0: 0x0000000100ec58f4 multithread-test`bar{{.*}} [artificial]
 # CHECK-NEXT:    frame #1: 0x0000000100ec591b multithread-test`foo{{.*}} [artificial]
 # CHECK-NEXT:    frame #2: 0x0000000100ec5a87 multithread-test`compute_pow{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc7e06b{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc78e2b{{.*}} [artificial]

lldb/test/Shell/ScriptInterpreter/Python/Crashlog/skipped_status_interactive_crashlog.test

 # REQUIRES: python, native && target-aarch64 && system-darwin
 
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj %S/Inputs/interactive_crashlog/multithread-test.yaml > %t.dir/multithread-test
 # RUN: %lldb -b -o 'command script import lldb.macosx.crashlog' \
 # RUN: -o 'crashlog -a -i -s -t %t.dir/multithread-test %S/Inputs/interactive_crashlog/multithread-test.ips' \
 # RUN: -o 'command source -s 0 %s' 2>&1 | FileCheck %s
 
 # CHECK: "crashlog" {{.*}} commands have been installed, use the "--help" options on these commands
 
 process status
 # CHECK: Process 22511 stopped
-# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT: * thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:     frame #0: 0x0000000100ec58f4 multithread-test`bar
 
 thread backtrace
-# CHECK: * thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK: * thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:   * frame #0: 0x0000000100ec58f4 multithread-test`bar{{.*}} [artificial]
 # CHECK-NEXT:     frame #1: 0x0000000100ec591b multithread-test`foo{{.*}} [artificial]
 # CHECK-NEXT:     frame #2: 0x0000000100ec5a87 multithread-test`compute_pow{{.*}} [artificial]
 
 thread list
 # CHECK: Process 22511 stopped
 # CHECK-NEXT:   thread #1: tid = 0x23c7fe, 0x000000019cc40b84{{.*}}, queue = 'com.apple.main-thread'
 # CHECK-NEXT:   thread #2: tid = 0x23c800, 0x000000019cc42c9c{{.*}}
-# CHECK-NEXT: * thread #3: tid = 0x23c801, 0x0000000100ec58f4 multithread-test`bar{{.*}}, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT: * thread #3: tid = 0x23c801, 0x0000000100ec58f4 multithread-test`bar{{.*}}, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 
 bt all
 # CHECK:  thread #1, queue = 'com.apple.main-thread'
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc40b84{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x0000000100ec5b3b multithread-test`main{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x00000002230f8da7{{.*}} [artificial]
 # CHECK-NEXT:  thread #2
 # CHECK-NEXT:    frame #0: 0x000000019cc42c9c{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x0000000100ec5957 multithread-test`call_and_wait{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc7e06b{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc78e2b{{.*}} [artificial]
-# CHECK-NEXT:* thread #3, stop reason = EXC_BAD_ACCESS
+# CHECK-NEXT:* thread #3, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
 # CHECK-NEXT:  * frame #0: 0x0000000100ec58f4 multithread-test`bar{{.*}} [artificial]
 # CHECK-NEXT:    frame #1: 0x0000000100ec591b multithread-test`foo{{.*}} [artificial]
 # CHECK-NEXT:    frame #2: 0x0000000100ec5a87 multithread-test`compute_pow{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc7e06b{{.*}} [artificial]
 # CHECK:    frame #{{[0-9]+}}: 0x000000019cc78e2b{{.*}} [artificial]