[lldb/crashlog] Adapt raw text crashlog exception to json format

[mib]

Summary

This patch parses CrashLog exception data from the raw
text format and adapts it to the new JSON format.

This is necessary for feature parity between the 2 formats.

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

[mib]

Change regex to support actual hex addresses

[kastiglione]

lldb/examples/python/crashlog.py

628

consider using EXC_[A-Z_]+ or EXC_.*? to not over match.

\s* (a space followed by \s*) could be replaced with \s+

[kastiglione]

lldb/examples/python/crashlog.py

708–709

is this meaning to check that the key 'type' exists, and that it is false-y? Or, should it be checking whether the key 'type' is in the dictionary (if key is not in dict)

also, this check could be hoisted out, and avoid performing the regex search if the result isn't going to be used. As it is now, the regex search happens, and the result is ignored if this condition is met.

[mib]

lldb/examples/python/crashlog.py

628

Yeah, that's better! Also, I suspect the second group to be optional, so I need to change this regex anyway

[mib]

lldb/examples/python/crashlog.py

708–709

+1

[mib]

Address @kastiglione comments

[kastiglione]

lldb/examples/python/crashlog.py

343

should this be initialized to {}?

684

if you would like to avoid the ignored group (_) then you can use non-capturing grouping (?:...) in the regex:

before:

r'^Exception Type:\s+(EXC_[A-Z_]+)(\s+\((.*)\))?'

after:

r'^Exception Type:\s+(EXC_[A-Z_]+)(?:\s+\((.*)\))?'

[mib]

• Make CrashLog.exception a dictionary at initialization
• Update exception_type regex to use a non-capture group

[kastiglione]

one typo to fix, but otherwise looks good

lldb/examples/python/crashlog.py

690–691

should this also be if 'type' in self.crashlog.exception?

typo, should be = instead of :

[mib]

Fixing typo

lldb/examples/python/crashlog.py

def __init__(self, debugger, path, verbose):
         symbolication.Symbolicator.__init__(self, debugger)
         self.path = os.path.expanduser(path)
         self.info_lines = list()
         self.system_profile = list()
         self.threads = list()
         self.backtraces = list()  # For application specific backtraces
         self.idents = list()  # A list of the required identifiers for doing all stack backtraces
         self.errors = list()
+        self.exception = None
         self.crashed_thread_idx = -1
         self.version = -1
         self.target = None
         self.verbose = verbose
 
     def dump(self):
         print("Crash Log File: %s" % (self.path))
         if self.backtraces:
class JSONCrashLogParser(CrashLogParser):
     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']
 
     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'])
 
         if 'codes' in json_exception:
             exception_extra = " ({})".format(json_exception['codes'])
         elif 'subtype' in json_exception:

 class CrashLogParseMode:
     NORMAL = 0
     THREAD = 1
     IMAGES = 2
     THREGS = 3
     SYSTEM = 4
     INSTRS = 5
 
-
 class TextCrashLogParser(CrashLogParser):
     parent_process_regex = re.compile(r'^Parent Process:\s*(.*)\[(\d+)\]')
     thread_state_regex = re.compile(r'^Thread \d+ crashed with')
     thread_instrs_regex = re.compile(r'^Thread \d+ instruction stream')
     thread_regex = re.compile(r'^Thread (\d+).*:')
     app_backtrace_regex = re.compile(r'^Application Specific Backtrace (\d+).*:')
     version = r'\(.+\)|(?:arm|x86_)[0-9a-z]+'
     frame_regex = re.compile(r'^(\d+)\s+'              # id
                              r'(.+?)\s+'               # img_name
                              r'(?:' +version+ r'\s+)?' # img_version
                              r'(0x[0-9a-fA-F]{7,})'    # addr
                              r' +(.*)'                 # offs
                              )
     null_frame_regex = re.compile(r'^\d+\s+\?\?\?\s+0{7,} +')
     image_regex_uuid = re.compile(r'(0x[0-9a-fA-F]+)'          # img_lo
                                   r'\s+-\s+'                   #   -
                                   r'(0x[0-9a-fA-F]+)\s+'       # img_hi
                                   r'[+]?(.+?)\s+'              # img_name
                                   r'(?:(' +version+ r')\s+)?'  # img_version
                                   r'(?:<([-0-9a-fA-F]+)>\s+)?' # img_uuid
                                   r'(/.*)'                     # img_path
                                  )
+    exception_type_regex = re.compile(r'^Exception Type:\s+(EXC_.*) \s*\((.*)\)')
+    exception_codes_regex = re.compile(r'^Exception Codes:\s+(0x[\d]+),\s*(0x[\d]+)')
+    exception_extra_regex = re.compile(r'^Exception\s+.*:\s+(.*)')
 
     def __init__(self, debugger, path, verbose):
         super().__init__(debugger, path, verbose)
         self.thread = None
         self.app_specific_backtrace = False
         self.parse_mode = CrashLogParseMode.NORMAL
         self.parsers = {
             CrashLogParseMode.NORMAL : self.parse_normal,
def parse(self):
                     if len(self.crashlog.info_lines) > 0 and len(self.crashlog.info_lines[-1]):
                         self.crashlog.info_lines.append(line)
                 self.parse_mode = CrashLogParseMode.NORMAL
             else:
                 self.parsers[self.parse_mode](line)
 
         return self.crashlog
 
+    def parse_exception(self, line):
+        if not line.startswith('Exception'):
+            return
+        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 = {}
+                self.crashlog.exception['type'] = exc_type
+                self.crashlog.exception['signal'] = exc_signal
+            return
+        elif line.startswith('Exception Subtype:'): # iOS
+            self.crashlog.thread_exception_subtype = line[18:].strip()
+            if self.crashlog.exception['type']:
+                self.crashlog.exception['subtype']: self.crashlog.thread_exception_subtype
+            return
+        elif line.startswith('Exception Codes:'):
+            self.crashlog.thread_exception_data = line[16:].strip()
+            exception_codes_match = self.exception_codes_regex.search(line)
+            if exception_codes_match:
+                if not self.crashlog.exception['type']:
+                    return
+                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)]
+            return
+        else:
+            exception_extra_match = self.exception_extra_regex.search(line)
+            if exception_extra_match:
+                if not self.crashlog.exception['type']:
+                    return
+                self.crashlog.exception['message'] = exception_extra_match.group(0)
+            return
 
     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('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 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 Type:'):
-            self.crashlog.thread_exception = line[15:].strip()
-            return
-        elif line.startswith('Exception Codes:'):
-            self.crashlog.thread_exception_data = line[16:].strip()
-            return
-        elif line.startswith('Exception Subtype:'): # iOS
-            self.crashlog.thread_exception_data = line[18:].strip()
+        elif line.startswith('Exception'):
+            self.parse_exception(line)
             return
         elif line.startswith('Crashed Thread:'):
             self.crashlog.crashed_thread_idx = int(line[15:].strip().split()[0])
             return
         elif line.startswith('Triggered by Thread:'): # iOS
             self.crashlog.crashed_thread_idx = int(line[20:].strip().split()[0])
             return
         elif line.startswith('Report Version:'):