[lldb/crashlog] Create interactive crashlog with no binary

[mib]

Summary

This patch changes the way we load a crash report into a scripted
process by creating a empty target.

To do so, it parses the architecture information from the report (for
both the legacy and json format) and uses that to create a target that
doesn't have any executable, like what we do when attaching to a process.

For the legacy format, we mostly rely on the Code Type line, since the
architure is an optional field on the Binary Images sections.

However for the json format, we first try to get the architecture while
parsing the image dictionary if we couldn't find it, we try to infer it
using the "flavor" key when parsing the frame's registers.

If the architecture is still not set after parsing the report, we use
the host architecture, as a fallback.

rdar://107850263

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

[bulbazord]

lldb/examples/python/crashlog.py

493

Any reason you moved this?

552–553

I assume "pid" and "procName" are not optional right? Maybe not in this one but in a follow-up we can add some error handling here.

1373–1374

The fallback of "use the host platform's architecture" seems like it could lead to some issues no? I'm not sure we can do better if the crashlog doesn't have any info about a process architecture though...

[mib]

lldb/examples/python/crashlog.py

493

It makes more sense to me to initialize the crashlog object last.

1373–1374

Do you think we shouldn't fallback to the host architecture in this case and raise an exception instead ?

[bulbazord]

lldb/examples/python/crashlog.py

1373–1374

That might be a better idea. For example, if you're debugging a crashlog for a different platform, lldb would make this assumption silently which can lead to strange problems that are difficult to reason about.

[mib]

Address @bulbazord & @jingham's comments:

• Rename name -> label
• Add test
• Add sanity check to avoid having integer only labels
• Add target index when label already exist for another target

[mib]

Reload the previous version of this diff

[mib]

Address @bulbazord last comments

[bulbazord]

LGTM modulo typo

lldb/examples/python/crashlog.py

1374

Typo

lldb/examples/python/crashlog.py

def __init__(self, debugger, path, verbose):
             list()
         )  # A list of the required identifiers for doing all stack backtraces
         self.errors = list()
         self.exception = dict()
         self.crashed_thread_idx = -1
         self.version = -1
         self.target = None
         self.verbose = verbose
+        self.process_id = None
+        self.process_identifier = None
+        self.process_path = None
+        self.process_arch = None
 
     def dump(self):
         print("Crash Log File: %s" % (self.path))
         if self.backtraces:
             print("\nApplication Specific Backtraces:")
             for thread in self.backtraces:
                 thread.dump("  ")
         print("\nThreads:")
def create(debugger, path, verbose):
             parser.data = data
             return parser
         else:
             return TextCrashLogParser(debugger, path, verbose)
 
     def __init__(self, debugger, path, verbose):
         self.path = os.path.expanduser(path)
         self.verbose = verbose
-        self.crashlog = CrashLog(debugger, self.path, self.verbose)
         # List of DarwinImages sorted by their index.
         self.images = list()
+        self.crashlog = CrashLog(debugger, self.path, self.verbose)
 
     @abc.abstractmethod
     def parse(self):
         pass
 
 
 class JSONCrashLogParser(CrashLogParser):
     @staticmethod
def parse(self):
             )
 
         return self.crashlog
 
     def get_used_image(self, idx):
         return self.data["usedImages"][idx]
 
     def parse_process_info(self, json_data):
         self.crashlog.process_id = json_data["pid"]
         self.crashlog.process_identifier = json_data["procName"]
+        if "procPath" in json_data:
+            self.crashlog.process_path = json_data["procPath"]
 
     def parse_crash_reason(self, json_exception):
         self.crashlog.exception = json_exception
         exception_type = json_exception["type"]
         exception_signal = " "
         if "signal" in json_exception:
             exception_signal += "({})".format(json_exception["signal"])
 
def parse_images(self, json_images):
             low = int(json_image["base"])
             high = low + int(json_image["size"]) if "size" in json_image else low
             name = json_image["name"] if "name" in json_image else ""
             path = json_image["path"] if "path" in json_image else ""
             version = ""
             darwin_image = self.crashlog.DarwinImage(
                 low, high, name, version, img_uuid, path, self.verbose
             )
+            if "arch" in json_image:
+                darwin_image.arch = json_image["arch"]
+                if path == self.crashlog.process_path:
+                    self.crashlog.process_arch = darwin_image.arch
             self.images.append(darwin_image)
             self.crashlog.images.append(darwin_image)
 
     def parse_main_image(self, json_data):
         if "procName" in json_data:
             proc_name = json_data["procName"]
             self.crashlog.set_main_image(proc_name)
 
def parse_thread_registers(self, json_thread_state, prefix=None):
         for key, state in json_thread_state.items():
             if key == "rosetta":
                 registers.update(self.parse_thread_registers(state))
                 continue
             if key == "x":
                 gpr_dict = {str(idx): reg for idx, reg in enumerate(state)}
                 registers.update(self.parse_thread_registers(gpr_dict, key))
                 continue
+            if key == "flavor":
+                if not self.crashlog.process_arch:
+                    if state == "ARM_THREAD_STATE64":
+                        self.crashlog.process_arch = "arm64"
+                    elif state == "X86_THREAD_STATE":
+                        self.crashlog.process_arch = "x86_64"
+                continue
             try:
                 value = int(state["value"])
                 registers["{}{}".format(prefix or "", key)] = value
             except (KeyError, ValueError, TypeError):
                 pass
         return registers
 
     def parse_errors(self, json_data):
def parse_exception(self, line):
                 self.crashlog.exception["message"] = exception_extra_match.group(1)
 
     def parse_normal(self, line):
         if line.startswith("Process:"):
             (self.crashlog.process_name, pid_with_brackets) = (
                 line[8:].strip().split(" [")
             )
             self.crashlog.process_id = pid_with_brackets.strip("[]")
+        elif line.startswith("Path:"):
+            self.crashlog.process_path = line[5:].strip()
         elif line.startswith("Identifier:"):
             self.crashlog.process_identifier = line[11:].strip()
         elif line.startswith("Version:"):
             version_string = line[8:].strip()
             matched_pair = re.search("(.+)\((.+)\)", version_string)
             if matched_pair:
                 self.crashlog.process_version = matched_pair.group(1)
                 self.crashlog.process_compatability_version = matched_pair.group(2)
             else:
                 self.crashlog.process = version_string
                 self.crashlog.process_compatability_version = version_string
+        elif line.startswith("Code Type:"):
+            if "ARM-64" in line:
+                self.crashlog.process_arch = "arm64"
+            elif "X86-64" in line:
+                self.crashlog.process_arch = "x86_64"
         elif self.parent_process_regex.search(line):
             parent_process_match = self.parent_process_regex.search(line)
             self.crashlog.parent_process_name = parent_process_match.group(1)
             self.crashlog.parent_process_id = parent_process_match.group(2)
         elif line.startswith("Exception"):
             self.parse_exception(line)
             return
         elif line.startswith("Crashed Thread:"):
if options.target_path:
         if not target:
             raise InteractiveCrashLogException(
                 "couldn't create target provided by the user (%s)" % options.target_path
             )
 
     # 2. If the user didn't provide a target, try to create a target using the symbolicator
     if not target or not target.IsValid():
         target = crashlog.create_target()
-    # 3. If that didn't work, and a target is already loaded, use it
-    if (target is None or not target.IsValid()) and debugger.GetNumTargets() > 0:
-        target = debugger.GetTargetAtIndex(0)
+    # 3. If that didn't work, create a dummy target
+    if target is None or not target.IsValid():
+        arch = crashlog.process_arch
+        if not arch:
+            arch = platform.machine()
+        target = debugger.CreateTargetWithFileAndArch(None, arch)
     # 4. Fail
     if target is None or not target.IsValid():
         raise InteractiveCrashLogException("couldn't create target")
 
     ci = debugger.GetCommandInterpreter()
     if not ci:
         raise InteractiveCrashLogException("couldn't get command interpreter")
 

lldb/source/Target/Process.cpp

Status Process::LaunchPrivate(ProcessLaunchInfo &launch_info, StateType &state,
   // module.  But we should be able to debug a remote process even if the
   // executable module only exists on the remote.  However, there needs to
   // be a way to express this path, without actually having a module.
   // The way to do that is to set the ExecutableFile in the LaunchInfo.
   // Figure that out here:
 
   FileSpec exe_spec_to_use;
   if (!exe_module) {
-    if (!launch_info.GetExecutableFile()) {
+    if (!launch_info.GetExecutableFile() && !launch_info.IsScriptedProcess()) {
       error.SetErrorString("executable module does not exist");
       return error;
     }
     exe_spec_to_use = launch_info.GetExecutableFile();
   } else
     exe_spec_to_use = exe_module->GetFileSpec();
 
   if (exe_module && FileSystem::Instance().Exists(exe_module->GetFileSpec())) {