[lldb/Plugins] Move SBTarget::GetExtendedCrashInformation to SBProcess

[mib]

Summary

This patch moves the SB API method GetExtendedCrashInformation from
SBTarget to SBProcess since it only makes sense to call this method on a
sane process which might not be the case on a SBTarget object.

It also addresses some feedbacks received in D74657.

[labath]

This is great now, thanks for bearing with me.

lldb/bindings/interface/SBProcess.i

350

Mentioning the platform just confuses things here IMO. Maybe we can just remove it now?

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

89

Please run clang-format on this patch. the & should bind to the variable, not the type.

lldb/bindings/interface/SBProcess.i

public:
     EventIsStructuredDataEvent (const lldb::SBEvent &event);
 
     lldb::SBBroadcaster
     GetBroadcaster () const;
 
     bool
     GetDescription (lldb::SBStream &description);
 
+    %feature("autodoc", "
+    Returns the process' extended crash information.") GetExtendedCrashInformation;
+    lldb::SBStructuredData
+    GetExtendedCrashInformation ();
+
     uint32_t
     GetNumSupportedHardwareWatchpoints (lldb::SBError &error) const;
 
     uint32_t
     LoadImage (lldb::SBFileSpec &image_spec, lldb::SBError &error);
 
     %feature("autodoc", "
     Load the library whose filename is given by image_spec looking in all the

lldb/bindings/interface/SBTarget.i

#endif
     GetStackRedZoneSize();
 
     lldb::SBLaunchInfo
     GetLaunchInfo () const;
 
     void
     SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
 
-    %feature("autodoc", "
-    Returns the platform's process extended crash information.") GetExtendedCrashInformation;
-    lldb::SBStructuredData
-    GetExtendedCrashInformation ();
-
-
     void SetCollectingStats(bool v);
 
     bool GetCollectingStats();
 
     lldb::SBStructuredData GetStatistics();
 
     bool
     operator == (const lldb::SBTarget &rhs) const;

lldb/include/lldb/API/SBProcess.h

public:
   static bool EventIsStructuredDataEvent(const lldb::SBEvent &event);
 
   lldb::SBBroadcaster GetBroadcaster() const;
 
   static const char *GetBroadcasterClass();
 
   bool GetDescription(lldb::SBStream &description);
 
+  SBStructuredData GetExtendedCrashInformation();
+
   /// Start Tracing with the given SBTraceOptions.
   ///
   /// \param[in] options
   ///     Class containing trace options like trace buffer size, meta
   ///     data buffer size, TraceType and any custom parameters
   ///     {formatted as a JSON Dictionary}. In case of errors in
   ///     formatting, an error would be reported.
   ///     It must be noted that tracing options such as buffer sizes

lldb/include/lldb/API/SBStructuredData.h

public:
   ///     Returns the byte size needed to completely write the string value at
   ///     \a dst in all cases.
   size_t GetStringValue(char *dst, size_t dst_len) const;
 
 protected:
   friend class SBTraceOptions;
   friend class SBDebugger;
   friend class SBTarget;
+  friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRUCTUREDDATA_H

lldb/include/lldb/API/SBTarget.h

lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options);
 
   lldb::addr_t GetStackRedZoneSize();
 
   lldb::SBLaunchInfo GetLaunchInfo() const;
 
   void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
 
-  SBStructuredData GetExtendedCrashInformation();
-
 protected:
   friend class SBAddress;
   friend class SBBlock;
   friend class SBBreakpointList;
   friend class SBBreakpointNameImpl;
   friend class SBDebugger;
   friend class SBExecutionContext;
   friend class SBFunction;

lldb/include/lldb/Target/Platform.h

public:
 
   /// Gather all of crash informations into a structured data dictionnary.
   ///
   /// If the platform have a crashed process with crash information entries,
   /// gather all the entries into an structured data dictionnary or return a
   /// nullptr. This dictionnary is generic and extensible, as it contains an
   /// array for each different type of crash information.
   ///
-  /// \param[in] target
-  ///     The target running the crashed process.
+  /// \param[in] process
+  ///     The crashed process.
   ///
   /// \return
   ///     A structured data dictionnary containing at each entry, the crash
   ///     information type as the entry key and the matching  an array as the
   ///     entry value. \b nullptr if not implemented or  if the process has no
   ///     crash information entry. \b error if an error occured.
   virtual llvm::Expected<StructuredData::DictionarySP>
-  FetchExtendedCrashInformation(lldb_private::Target &target) {
+  FetchExtendedCrashInformation(lldb_private::Process &process) {
     return nullptr;
   }
 
 protected:
   bool m_is_host;
   // Set to true when we are able to actually set the OS version while being
   // connected. For remote platforms, we might set the version ahead of time
   // before we actually connect and this version might change when we actually

lldb/source/API/SBProcess.cpp

 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ProcessInfo.h"
strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s",
                 GetNumThreads(), exe_name ? ", executable = " : "",
                 exe_name ? exe_name : "");
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
+SBStructuredData SBProcess::GetExtendedCrashInformation() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
+                             GetExtendedCrashInformation);
+  SBStructuredData data;
+  ProcessSP process_sp(GetSP());
+  if (!process_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
+
+  if (!platform_sp)
+    return LLDB_RECORD_RESULT(data);
+
+  auto expected_data =
+      platform_sp->FetchExtendedCrashInformation(*process_sp.get());
+
+  if (!expected_data)
+    return LLDB_RECORD_RESULT(data);
+
+  StructuredData::ObjectSP fetched_data = *expected_data;
+  data.m_impl_up->SetObjectSP(fetched_data);
+  return LLDB_RECORD_RESULT(data);
+}
+
 uint32_t
 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
   LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
                            GetNumSupportedHardwareWatchpoints,
                            (lldb::SBError &), sb_error);
 
   uint32_t num = 0;
   ProcessSP process_sp(GetSP());
LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBProcess, GetBroadcaster,
                              ());
   LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess, GetBroadcasterClass,
                               ());
   LLDB_REGISTER_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
                        (lldb::addr_t, uint32_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
                        (lldb::addr_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &));
+  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBProcess,
+                       GetExtendedCrashInformation, ());
   LLDB_REGISTER_METHOD_CONST(uint32_t, SBProcess,
                              GetNumSupportedHardwareWatchpoints,
                              (lldb::SBError &));
   LLDB_REGISTER_METHOD(uint32_t, SBProcess, LoadImage,
                        (lldb::SBFileSpec &, lldb::SBError &));
   LLDB_REGISTER_METHOD(
       uint32_t, SBProcess, LoadImage,
       (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &));

lldb/source/API/SBTarget.cpp

void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
   LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
                      (const lldb::SBLaunchInfo &), launch_info);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
 }
 
-SBStructuredData SBTarget::GetExtendedCrashInformation() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget,
-                             GetExtendedCrashInformation);
-  SBStructuredData data;
-  TargetSP target_sp(GetSP());
-  if (!target_sp)
-    return LLDB_RECORD_RESULT(data);
-
-  PlatformSP platform_sp = target_sp->GetPlatform();
-
-  if (!target_sp)
-    return LLDB_RECORD_RESULT(data);
-
-  auto expected_data =
-      platform_sp->FetchExtendedCrashInformation(*target_sp.get());
-
-  if (!expected_data)
-    return LLDB_RECORD_RESULT(data);
-
-  StructuredData::ObjectSP fetched_data = *expected_data;
-  data.m_impl_up->SetObjectSP(fetched_data);
-  return LLDB_RECORD_RESULT(data);
-}
-
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *, const lldb::SBExpressionOptions &));
   LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
   LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
                        (const lldb::SBLaunchInfo &));
-  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget,
-                       GetExtendedCrashInformation, ());
   LLDB_REGISTER_METHOD(
       size_t, SBTarget, ReadMemory,
       (const lldb::SBAddress, void *, size_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
                        (lldb::SBAddress, const void *, size_t));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
                        GetInstructionsWithFlavor,
                        (lldb::SBAddress, const char *, const void *, size_t));

lldb/source/Commands/CommandObjectProcess.cpp

if (m_options.m_verbose) {
       PlatformSP platform_sp = process->GetTarget().GetPlatform();
       if (!platform_sp) {
         result.AppendError("Couldn'retrieve the target's platform");
         result.SetStatus(eReturnStatusFailed);
         return result.Succeeded();
       }
 
       auto expected_crash_info =
-          platform_sp->FetchExtendedCrashInformation(process->GetTarget());
+          platform_sp->FetchExtendedCrashInformation(*process);
 
       if (!expected_crash_info) {
         result.AppendError(llvm::toString(expected_crash_info.takeError()));
         result.SetStatus(eReturnStatusFailed);
         return result.Succeeded();
       }
 
       StructuredData::DictionarySP crash_info_sp = *expected_crash_info;

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

public:
 
   enum SDKType : unsigned {
     MacOSX = 0,
     iPhoneSimulator,
     iPhoneOS,
   };
 
   llvm::Expected<lldb_private::StructuredData::DictionarySP>
-  FetchExtendedCrashInformation(lldb_private::Target &target) override;
+  FetchExtendedCrashInformation(lldb_private::Process &process) override;
 
 protected:
   struct CrashInfoAnnotations {
     uint64_t version;          // unsigned long
     uint64_t message;          // char *
     uint64_t signature_string; // char *
     uint64_t backtrace;        // char *
     uint64_t message2;         // char *
     uint64_t thread;           // uint64_t
     uint64_t dialog_mode;      // unsigned int
     uint64_t abort_cause;      // unsigned int
   };
 
   /// Extract the `__crash_info` annotations from each of of the target's
   /// modules.
   ///
   /// If the platform have a crashed processes with a `__crash_info` section,
   /// extract the section to gather the messages annotations and the abort
   /// cause.
   ///
-  /// \param[in] target
-  ///     The target running the crashed process.
+  /// \param[in] process
+  ///     The crashed process.
   ///
   /// \return
   ///     A  structured data array containing at each entry in each entry, the
   ///     module spec, its UUID, the crash messages and the abort cause.
   ///     \b nullptr if process has no crash information annotations.
   lldb_private::StructuredData::ArraySP
-  ExtractCrashInfoAnnotations(lldb_private::Target &target);
+  ExtractCrashInfoAnnotations(lldb_private::Process &process);
 
   void ReadLibdispatchOffsetsAddress(lldb_private::Process *process);
 
   void ReadLibdispatchOffsets(lldb_private::Process *process);
 
   virtual lldb_private::Status GetSharedModuleWithLocalCache(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr,

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (build_str.consume_front("(")) {
       build = build_str.slice(0, pos);
     }
   }
 
   return std::make_tuple(version, build);
 }
 
 llvm::Expected<StructuredData::DictionarySP>
-PlatformDarwin::FetchExtendedCrashInformation(lldb_private::Target &target) {
+PlatformDarwin::FetchExtendedCrashInformation(Process &process) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  StructuredData::ArraySP annotations = ExtractCrashInfoAnnotations(target);
+  StructuredData::ArraySP annotations = ExtractCrashInfoAnnotations(process);
 
   if (!annotations || !annotations->GetSize()) {
     LLDB_LOG(log, "Couldn't extract crash information annotations");
     return nullptr;
   }
 
   StructuredData::DictionarySP extended_crash_info =
       std::make_shared<StructuredData::Dictionary>();
 
   extended_crash_info->AddItem("crash-info annotations", annotations);
 
   return extended_crash_info;
 }
 
 StructuredData::ArraySP
-PlatformDarwin::ExtractCrashInfoAnnotations(Target &target) {
+PlatformDarwin::ExtractCrashInfoAnnotations(Process &process) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   ConstString section_name("__crash_info");
-  ProcessSP process_sp = target.GetProcessSP();
+  Target &target = process.GetTarget();
   StructuredData::ArraySP array_sp = std::make_shared<StructuredData::Array>();
 
   for (ModuleSP module : target.GetImages().Modules()) {
     SectionList *sections = module->GetSectionList();
 
     std::string module_name = module->GetSpecificationDescription();
 
     // The DYDL module is skipped since it's always loaded when running the
if (load_addr == LLDB_INVALID_ADDRESS) {
       LLDB_LOG(log, "Module {0} has an invalid '{1}' section load address: {2}",
                module_name, section_name, load_addr);
       continue;
     }
 
     Status error;
     CrashInfoAnnotations annotations;
     size_t expected_size = sizeof(CrashInfoAnnotations);
-    size_t bytes_read = process_sp->ReadMemoryFromInferior(
-        load_addr, &annotations, expected_size, error);
+    size_t bytes_read = process.ReadMemoryFromInferior(load_addr, &annotations,
+                                                       expected_size, error);
 
     if (expected_size != bytes_read || error.Fail()) {
       LLDB_LOG(log, "Failed to read {0} section from memory in module {1}: {2}",
                section_name, module_name, error);
       continue;
     }
 
     // initial support added for version 5
     if (annotations.version < 5) {
       LLDB_LOG(log,
                "Annotation version lower than 5 unsupported! Module {0} has "
                "version {1} instead.",
                module_name, annotations.version);
       continue;
     }
 
     if (!annotations.message) {
       LLDB_LOG(log, "No message available for module {0}.", module_name);
       continue;
     }
 
     std::string message;
     bytes_read =
-        process_sp->ReadCStringFromMemory(annotations.message, message, error);
+        process.ReadCStringFromMemory(annotations.message, message, error);
 
     if (message.empty() || bytes_read != message.size() || error.Fail()) {
       LLDB_LOG(log, "Failed to read the message from memory in module {0}: {1}",
                module_name, error);
       continue;
     }
 
     // Remove trailing newline from message
     if (message.back() == '\n')
       message.pop_back();
 
     if (!annotations.message2)
       LLDB_LOG(log, "No message2 available for module {0}.", module_name);
 
     std::string message2;
-    bytes_read = process_sp->ReadCStringFromMemory(annotations.message2,
-                                                   message2, error);
+    bytes_read =
+        process.ReadCStringFromMemory(annotations.message2, message2, error);
 
     if (!message2.empty() && bytes_read == message2.size() && error.Success())
       if (message2.back() == '\n')
         message2.pop_back();
 
     StructuredData::DictionarySP entry_sp =
         std::make_shared<StructuredData::Dictionary>();
 

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

 """
 Test lldb process crash info.
 """
 
 import os
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
+from lldbsuite.test import lldbtest
+
 
 class PlatformProcessCrashInfoTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         self.runCmd("settings set auto-confirm true")
         self.source = "main.c"
-        self.line = 3
+        self.line = line_number(self.source, '// break here')
 
     def tearDown(self):
         self.runCmd("settings clear auto-confirm")
         TestBase.tearDown(self)
 
     @skipUnlessDarwin
     def test_cli(self):
         """Test that `process status --verbose` fetches the extended crash
def test_api(self):
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         target.LaunchSimple(None, None, os.getcwd())
 
         stream = lldb.SBStream()
         self.assertTrue(stream)
 
-        crash_info = target.GetExtendedCrashInformation()
+        process = target.GetProcess()
+        self.assertTrue(process)
+
+        crash_info = process.GetExtendedCrashInformation()
 
         error = crash_info.GetAsJSON(stream)
 
         self.assertTrue(error.Success())
 
         self.assertTrue(crash_info.IsValid())
 
         self.assertIn("pointer being freed was not allocated", stream.GetData())
 
-    @skipUnlessDarwin
-    def test_before_launch(self):
-        """Test that lldb doesn't fetch the extended crash information
-        dictionnary from if the process wasn't launched yet."""
-        self.build()
-        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
-        self.assertTrue(target, VALID_TARGET)
-
-        stream = lldb.SBStream()
-        self.assertTrue(stream)
-
-        crash_info = target.GetExtendedCrashInformation()
-
-        error = crash_info.GetAsJSON(stream)
-        self.assertFalse(error.Success())
-        self.assertIn("No structured data.", error.GetCString())
-
-    @skipUnlessDarwin
     def test_on_sane_process(self):
         """Test that lldb doesn't fetch the extended crash information
         dictionnary from a 'sane' stopped process."""
         self.build()
         target, _, _, _ = lldbutil.run_to_line_breakpoint(self, lldb.SBFileSpec(self.source),
                                         self.line)
 
         stream = lldb.SBStream()
         self.assertTrue(stream)
 
-        crash_info = target.GetExtendedCrashInformation()
+        process = target.GetProcess()
+        self.assertTrue(process)
+
+        crash_info = process.GetExtendedCrashInformation()
 
         error = crash_info.GetAsJSON(stream)
         self.assertFalse(error.Success())
         self.assertIn("No structured data.", error.GetCString())

lldb/test/API/functionalities/process_crash_info/main.c

 #include <stdlib.h>
+
 int main() {
-  int *var = malloc(sizeof(int));
+  int *var = malloc(sizeof(int)); // break here
   free(var);
   free(var);
   return 0;
 }