[lldb/crashlog] Make TextCrashLogParser more resilient to new lines

[mib]

Summary

This patch changes the parsing logic for the legacy crash report format
to avoid interrupting the parsing if there are new lines in the middle
of a section.

To do, the parser starts to skip all consecutive empty lines. If the
number of lines skipped is greater than 1, the parser considers that it
reached a new setion of the report and should reset the parsing mode to
back to normal.

Otherwise, it tries to parse the next line in the current parsing mode.
If it succeeds, the parser will also skip that line since it has already
been parsed and continue the parsing.

rdar://107022595

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

[bulbazord]

Looks alright to me. I think it would be interesting to replace a lot of the index juggling code with python Iterators that can only iterate over the lines that are not empty, but that's just a fun idea I had.

[JDevlieghere]

LGTM with a test.

[JDevlieghere]

Test?

[mib]

In D157043#4582385, @JDevlieghere wrote:

Test?

I'll do it in a follow-up.

[mib]

In D157043#4584339, @mib wrote:

In D157043#4582385, @JDevlieghere wrote:

Test?

I'll do it in a follow-up.

7602641

lldb/examples/python/crashlog.py

 
 
 class InteractiveCrashLogException(Exception):
     pass
 
 
 class CrashLogParser:
     @staticmethod
-    def create(debugger, path, verbose):
+    def create(debugger, path, options):
         data = JSONCrashLogParser.is_valid_json(path)
         if data:
-            parser = JSONCrashLogParser(debugger, path, verbose)
+            parser = JSONCrashLogParser(debugger, path, options)
             parser.data = data
             return parser
         else:
-            return TextCrashLogParser(debugger, path, verbose)
+            return TextCrashLogParser(debugger, path, options)
 
-    def __init__(self, debugger, path, verbose):
+    def __init__(self, debugger, path, options):
         self.path = os.path.expanduser(path)
-        self.verbose = verbose
+        self.options = options
         # List of DarwinImages sorted by their index.
         self.images = list()
-        self.crashlog = CrashLog(debugger, self.path, self.verbose)
+        self.crashlog = CrashLog(debugger, self.path, self.options.verbose)
 
     @abc.abstractmethod
     def parse(self):
         pass
 
 
 class JSONCrashLogParser(CrashLogParser):
     @staticmethod
def is_valid_json(path):
 
         with open(path, "r", encoding="utf-8") as f:
             buffer = f.read()
         try:
             return parse_json(buffer)
         except:
             return None
 
-    def __init__(self, debugger, path, verbose):
-        super().__init__(debugger, path, verbose)
+    def __init__(self, debugger, path, options):
+        super().__init__(debugger, path, options)
 
     def parse(self):
         try:
             self.parse_process_info(self.data)
             self.parse_images(self.data["usedImages"])
             self.parse_main_image(self.data)
             self.parse_threads(self.data["threads"])
             if "asi" in self.data:
def parse_images(self, json_images):
         for json_image in json_images:
             img_uuid = uuid.UUID(json_image["uuid"])
             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
+                low, high, name, version, img_uuid, path, self.options.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)
 
class TextCrashLogParser(CrashLogParser):
     exception_type_regex = re.compile(
         r"^Exception Type:\s+(EXC_[A-Z_]+)(?:\s+\((.*)\))?"
     )
     exception_codes_regex = re.compile(
         r"^Exception Codes:\s+(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)"
     )
     exception_extra_regex = re.compile(r"^Exception\s+.*:\s+(.*)")
 
-    def __init__(self, debugger, path, verbose):
-        super().__init__(debugger, path, verbose)
+    def __init__(self, debugger, path, options):
+        super().__init__(debugger, path, options)
         self.thread = None
         self.app_specific_backtrace = False
         self.parse_mode = CrashLogParseMode.NORMAL
         self.parsers = {
             CrashLogParseMode.NORMAL: self.parse_normal,
             CrashLogParseMode.THREAD: self.parse_thread,
             CrashLogParseMode.IMAGES: self.parse_images,
             CrashLogParseMode.THREGS: self.parse_thread_registers,
             CrashLogParseMode.SYSTEM: self.parse_system,
             CrashLogParseMode.INSTRS: self.parse_instructions,
         }
         self.symbols = {}
 
     def parse(self):
         with open(self.path, "r", encoding="utf-8") as f:
             lines = f.read().splitlines()
 
-        for line in lines:
+        idx = 0
+        lines_count = len(lines)
+        while True:
+            if idx >= lines_count:
+                break
+
+            line = lines[idx]
             line_len = len(line)
+
             if line_len == 0:
                 if self.thread:
                     if self.parse_mode == CrashLogParseMode.THREAD:
                         if self.thread.index == self.crashlog.crashed_thread_idx:
                             self.thread.reason = ""
                             if hasattr(self.crashlog, "thread_exception"):
                                 self.thread.reason += self.crashlog.thread_exception
                             if hasattr(self.crashlog, "thread_exception_data"):
                                 self.thread.reason += (
                                     " (%s)" % self.crashlog.thread_exception_data
                                 )
                         if self.app_specific_backtrace:
                             self.crashlog.backtraces.append(self.thread)
                         else:
                             self.crashlog.threads.append(self.thread)
                     self.thread = None
-                else:
-                    # only append an extra empty line if the previous line
-                    # in the info_lines wasn't empty
-                    if len(self.crashlog.info_lines) > 0 and len(
-                        self.crashlog.info_lines[-1]
-                    ):
-                        self.crashlog.info_lines.append(line)
+
+                empty_lines = 1
+                while (
+                    idx + empty_lines < lines_count
+                    and len(lines[idx + empty_lines]) == 0
+                    empty_lines = empty_lines + 1
+
+                if (
+                    empty_lines == 1
+                    and idx + empty_lines < lines_count - 1
+                    and self.parse_mode != CrashLogParseMode.NORMAL
+                ):
+                    # check if next line can be parsed with the current parse mode
+                    next_line_idx = idx + empty_lines
+                    if self.parsers[self.parse_mode](lines[next_line_idx]):
+                        # If that suceeded, skip the empty line and the next line.
+                        idx = next_line_idx + 1
+                        continue
                 self.parse_mode = CrashLogParseMode.NORMAL
-            else:
-                self.parsers[self.parse_mode](line)
+
 
+            idx = idx + 1
+
         return self.crashlog
 
     def parse_exception(self, line):
         if not line.startswith("Exception"):
-            return
+            return False
         if line.startswith("Exception Type:"):
             self.crashlog.thread_exception = line[15:].strip()
             exception_type_match = self.exception_type_regex.search(line)
             if exception_type_match:
                 exc_type, exc_signal = exception_type_match.groups()
                 self.crashlog.exception["type"] = exc_type
                 if exc_signal:
                     self.crashlog.exception["signal"] = exc_signal
         elif line.startswith("Exception Subtype:"):
             self.crashlog.thread_exception_subtype = line[18:].strip()
             if "type" in self.crashlog.exception:
                 self.crashlog.exception[
                     "subtype"
                 ] = self.crashlog.thread_exception_subtype
         elif line.startswith("Exception Codes:"):
             self.crashlog.thread_exception_data = line[16:].strip()
             if "type" not in self.crashlog.exception:
-                return
+                return False
             exception_codes_match = self.exception_codes_regex.search(line)
             if exception_codes_match:
                 self.crashlog.exception["codes"] = self.crashlog.thread_exception_data
                 code, subcode = exception_codes_match.groups()
                 self.crashlog.exception["rawCodes"] = [
                     int(code, base=16),
                     int(subcode, base=16),
                 ]
         else:
             if "type" not in self.crashlog.exception:
-                return
+                return False
             exception_extra_match = self.exception_extra_regex.search(line)
             if exception_extra_match:
                 self.crashlog.exception["message"] = exception_extra_match.group(1)
+        return True
 
     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:"):
def parse_normal(self, line):
             self.parse_mode = CrashLogParseMode.THREAD
             self.app_specific_backtrace = True
             idx = 1
             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
+            return False
         if self.null_frame_regex.search(line):
             print('warning: thread parser ignored null-frame: "%s"' % line)
-            return
+            return False
         frame_match = self.frame_regex.search(line)
         if not frame_match:
             print('error: frame regex failed for line: "%s"' % line)
-            return
+            return False
 
         frame_id = (
             frame_img_name
         ) = (
             frame_addr
         ) = frame_symbol = frame_offset = frame_file = frame_line = frame_column = None
 
         if len(frame_match.groups()) == 3:
def parse_thread(self, line):
                     "address": int(frame_addr, 0) - frame_offset_value,
                 }
             )
 
         self.thread.frames.append(
             self.crashlog.Frame(int(frame_id), int(frame_addr, 0), description)
         )
 
+        return True
+
     def parse_images(self, line):
         image_match = self.image_regex_uuid.search(line)
         if image_match:
             (
                 img_lo,
                 img_hi,
                 img_name,
                 img_version,
                 img_uuid,
                 img_path,
             ) = image_match.groups()
 
             image = self.crashlog.DarwinImage(
                 int(img_lo, 0),
                 int(img_hi, 0),
                 img_name.strip(),
                 img_version.strip() if img_version else "",
                 uuid.UUID(img_uuid),
                 img_path,
-                self.verbose,
+                self.options.verbose,
             )
             unqualified_img_name = os.path.basename(img_path)
             if unqualified_img_name in self.symbols:
                 for symbol in self.symbols[unqualified_img_name]:
                     image.symbols[symbol["name"]] = {
                         "name": symbol["name"],
                         "type": "code",
                         # NOTE: "address" is actually the symbol image offset
                         "address": symbol["address"] - int(img_lo, 0),
                     }
 
             self.images.append(image)
             self.crashlog.images.append(image)
+            return True
         else:
+            if self.options.debug:
                 print("error: image regex failed for: %s" % line)
+            return False
 
     def parse_thread_registers(self, line):
         # "r12: 0x00007fff6b5939c8  r13: 0x0000000007000006  r14: 0x0000000000002a03  r15: 0x0000000000000c00"
         reg_values = re.findall("([a-z0-9]+): (0x[0-9a-f]+)", line, re.I)
         for reg, value in reg_values:
             self.thread.registers[reg] = int(value, 16)
+        return len(reg_values) != 0
 
     def parse_system(self, line):
         self.crashlog.system_profile.append(line)
+        return True
 
     def parse_instructions(self, line):
         pass
 
 
 def usage():
     print("Usage: lldb-symbolicate.py [-n name] executable-image")
     sys.exit(0)
def SymbolicateCrashLog(crash_log, options):
 
     if crash_log.errors:
         print("Errors:")
         for error in crash_log.errors:
             print(error)
 
 
 def load_crashlog_in_scripted_process(debugger, crashlog_path, options, result):
-    crashlog = CrashLogParser.create(debugger, crashlog_path, False).parse()
+    crashlog = CrashLogParser.create(debugger, crashlog_path, options).parse()
 
     target = lldb.SBTarget()
     # 1. Try to use the user-provided target
     if options.target_path:
         target = debugger.CreateTarget(options.target_path)
         if not target:
             raise InteractiveCrashLogException(
                 "couldn't create target provided by the user (%s)" % options.target_path
if args:
                 try:
                     load_crashlog_in_scripted_process(
                         debugger, crashlog_path, options, result
                     )
                 except InteractiveCrashLogException as e:
                     result.SetError(str(e))
             else:
                 crash_log = CrashLogParser.create(
-                    debugger, crashlog_path, options.verbose
+                    debugger, crashlog_path, options
                 ).parse()
                 SymbolicateCrashLog(crash_log, options)
 
 
 if __name__ == "__main__":
     # Create a new debugger instance
     debugger = lldb.SBDebugger.Create()
     result = lldb.SBCommandReturnObject()