[crashlog] Pass the debugger around instead of relying on lldb.debugger

[JDevlieghere]

Summary

The lldb.debugger et al convenience variables are only available from the interactive script interpreter. In all other scenarios, they are None (since fc1fd6bf9fcfac412b10b4193805ec5de0e8df57) before that they were default initialized.

The crashlog script was hacking around that by setting the lldb.debugger to a newly created debugger instance when running outside of the script interpreter, which works fine until lldb creates a script interpreter instance under the hood and clears the variables. This was resulting in an AttributeError when invoking the script directly (from outside of lldb):

AttributeError: 'NoneType' object has no attribute 'GetSourceManager'

This patch fixes that by passing around the debugger instance.

rdar://64775776

[JDevlieghere]

Fix partial upload.

[vsk]

lldb/examples/python/crashlog.py

853

Why does crashlog.Symbolicate accept a debugger parameter?

[JDevlieghere]

lldb/examples/python/crashlog.py

853

It's the signature lldb expects for command script add, but good point, we shouldn't use lldb.debugger and just forward the one we're passed in.

[JDevlieghere]

Address @vsk's comment

[vsk]

Looks good to me.

lldb/examples/python/crashlog.py

class Thread:
                         print('[%3u] %s' % (frame_idx, symbolicated_frame_address))
                         if (options.source_all or self.did_crash(
                         )) and display_frame_idx < options.source_frames and options.source_context:
                             source_context = options.source_context
                             line_entry = symbolicated_frame_address.get_symbol_context().line_entry
                             if line_entry.IsValid():
                                 strm = lldb.SBStream()
                                 if line_entry:
-                                    lldb.debugger.GetSourceManager().DisplaySourceLinesWithLineNumbers(
+                                    crash_log.debugger.GetSourceManager().DisplaySourceLinesWithLineNumbers(
                                         line_entry.file, line_entry.line, source_context, source_context, "->", strm)
                                 source_text = strm.GetData()
                                 if source_text:
                                     # Indent the source a bit
                                     indent_str = '    '
                                     join_str = '\n' + indent_str
                                     print('%s%s' % (indent_str, join_str.join(source_text.split('\n'))))
                         if symbolicated_frame_address_idx == 0:
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, verbose):
+    def __init__(self, debugger, path, verbose):
         """CrashLog constructor that take a path to a darwin crash log file"""
-        symbolication.Symbolicator.__init__(self)
+        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.crashed_thread_idx = -1
         self.version = -1
def create_target(self):
                 return self.target
             # We weren't able to open the main executable as, but we can still
             # symbolicate
             print('crashlog.create_target()...2')
             if self.idents:
                 for ident in self.idents:
                     image = self.find_image_with_identifier(ident)
                     if image:
-                        self.target = image.create_target()
+                        self.target = image.create_target(self.debugger)
                         if self.target:
                             return self.target  # success
             print('crashlog.create_target()...3')
             for image in self.images:
-                self.target = image.create_target()
+                self.target = image.create_target(self.debugger)
                 if self.target:
                     return self.target  # success
             print('crashlog.create_target()...4')
             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
 
image_regex_uuid = re.compile(r'(0x[0-9a-fA-F]+)'            # img_lo
                                   r'(0x[0-9a-fA-F]+)'     r'\s+' # img_hi
                                   r'[+]?(.+?)'            r'\s+' # img_name
                                   r'(' +version+ ')?'            # img_version
                                   r'(<([-0-9a-fA-F]+)>\s+)?'     # img_uuid
                                   r'(/.*)'                       # img_path
                                  )
 
 
-    def __init__(self, path, verbose):
+    def __init__(self, debugger, path, verbose):
         self.path = os.path.expanduser(path)
         self.verbose = verbose
         self.thread = None
         self.app_specific_backtrace = False
-        self.crashlog = CrashLog(self.path, self.verbose)
+        self.crashlog = CrashLog(debugger, self.path, self.verbose)
         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,
def do_image(self, line):
                                 print('[%u] ' % (crash_log_idx), image)
         else:
             for crash_log in self.crash_logs:
                 for (image_idx, image) in enumerate(crash_log.images):
                     print('[%u] %s' % (image_idx, image))
         return False
 
 
-def interactive_crashlogs(options, args):
+def interactive_crashlogs(debugger, 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:
         try:
-            crash_log = CrashLogParser(crash_log_file, options.verbose).parse()
+            crash_log = CrashLogParser(debugger, crash_log_file, options.verbose).parse()
         except Exception as e:
             print(e)
             continue
         if options.debug:
             crash_log.dump()
         if not crash_log.images:
             print('error: no images in crash log "%s"' % (crash_log))
             continue
if target:
                          module.file.fullpath))
         out_file.close()
     else:
         result.PutCString("error: invalid target")
 
 
 def Symbolicate(debugger, command, result, dict):
     try:
-        SymbolicateCrashLogs(shlex.split(command))
+        SymbolicateCrashLogs(debugger, shlex.split(command))
     except Exception as e:
         result.PutCString("error: python exception: %s" % e)
 
 
 def SymbolicateCrashLog(crash_log, options):
     if options.debug:
         crash_log.dump()
     if not crash_log.images:
         print('error: no images in crash log')
         return
if add_interactive_options:
             '-i',
             '--interactive',
             action='store_true',
             help='parse all crash logs and enter interactive mode',
             default=False)
     return option_parser
 
 
-def SymbolicateCrashLogs(command_args):
+def SymbolicateCrashLogs(debugger, command_args):
     description = '''Symbolicate one or more darwin crash log files to provide source file and line information,
 inlined stack frames back to the concrete functions, and disassemble the location of the crash
 for the first frame of the crashed thread.
 If this script is imported into the LLDB command interpreter, a "crashlog" command will be added to the interpreter
 for use at the LLDB command line. After a crash log has been parsed and symbolicated, a target will have been
 created that has all of the shared libraries loaded at the load addresses found in the crash log file. This allows
 you to explore the program as if it were stopped at the locations described in the crash log and functions can
 be disassembled and lookups can be performed using the addresses found in the crash log.'''
be disassembled and lookups can be performed using the addresses found in the crash log.'''
 
     if options.debug_delay > 0:
         print("Waiting %u seconds for debugger to attach..." % options.debug_delay)
         time.sleep(options.debug_delay)
     error = lldb.SBError()
 
     if args:
         if options.interactive:
-            interactive_crashlogs(options, args)
+            interactive_crashlogs(debugger, options, args)
         else:
             for crash_log_file in args:
-                crash_log_parser = CrashLogParser(crash_log_file, options.verbose)
+                crash_log_parser = CrashLogParser(debugger, crash_log_file, options.verbose)
                 crash_log = crash_log_parser.parse()
                 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)
+    debugger = lldb.SBDebugger.Create()
+    SymbolicateCrashLogs(debugger, sys.argv[1:])
+    lldb.SBDebugger.Destroy(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')

lldb/examples/python/symbolication.py

def get_uuid(self):
             self.uuid = uuid.UUID(self.module.GetUUIDString())
         return self.uuid
 
     def get_normalized_uuid_string(self):
         if self.uuid:
             return str(self.uuid).upper()
         return None
 
-    def create_target(self):
+    def create_target(self, debugger):
         '''Create a target using the information in this Image object.'''
         if self.unavailable:
             return None
 
         if self.locate_module_and_debug_symbols():
             resolved_path = self.get_resolved_path()
             path_spec = lldb.SBFileSpec(resolved_path)
             error = lldb.SBError()
-            target = lldb.debugger.CreateTarget(
+            target = debugger.CreateTarget(
                 resolved_path, self.arch, None, False, error)
             if target:
                 self.module = target.FindModule(path_spec)
                 if self.has_section_load_info():
                     err = self.load_module(target)
                     if err:
                         print('ERROR: ', err)
                 return target
             else:
                 print('error: unable to create a valid target for (%s) "%s"' % (self.arch, self.path))
         else:
             print('error: unable to locate main executable (%s) "%s"' % (self.arch, self.path))
         return None
 
 
 class Symbolicator:
 
-    def __init__(self):
+    def __init__(self, debugger):
         """A class the represents the information needed to symbolicate addresses in a program"""
+        self.debugger = debugger
         self.target = None
         self.images = list()  # a list of images to be used when symbolicating
         self.addr_mask = 0xffffffffffffffff
 
     @classmethod
     def InitWithSBTarget(cls, target):
         obj = cls()
         obj.target = target
def find_image_containing_load_addr(self, load_addr):
         return None
 
     def create_target(self):
         if self.target:
             return self.target
 
         if self.images:
             for image in self.images:
-                self.target = image.create_target()
+                self.target = image.create_target(self.debugger)
                 if self.target:
                     if self.target.GetAddressByteSize() == 4:
                         triple = self.target.triple
                         if triple:
                             arch = triple.split('-')[0]
                             if "arm" in arch:
                                 self.addr_mask = 0xfffffffffffffffe
                     return self.target
for sect in module.section_iter():
         print_module_section(sect, depth)
 
 
 def print_module_symbols(module):
     for sym in module:
         print(sym)
 
 
-def Symbolicate(command_args):
+def Symbolicate(debugger, command_args):
 
     usage = "usage: %prog [options] <addr1> [addr2 ...]"
     description = '''Symbolicate one or more addresses using LLDB's python scripting API..'''
     parser = optparse.OptionParser(
         description=description,
         prog='crashlog.py',
         usage=usage)
     parser.add_option(
parser.add_option(
         type='string',
         action='append',
         dest='section_strings',
         help='specify <sect-name>=<start-addr> or <sect-name>=<start-addr>-<end-addr>')
     try:
         (options, args) = parser.parse_args(command_args)
     except:
         return
-    symbolicator = Symbolicator()
+    symbolicator = Symbolicator(debugger)
     images = list()
     if options.file:
         image = Image(options.file)
         image.arch = options.arch
         # Add any sections that were specified with one or more --section
         # options
         if options.section_strings:
             for section_str in options.section_strings:
if target:
             for symbolicated_addr in symbolicated_addrs:
                 print(symbolicated_addr)
             print()
     else:
         print('error: no target for %s' % (symbolicator))
 
 if __name__ == '__main__':
     # Create a new debugger instance
-    lldb.debugger = lldb.SBDebugger.Create()
-    Symbolicate(sys.argv[1:])
+    debugger = lldb.SBDebugger.Create()
+    Symbolicate(debugger, sys.argv[1:])
+    SBDebugger.Destroy(debugger)