[lldb] Parse the crashlog only once

[JDevlieghere]

Summary

Now that we can pass Python objects to the scripted process instance, we don't need to parse the crashlog twice anymore.

[mib]

LGTM!

lldb/examples/python/crashlog.py

def load_crashlog_in_scripted_process(debugger, crash_log_file, options, result):
 
     structured_data = lldb.SBStructuredData()
     structured_data.SetFromJSON(json.dumps({ "file_path" : crashlog_path,
                                              "load_all_images": options.load_all_images }))
     launch_info = lldb.SBLaunchInfo(None)
     launch_info.SetProcessPluginName("ScriptedProcess")
     launch_info.SetScriptedProcessClassName("crashlog_scripted_process.CrashLogScriptedProcess")
     launch_info.SetScriptedProcessDictionary(structured_data)
+    launch_info.SetLaunchFlags(lldb.eLaunchFlagStopAtEntry)
+
     error = lldb.SBError()
     process = target.Launch(launch_info, error)
 
     if not process or error.Fail():
         raise InteractiveCrashLogException("couldn't launch Scripted Process", error)
 
+    process.GetScriptedImplementation().set_crashlog(crashlog)
+    process.Continue()
+
     if not options.skip_status:
         @contextlib.contextmanager
         def synchronous(debugger):
             async_state = debugger.GetAsync()
             debugger.SetAsync(False)
             try:
                 yield
             finally:

lldb/examples/python/scripted_process/crashlog_scripted_process.py

 import os,json,struct,signal,uuid
 
 from typing import Any, Dict
 
 import lldb
 from lldb.plugins.scripted_process import ScriptedProcess
 from lldb.plugins.scripted_process import ScriptedThread
 
 from lldb.macosx.crashlog import CrashLog,CrashLogParser
 
 class CrashLogScriptedProcess(ScriptedProcess):
-    def parse_crashlog(self):
-        crashlog_parser = CrashLogParser.create(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
+    def set_crashlog(self, crashlog):
+        self.crashlog = crashlog
+        self.pid = self.crashlog.process_id
+        self.addr_mask = self.crashlog.addr_mask
+        self.crashed_thread_idx = self.crashlog.crashed_thread_idx
         self.loaded_images = []
-        self.exception = crash_log.exception
+        self.exception = self.crashlog.exception
         self.app_specific_thread = None
-        if hasattr(crash_log, 'asi'):
-            self.metadata['asi'] = crash_log.asi
-        if hasattr(crash_log, 'asb'):
-            self.extended_thread_info = crash_log.asb
+        if hasattr(self.crashlog, 'asi'):
+            self.metadata['asi'] = self.crashlog.asi
+        if hasattr(self.crashlog, 'asb'):
+            self.extended_thread_info = self.crashlog.asb
 
         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
                         err = image.add_module(self.target)
                         if err:
                             # Append to SBCommandReturnObject
                             print(err)
                         else:
                             self.loaded_images.append(image)
 
-        for thread in crash_log.threads:
+        for thread in self.crashlog.threads:
             if self.load_all_images:
-                load_images(self, crash_log.images)
+                load_images(self, self.crashlog.images)
             elif thread.did_crash():
                 for ident in thread.idents:
-                    load_images(self, crash_log.find_images_with_identifier(ident))
+                    load_images(self, self.crashlog.find_images_with_identifier(ident))
 
             if hasattr(thread, 'app_specific_backtrace') and thread.app_specific_backtrace:
                 # We don't want to include the Application Specific Backtrace
                 # Thread into the Scripted Process' Thread list.
                 # Instead, we will try to extract the stackframe pcs from the
                 # backtrace and inject that as the extended thread info.
                 self.app_specific_thread = thread
                 continue
def __init__(self, exe_ctx: lldb.SBExecutionContext, args : lldb.SBStructuredData):
 
         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.extended_thread_info = None
-        self.parse_crashlog()
 
     def read_memory_at_address(self, addr: int, size: int, error: lldb.SBError) -> lldb.SBData:
         # NOTE: CrashLogs don't contain any memory.
         return lldb.SBData()
 
     def get_loaded_images(self):
         # TODO: Iterate over corefile_target modules and build a data structure
         # from it.

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

public:
   DynamicLoader *GetDynamicLoader() override { return nullptr; }
 
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   Status DoLoadCore() override;
 
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
-  void DidLaunch() override;
+  void DidResume() override;
 
   Status DoResume() override;
 
   Status DoAttachToProcessWithID(lldb::pid_t pid,
                                  const ProcessAttachInfo &attach_info) override;
 
   Status
   DoAttachToProcessWithName(const char *process_name,

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

Status ScriptedProcess::DoLaunch(Module *exe_module,
   //  if (state != eStateInvalid) {
   //    SetPrivateState(state);
 
   SetPrivateState(eStateStopped);
 
   return {};
 }
 
-void ScriptedProcess::DidLaunch() {
+void ScriptedProcess::DidResume() {
   m_pid = GetInterface().GetProcessID();
   GetLoadedDynamicLibrariesInfos();
 }
 
 Status ScriptedProcess::DoResume() {
   Log *log = GetLog(LLDBLog::Process);
   // FIXME: Fetch data from thread.
   const StateType thread_resume_state = eStateRunning;