[lldb] Run crashlog inside lldb when invoked in interactive mode from the command line

[JDevlieghere]

Summary

Run crashlog inside lldb when invoked in interactive mode from the command line. Currently, when passing -i to crashlog from the command line, we symbolicate in LLDB and immediately exit right after which pretty much defeats the purpose of interactive mode. On the other hand, we wouldn't want to reimplement the driver from the crashlog script. Re-invoking ourself from inside LLDB solves the issue.

rdar://97801509

[aprantl]

This is super convenient! Thanks!

[mib]

LGTM! Thanks for taking care of this :)

lldb/examples/python/crashlog.py

else:
         result.PutCString("error: invalid target")
 
 
 class Symbolicate:
     def __init__(self, debugger, internal_dict):
         pass
 
     def __call__(self, debugger, command, exe_ctx, result):
-        SymbolicateCrashLogs(debugger, shlex.split(command), result)
+        SymbolicateCrashLogs(debugger, shlex.split(command), result, True)
 
     def get_short_help(self):
         return "Symbolicate one or more darwin crash log files."
 
     def get_long_help(self):
         option_parser = CrashLogOptionParser()
         return option_parser.format_help()
 

 If this script is imported into the LLDB command interpreter, a "crashlog" command will be added to the interpreter
 for use at the LLDB command line. After a crash log has been parsed and symbolicated, a target will have been
 created that has all of the shared libraries loaded at the load addresses found in the crash log file. This allows
 you to explore the program as if it were stopped at the locations described in the crash log and functions can
 be disassembled and lookups can be performed using the addresses found in the crash log."""
     return CreateSymbolicateCrashLogOptions("crashlog", description, True)
 
 
-def SymbolicateCrashLogs(debugger, command_args, result):
+def SymbolicateCrashLogs(debugger, command_args, result, is_command):
     option_parser = CrashLogOptionParser()
 
     if not len(command_args):
         option_parser.print_help()
         return
 
     try:
         (options, args) = option_parser.parse_args(command_args)
     except:
         return
 
+    # Interactive mode requires running the crashlog command from inside lldb.
+    if options.interactive and not is_command:
+        lldb_exec = (
+            subprocess.check_output(["/usr/bin/xcrun", "-f", "lldb"])
+            .decode("utf-8")
+            .strip()
+        )
+        sys.exit(
+            os.execv(
+                lldb_exec,
+                [
+                    lldb_exec,
+                    "-o",
+                    "command script import lldb.macosx",
+                    "-o",
+                    "crashlog {}".format(shlex.join(command_args)),
+                ],
+            )
+        )
+
     if options.version:
         print(debugger.GetVersionString())
         return
 
     if options.debug:
         print("command_args = %s" % command_args)
         print("options", options)
         print("args", args)
if args:
                 ).parse()
                 SymbolicateCrashLog(crash_log, options)
 
 
 if __name__ == "__main__":
     # Create a new debugger instance
     debugger = lldb.SBDebugger.Create()
     result = lldb.SBCommandReturnObject()
-    SymbolicateCrashLogs(debugger, sys.argv[1:], result)
+    SymbolicateCrashLogs(debugger, sys.argv[1:], result, False)
     lldb.SBDebugger.Destroy(debugger)
 
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
         "command script add -o -c lldb.macosx.crashlog.Symbolicate -C disk-file crashlog"
     )
     debugger.HandleCommand(
         "command script add -o -f lldb.macosx.crashlog.save_crashlog -C disk-file save_crashlog"
     )
     print(
         '"crashlog" and "save_crashlog" commands have been installed, use '
         'the "--help" options on these commands for detailed help.'
     )