[lldb/crashlog] Make register output match lldb ordering in legacy mode

[mib]

Summary

This patch changes the way we dump the registers from the legacy
crashlog command to make sure that the ordering matches the one from lldb.

rdar://109172073

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

[bulbazord]

In general looks good to me. I have one suggestion and one question.

lldb/examples/python/crashlog.py

104

Is there a reason to do anything if self.arch isn't set? (Or is set to None)

126–131

nit: You can avoid an else+continue if you check reg_name at the end. Just a style thing though, feel free to ignore.

[mib]

lldb/examples/python/crashlog.py

104

If we fail to parse it from the report or if it's missing (for some reasons), self.crashlog.process_arch will be None.

[JDevlieghere]

LGTM

[mib]

Address feedback & reformat

lldb/examples/python/crashlog.py

try:
         import lldb
     except ImportError:
         print(
             "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
         )
         sys.exit(1)
 
 from lldb.utils import symbolication
+from lldb.plugins.scripted_process import INTEL64_GPR, ARM64_GPR
 
 
 def read_plist(s):
     if sys.version_info.major == 3:
         return plistlib.loads(s)
     else:
         return plistlib.readPlistFromString(s)
 
 
 class CrashLog(symbolication.Symbolicator):
     class Thread:
         """Class that represents a thread in a darwin crash log"""
 
-        def __init__(self, index, app_specific_backtrace):
+        def __init__(self, index, app_specific_backtrace, arch):
             self.index = index
             self.id = index
             self.images = list()
             self.frames = list()
             self.idents = list()
             self.registers = dict()
             self.reason = None
             self.name = None
             self.queue = None
             self.crashed = False
             self.app_specific_backtrace = app_specific_backtrace
+            self.arch = arch
 
-        def dump(self, prefix):
+        def dump_registers(self, prefix=""):
+            registers_info = None
+            sorted_registers = {}
+
+            def sort_dict(d):
+                sorted_keys = list(d.keys())
+                sorted_keys.sort()
+                return {k: d[k] for k in sorted_keys}
+
+            if self.arch:
+                if "x86_64" == self.arch:
+                    registers_info = INTEL64_GPR
+                elif "arm64" in self.arch:
+                    registers_info = ARM64_GPR
+                else:
+                    print("unknown target architecture: %s" % self.arch)
+                    return
+
+                # Add registers available in the register information dictionary.
+                for reg_info in registers_info:
+                    reg_name = None
+                    if reg_info["name"] in self.registers:
+                        reg_name = reg_info["name"]
+                    elif (
+                        "generic" in reg_info and reg_info["generic"] in self.registers
+                    ):
+                        reg_name = reg_info["generic"]
+                    else:
+                        # Skip register that are present in the register information dictionary but not present in the report.
+                        continue
+
+                    reg_val = self.registers[reg_name]
+                    sorted_registers[reg_name] = reg_val
+
+                unknown_parsed_registers = {}
+                for reg_name in self.registers:
+                    if reg_name not in sorted_registers:
+                        unknown_parsed_registers[reg_name] = self.registers[reg_name]
+
+                sorted_registers.update(sort_dict(unknown_parsed_registers))
+
+            else:
+                sorted_registers = sort_dict(self.registers)
+
+            for reg_name, reg_val in sorted_registers.items():
+                print("%s    %-8s = %#16.16x" % (prefix, reg_name, reg_val))
+
+        def dump(self, prefix=""):
             if self.app_specific_backtrace:
                 print(
                     "%Application Specific Backtrace[%u] %s"
                     % (prefix, self.index, self.reason)
                 )
             else:
                 print("%sThread[%u] %s" % (prefix, self.index, self.reason))
             if self.frames:
                 print("%s  Frames:" % (prefix))
                 for frame in self.frames:
                     frame.dump(prefix + "    ")
             if self.registers:
                 print("%s  Registers:" % (prefix))
-                for reg in self.registers.keys():
-                    print("%s    %-8s = %#16.16x" % (prefix, reg, self.registers[reg]))
+                self.dump_registers(prefix)
 
         def dump_symbolicated(self, crash_log, options):
             this_thread_crashed = self.app_specific_backtrace
             if not this_thread_crashed:
                 this_thread_crashed = self.did_crash()
                 if options.crashed_only and this_thread_crashed == False:
                     return
 
class Thread:
                                         frame.index > 0,
                                     )
                                     print()
                         symbolicated_frame_address_idx += 1
                 else:
                     print(frame)
             if self.registers:
                 print()
-                for reg in self.registers.keys():
-                    print("    %-8s = %#16.16x" % (reg, self.registers[reg]))
+                self.dump_registers()
             elif self.crashed:
                 print()
                 print("No thread state (register information) available")
 
         def add_ident(self, ident):
             if ident not in self.idents:
                 self.idents.append(ident)
 
def parse_frames(self, thread, json_frames):
                         thread.frames.append(self.crashlog.Frame(idx, pc, frame_offset))
                         break
 
             idx += 1
 
     def parse_threads(self, json_threads):
         idx = 0
         for json_thread in json_threads:
-            thread = self.crashlog.Thread(idx, False)
+            thread = self.crashlog.Thread(idx, False, self.crashlog.process_arch)
             if "name" in json_thread:
                 thread.name = json_thread["name"]
                 thread.reason = json_thread["name"]
             if "id" in json_thread:
                 thread.id = int(json_thread["id"])
             if json_thread.get("triggered", False):
                 self.crashlog.crashed_thread_idx = idx
                 thread.crashed = True
def parse_asi_backtrace(self, thread, bt):
             thread.frames.append(
                 self.crashlog.Frame(int(frame_id), int(frame_addr, 0), description)
             )
 
         return True
 
     def parse_app_specific_backtraces(self, json_app_specific_bts):
         for idx, backtrace in enumerate(json_app_specific_bts):
-            thread = self.crashlog.Thread(idx, True)
+            thread = self.crashlog.Thread(idx, True, self.crashlog.process_arch)
             thread.queue = "Application Specific Backtrace"
             if self.parse_asi_backtrace(thread, backtrace):
                 self.crashlog.threads.append(thread)
 
     def parse_thread_registers(self, json_thread_state, prefix=None):
         registers = dict()
         for key, state in json_thread_state.items():
             if key == "rosetta":
def parse_normal(self, line):
             if thread_insts_match:
                 self.parse_mode = CrashLogParseMode.INSTRS
                 return
             thread_match = self.thread_regex.search(line)
             if thread_match:
                 self.app_specific_backtrace = False
                 self.parse_mode = CrashLogParseMode.THREAD
                 thread_idx = int(thread_match.group(1))
-                self.thread = self.crashlog.Thread(thread_idx, False)
+                self.thread = self.crashlog.Thread(
+                    thread_idx, False, self.crashlog.process_arch
+                )
                 return
             return
         elif line.startswith("Binary Images:"):
             self.parse_mode = CrashLogParseMode.IMAGES
             return
         elif line.startswith("Application Specific Backtrace"):
             app_backtrace_match = self.app_backtrace_regex.search(line)
             if app_backtrace_match:
                 self.parse_mode = CrashLogParseMode.THREAD
                 self.app_specific_backtrace = True
                 idx = int(app_backtrace_match.group(1))
-                self.thread = self.crashlog.Thread(idx, True)
+                self.thread = self.crashlog.Thread(
+                    idx, True, self.crashlog.process_arch
+                )
         elif line.startswith("Last Exception Backtrace:"):  # iOS
             self.parse_mode = CrashLogParseMode.THREAD
             self.app_specific_backtrace = True
             idx = 1
-            self.thread = self.crashlog.Thread(idx, True)
+            self.thread = self.crashlog.Thread(idx, True, self.crashlog.process_arch)
         self.crashlog.info_lines.append(line.strip())
 
     def parse_thread(self, line):
         if line.startswith("Thread"):
             return
         if self.null_frame_regex.search(line):
             print('warning: thread parser ignored null-frame: "%s"' % line)
             return