Make crashlog.py less noisy

[aprantl]

Summary

For end-users there is no point in printing dSYM load errors for system frameworks, since they will all fail and there's nothing they can do about it. This patch hides them by default and shows them when --verbose is present.

[jasonmolenda]

Nice.

lldb/examples/python/crashlog.py

class DarwinImage(symbolication.Image):
 
         def __init__(
                 self,
                 text_addr_lo,
                 text_addr_hi,
                 identifier,
                 version,
                 uuid,
-                path):
+                path,
+                verbose):
             symbolication.Image.__init__(self, path, uuid)
             self.add_section(
                 symbolication.Section(
                     text_addr_lo,
                     text_addr_hi,
                     "__TEXT"))
             self.identifier = identifier
             self.version = version
+            self.verbose = verbose
+
+        def show_symbol_progress(self):
+            """
+            Hide progress output and errors from system frameworks as they are plentiful.
+            """
+            if self.verbose:
+                return True
+            return not (self.path.startswith("/System/Library/") or
+                        self.path.startswith("/usr/lib/"))
+
 
         def find_matching_slice(self):
             dwarfdump_cmd_output = subprocess.check_output(
                 'dwarfdump --uuid "%s"' % self.path, shell=True).decode("utf-8")
             self_uuid = self.get_uuid()
             for line in dwarfdump_cmd_output.splitlines():
                 match = self.dwarfdump_uuid_regex.search(line)
                 if match:
                     dwarf_uuid_str = match.group(1)
                     dwarf_uuid = uuid.UUID(dwarf_uuid_str)
                     if self_uuid == dwarf_uuid:
                         self.resolved_path = self.path
                         self.arch = match.group(2)
                         return True
             if not self.resolved_path:
                 self.unavailable = True
+                if self.show_symbol_progress():
                     print(("error\n    error: unable to locate '%s' with UUID %s"
                            % (self.path, self.get_normalized_uuid_string())))
                 return False
 
         def locate_module_and_debug_symbols(self):
             # Don't load a module twice...
             if self.resolved:
                 return True
             # Mark this as resolved so we don't keep trying
             self.resolved = True
             uuid_str = self.get_normalized_uuid_string()
+            if self.show_symbol_progress():
                 print('Getting symbols for %s %s...' % (uuid_str, self.path), end=' ')
             if os.path.exists(self.dsymForUUIDBinary):
                 dsym_for_uuid_command = '%s %s' % (
                     self.dsymForUUIDBinary, uuid_str)
                 s = subprocess.check_output(dsym_for_uuid_command, shell=True)
                 if s:
                     try:
                         plist_root = read_plist(s)
                     except:
class DarwinImage(symbolication.Image):
             if (self.resolved_path and os.path.exists(self.resolved_path)) or (
                     self.path and os.path.exists(self.path)):
                 print('ok')
                 return True
             else:
                 self.unavailable = True
             return False
 
-    def __init__(self, path):
+    def __init__(self, path, verbose):
         """CrashLog constructor that take a path to a darwin crash log file"""
         symbolication.Symbolicator.__init__(self)
         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.crashed_thread_idx = -1
         self.version = -1
         self.error = None
         self.target = None
+        self.verbose = verbose
         # With possible initial component of ~ or ~user replaced by that user's
         # home directory.
         try:
             f = open(self.path)
         except IOError:
             self.error = 'error: cannot open "%s"' % self.path
             return
 
def __init__(self, path, verbose):
                 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 = 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)
+                                                 uuid.UUID(img_uuid), img_path,
+                                                 self.verbose)
                     self.images.append(image)
                 else:
                     print("error: image regex failed for: %s" % line)
 
             elif parse_mode == PARSE_MODE_THREGS:
                 stripped_line = line.strip()
                 # "r12: 0x00007fff6b5939c8  r13: 0x0000000007000006  r14: 0x0000000000002a03  r15: 0x0000000000000c00"
                 reg_values = re.findall(
def create_target(self):
                         if self.target:
                             return self.target  # success
             print('crashlog.create_target()...3')
             for image in self.images:
                 self.target = image.create_target()
                 if self.target:
                     return self.target  # success
             print('crashlog.create_target()...4')
-            print('error: unable to locate any executables from the crash log')
+            print('error: Unable to locate any executables from the crash log.')
+            print('       Try loading the executable into lldb before running crashlog')
+            print('       and/or make sure the .dSYM bundles can be found by Spotlight.')
         return self.target
 
     def get_target(self):
         return self.target
 
 
 def usage():
     print("Usage: lldb-symbolicate.py [-n name] executable-image")
def interactive_crashlogs(options, args):
     crash_log_files = list()
     for arg in args:
         for resolved_path in glob.glob(arg):
             crash_log_files.append(resolved_path)
 
     crash_logs = list()
     for crash_log_file in crash_log_files:
         # print 'crash_log_file = "%s"' % crash_log_file
-        crash_log = CrashLog(crash_log_file)
+        crash_log = CrashLog(crash_log_file, options.verbose)
         if crash_log.error:
             print(crash_log.error)
             continue
         if options.debug:
             crash_log.dump()
         if not crash_log.images:
             print('error: no images in crash log "%s"' % (crash_log))
             continue
if options.debug_delay > 0:
         time.sleep(options.debug_delay)
     error = lldb.SBError()
 
     if args:
         if options.interactive:
             interactive_crashlogs(options, args)
         else:
             for crash_log_file in args:
-                crash_log = CrashLog(crash_log_file)
+                crash_log = CrashLog(crash_log_file, options.verbose)
                 SymbolicateCrashLog(crash_log, options)
 if __name__ == '__main__':
     # Create a new debugger instance
     lldb.debugger = lldb.SBDebugger.Create()
     SymbolicateCrashLogs(sys.argv[1:])
     lldb.SBDebugger.Destroy(lldb.debugger)
 elif getattr(lldb, 'debugger', None):
     lldb.debugger.HandleCommand(
         'command script add -f lldb.macosx.crashlog.Symbolicate crashlog')
     lldb.debugger.HandleCommand(
         'command script add -f lldb.macosx.crashlog.save_crashlog save_crashlog')
     print('"crashlog" and "save_crashlog" command installed, use the "--help" option for detailed help')