vendor/lldb/lldb-trunk-r290819

1 files changed, 221 insertions, 134 deletions

diff --git a/examples/python/symbolication.py b/examples/python/symbolication.py
index 88846c99b3a4..b655ad0d179d 100755
--- a/examples/python/symbolication.py
+++ b/examples/python/symbolication.py
@@ -11,13 +11,13 @@
 #   "crashlog" command installed, type "crashlog --help" for detailed help
 #   (lldb) crashlog ~/Library/Logs/DiagnosticReports/a.crash
 #
-# The benefit of running the crashlog command inside lldb in the 
-# embedded python interpreter is when the command completes, there 
+# The benefit of running the crashlog command inside lldb in the
+# embedded python interpreter is when the command completes, there
 # will be a target with all of the files loaded at the locations
 # described in the crash log. Only the files that have stack frames
 # in the backtrace will be loaded unless the "--load-all" option
 # has been specified. This allows users to explore the program in the
-# state it was in right at crash time. 
+# state it was in right at crash time.
 #
 # On MacOSX csh, tcsh:
 #   ( setenv PYTHONPATH /path/to/LLDB.framework/Resources/Python ; ./crashlog.py ~/Library/Logs/DiagnosticReports/a.crash )
@@ -37,16 +37,23 @@ import sys
 import time
 import uuid
 
+
 class Address:
     """Class that represents an address that will be symbolicated"""
+
     def __init__(self, target, load_addr):
         self.target = target
-        self.load_addr = load_addr # The load address that this object represents
-        self.so_addr = None # the resolved lldb.SBAddress (if any), named so_addr for section/offset address
-        self.sym_ctx = None # The cached symbol context for this address
-        self.description = None # Any original textual description of this address to be used as a backup in case symbolication fails
-        self.symbolication = None # The cached symbolicated string that describes this address
+        self.load_addr = load_addr  # The load address that this object represents
+        # the resolved lldb.SBAddress (if any), named so_addr for
+        # section/offset address
+        self.so_addr = None
+        self.sym_ctx = None  # The cached symbol context for this address
+        # Any original textual description of this address to be used as a
+        # backup in case symbolication fails
+        self.description = None
+        self.symbolication = None  # The cached symbolicated string that describes this address
         self.inlined = False
+
     def __str__(self):
         s = "%#16.16x" % (self.load_addr)
         if self.symbolication:
@@ -58,18 +65,19 @@ class Address:
         return s
 
     def resolve_addr(self):
-        if self.so_addr == None:
-            self.so_addr = self.target.ResolveLoadAddress (self.load_addr)
+        if self.so_addr is None:
+            self.so_addr = self.target.ResolveLoadAddress(self.load_addr)
         return self.so_addr
 
     def is_inlined(self):
         return self.inlined
-    
+
     def get_symbol_context(self):
-        if self.sym_ctx == None:
+        if self.sym_ctx is None:
             sb_addr = self.resolve_addr()
             if sb_addr:
-                self.sym_ctx = self.target.ResolveSymbolContextForAddress (sb_addr, lldb.eSymbolContextEverything)
+                self.sym_ctx = self.target.ResolveSymbolContextForAddress(
+                    sb_addr, lldb.eSymbolContextEverything)
             else:
                 self.sym_ctx = lldb.SBSymbolContext()
         return self.sym_ctx
@@ -82,9 +90,9 @@ class Address:
                 return function.GetInstructions(self.target)
             return sym_ctx.GetSymbol().GetInstructions(self.target)
         return None
-    
-    def symbolicate(self, verbose = False):
-        if self.symbolication == None:
+
+    def symbolicate(self, verbose=False):
+        if self.symbolication is None:
             self.symbolication = ''
             self.inlined = False
             sym_ctx = self.get_symbol_context()
@@ -101,27 +109,32 @@ class Address:
                     block = sym_ctx.GetBlock()
                     line_entry = sym_ctx.GetLineEntry()
                     symbol = sym_ctx.GetSymbol()
-                    inlined_block = block.GetContainingInlinedBlock();
+                    inlined_block = block.GetContainingInlinedBlock()
                     if function:
                         self.symbolication += function.GetName()
 
                         if inlined_block:
                             self.inlined = True
-                            self.symbolication += ' [inlined] ' + inlined_block.GetInlinedName();
-                            block_range_idx = inlined_block.GetRangeIndexForBlockAddress (self.so_addr)
+                            self.symbolication += ' [inlined] ' + \
+                                inlined_block.GetInlinedName()
+                            block_range_idx = inlined_block.GetRangeIndexForBlockAddress(
+                                self.so_addr)
                             if block_range_idx < lldb.UINT32_MAX:
-                                block_range_start_addr = inlined_block.GetRangeStartAddress (block_range_idx)
-                                function_start_load_addr = block_range_start_addr.GetLoadAddress (self.target)
+                                block_range_start_addr = inlined_block.GetRangeStartAddress(
+                                    block_range_idx)
+                                function_start_load_addr = block_range_start_addr.GetLoadAddress(
+                                    self.target)
                         if function_start_load_addr == -1:
-                            function_start_load_addr = function.GetStartAddress().GetLoadAddress (self.target)
+                            function_start_load_addr = function.GetStartAddress().GetLoadAddress(self.target)
                     elif symbol:
                         self.symbolication += symbol.GetName()
-                        function_start_load_addr = symbol.GetStartAddress().GetLoadAddress (self.target)
+                        function_start_load_addr = symbol.GetStartAddress().GetLoadAddress(self.target)
                     else:
                         self.symbolication = ''
                         return False
 
-                    # Dump the offset from the current function or symbol if it is non zero
+                    # Dump the offset from the current function or symbol if it
+                    # is non zero
                     function_offset = self.load_addr - function_start_load_addr
                     if function_offset > 0:
                         self.symbolication += " + %u" % (function_offset)
@@ -135,38 +148,44 @@ class Address:
                             self.symbolication += ' at %s' % line_entry.GetFileSpec()
                         else:
                             self.symbolication += ' at %s' % line_entry.GetFileSpec().GetFilename()
-                        self.symbolication += ':%u' % line_entry.GetLine ()
+                        self.symbolication += ':%u' % line_entry.GetLine()
                         column = line_entry.GetColumn()
                         if column > 0:
                             self.symbolication += ':%u' % column
                     return True
         return False
 
+
 class Section:
     """Class that represents an load address range"""
     sect_info_regex = re.compile('(?P<name>[^=]+)=(?P<range>.*)')
     addr_regex = re.compile('^\s*(?P<start>0x[0-9A-Fa-f]+)\s*$')
-    range_regex = re.compile('^\s*(?P<start>0x[0-9A-Fa-f]+)\s*(?P<op>[-+])\s*(?P<end>0x[0-9A-Fa-f]+)\s*$')
+    range_regex = re.compile(
+        '^\s*(?P<start>0x[0-9A-Fa-f]+)\s*(?P<op>[-+])\s*(?P<end>0x[0-9A-Fa-f]+)\s*$')
 
-    def __init__(self, start_addr = None, end_addr = None, name = None):
+    def __init__(self, start_addr=None, end_addr=None, name=None):
         self.start_addr = start_addr
         self.end_addr = end_addr
         self.name = name
-    
+
     @classmethod
     def InitWithSBTargetAndSBSection(cls, target, section):
         sect_load_addr = section.GetLoadAddress(target)
         if sect_load_addr != lldb.LLDB_INVALID_ADDRESS:
-            obj = cls(sect_load_addr, sect_load_addr + section.size, section.name)
+            obj = cls(
+                sect_load_addr,
+                sect_load_addr +
+                section.size,
+                section.name)
             return obj
         else:
             return None
-        
+
     def contains(self, addr):
-        return self.start_addr <= addr and addr < self.end_addr;
-    
+        return self.start_addr <= addr and addr < self.end_addr
+
     def set_from_string(self, s):
-        match = self.sect_info_regex.match (s)
+        match = self.sect_info_regex.match(s)
         if match:
             self.name = match.group('name')
             range_str = match.group('range')
@@ -192,22 +211,24 @@ class Section:
         print '<name>=<base>-<end>  __TEXT=0x123000-0x124000    Section from base address and end address'
         print '<name>=<base>+<size> __TEXT=0x123000+0x1000      Section from base address and size'
         return False
-        
+
     def __str__(self):
         if self.name:
-            if self.end_addr != None:
-                if self.start_addr != None:
-                    return "%s=[0x%16.16x - 0x%16.16x)" % (self.name, self.start_addr, self.end_addr)
+            if self.end_addr is not None:
+                if self.start_addr is not None:
+                    return "%s=[0x%16.16x - 0x%16.16x)" % (
+                        self.name, self.start_addr, self.end_addr)
             else:
-                if self.start_addr != None:
+                if self.start_addr is not None:
                     return "%s=0x%16.16x" % (self.name, self.start_addr)
             return self.name
         return "<invalid>"
-            
+
+
 class Image:
     """A class that represents an executable image and any associated data"""
-    
-    def __init__(self, path, uuid = None):
+
+    def __init__(self, path, uuid=None):
         self.path = path
         self.resolved_path = None
         self.resolved = False
@@ -220,7 +241,7 @@ class Image:
         self.module = None
         self.symfile = None
         self.slide = None
-        
+
     @classmethod
     def InitWithSBTargetAndSBModule(cls, target, module):
         '''Initialize this Image object with a module from a target.'''
@@ -229,15 +250,16 @@ class Image:
         obj.resolved = True
         obj.arch = module.triple
         for section in module.sections:
-            symb_section = Section.InitWithSBTargetAndSBSection(target, section)
+            symb_section = Section.InitWithSBTargetAndSBSection(
+                target, section)
             if symb_section:
-                obj.section_infos.append (symb_section)
+                obj.section_infos.append(symb_section)
         obj.arch = module.triple
         obj.module = module
         obj.symfile = None
         obj.slide = None
         return obj
-        
+
     def dump(self, prefix):
         print "%s%s" % (prefix, self)
 
@@ -254,7 +276,7 @@ class Image:
         print 'module = %s' % (self.module)
         print 'symfile = "%s"' % (self.symfile)
         print 'slide = %i (0x%x)' % (self.slide, self.slide)
-        
+
     def __str__(self):
         s = ''
         if self.uuid:
@@ -268,15 +290,15 @@ class Image:
             s += "%s " % (resolved_path)
         for section_info in self.section_infos:
             s += ", %s" % (section_info)
-        if self.slide != None:
+        if self.slide is not None:
             s += ', slide = 0x%16.16x' % self.slide
-        return s        
-    
+        return s
+
     def add_section(self, section):
-        #print "added '%s' to '%s'" % (section, self.path)
-        self.section_infos.append (section)
-        
-    def get_section_containing_load_addr (self, load_addr):
+        # print "added '%s' to '%s'" % (section, self.path)
+        self.section_infos.append(section)
+
+    def get_section_containing_load_addr(self, load_addr):
         for section_info in self.section_infos:
             if section_info.contains(load_addr):
                 return section_info
@@ -299,13 +321,13 @@ class Image:
         if self.symfile:
             return os.path.basename(self.symfile)
         return None
-    
+
     def has_section_load_info(self):
-        return self.section_infos or self.slide != None
-    
+        return self.section_infos or self.slide is not None
+
     def load_module(self, target):
         if self.unavailable:
-            return None # We already warned that we couldn't find this module, so don't return an error string
+            return None  # We already warned that we couldn't find this module, so don't return an error string
         # Load this module into "target" using the section infos to
         # set the section load addresses
         if self.has_section_load_info():
@@ -315,9 +337,11 @@ class Image:
                         num_sections_loaded = 0
                         for section_info in self.section_infos:
                             if section_info.name:
-                                section = self.module.FindSection (section_info.name)
+                                section = self.module.FindSection(
+                                    section_info.name)
                                 if section:
-                                    error = target.SetSectionLoadAddress (section, section_info.start_addr)
+                                    error = target.SetSectionLoadAddress(
+                                        section, section_info.start_addr)
                                     if error.Success():
                                         num_sections_loaded += 1
                                     else:
@@ -325,11 +349,13 @@ class Image:
                                 else:
                                     return 'error: unable to find the section named "%s"' % section_info.name
                             else:
-                                return 'error: unable to find "%s" section in "%s"' % (range.name, self.get_resolved_path())
+                                return 'error: unable to find "%s" section in "%s"' % (
+                                    range.name, self.get_resolved_path())
                         if num_sections_loaded == 0:
                             return 'error: no sections were successfully loaded'
                     else:
-                        err = target.SetModuleLoadAddress(self.module, self.slide)
+                        err = target.SetModuleLoadAddress(
+                            self.module, self.slide)
                         if err.Fail():
                             return err.GetCString()
                     return None
@@ -339,30 +365,33 @@ class Image:
                 return 'error: invalid target'
         else:
             return 'error: no section infos'
-        
+
     def add_module(self, target):
         '''Add the Image described in this object to "target" and load the sections if "load" is True.'''
         if target:
-            # Try and find using UUID only first so that paths need not match up
+            # Try and find using UUID only first so that paths need not match
+            # up
             uuid_str = self.get_normalized_uuid_string()
             if uuid_str:
-                self.module = target.AddModule (None, None, uuid_str)
+                self.module = target.AddModule(None, None, uuid_str)
             if not self.module:
-                self.locate_module_and_debug_symbols ()
+                self.locate_module_and_debug_symbols()
                 if self.unavailable:
                     return None
                 resolved_path = self.get_resolved_path()
-                self.module = target.AddModule (resolved_path, self.arch, uuid_str, self.symfile)
+                self.module = target.AddModule(
+                    resolved_path, self.arch, uuid_str, self.symfile)
             if not self.module:
-                return 'error: unable to get module for (%s) "%s"' % (self.arch, self.get_resolved_path())
+                return 'error: unable to get module for (%s) "%s"' % (
+                    self.arch, self.get_resolved_path())
             if self.has_section_load_info():
                 return self.load_module(target)
             else:
-                return None # No sections, the module was added to the target, so success
+                return None  # No sections, the module was added to the target, so success
         else:
             return 'error: invalid target'
-    
-    def locate_module_and_debug_symbols (self):
+
+    def locate_module_and_debug_symbols(self):
         # By default, just use the paths that were supplied in:
         # self.path
         # self.resolved_path
@@ -371,7 +400,7 @@ class Image:
         # Subclasses can inherit from this class and override this function
         self.resolved = True
         return True
-    
+
     def get_uuid(self):
         if not self.uuid and self.module:
             self.uuid = uuid.UUID(self.module.GetUUIDString())
@@ -387,12 +416,13 @@ class Image:
         if self.unavailable:
             return None
 
-        if self.locate_module_and_debug_symbols ():
-            resolved_path = self.get_resolved_path();
-            path_spec = lldb.SBFileSpec (resolved_path)
+        if self.locate_module_and_debug_symbols():
+            resolved_path = self.get_resolved_path()
+            path_spec = lldb.SBFileSpec(resolved_path)
             #result.PutCString ('plist[%s] = %s' % (uuid, self.plist))
             error = lldb.SBError()
-            target = lldb.debugger.CreateTarget (resolved_path, self.arch, None, False, error);
+            target = lldb.debugger.CreateTarget(
+                resolved_path, self.arch, None, False, error)
             if target:
                 self.module = target.FindModule(path_spec)
                 if self.has_section_load_info():
@@ -405,20 +435,21 @@ class Image:
         else:
             print 'error: unable to locate main executable (%s) "%s"' % (self.arch, self.path)
         return None
-    
+
+
 class Symbolicator:
 
     def __init__(self):
         """A class the represents the information needed to symbolicate addresses in a program"""
         self.target = None
-        self.images = list() # a list of images to be used when symbolicating
+        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
-        obj.images = list();
+        obj.images = list()
         triple = target.triple
         if triple:
             arch = triple.split('-')[0]
@@ -429,7 +460,7 @@ class Symbolicator:
             image = Image.InitWithSBTargetAndSBModule(target, module)
             obj.images.append(image)
         return obj
-        
+
     def __str__(self):
         s = "Symbolicator:\n"
         if self.target:
@@ -441,7 +472,7 @@ class Symbolicator:
         for image in self.images:
             s += '    %s\n' % (image)
         return s
-    
+
     def find_images_with_identifier(self, identifier):
         images = list()
         for image in self.images:
@@ -454,20 +485,20 @@ class Symbolicator:
                 if regex.match(image.identifier):
                     images.append(image)
         return images
-        
+
     def find_image_containing_load_addr(self, load_addr):
         for image in self.images:
-            if image.get_section_containing_load_addr (load_addr):
+            if image.get_section_containing_load_addr(load_addr):
                 return image
         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()
                 if self.target:
                     if self.target.GetAddressByteSize() == 4:
                         triple = self.target.triple
@@ -477,9 +508,8 @@ class Symbolicator:
                                 self.addr_mask = 0xfffffffffffffffe
                     return self.target
         return None
-    
-            
-    def symbolicate(self, load_addr, verbose = False):
+
+    def symbolicate(self, load_addr, verbose=False):
         if not self.target:
             self.create_target()
         if self.target:
@@ -493,51 +523,60 @@ class Symbolicator:
             # that a load address belongs to and lazily load its module in the
             # target, but we shouldn't do any of this if we have a live process
             if not live_process:
-                image = self.find_image_containing_load_addr (load_addr)
+                image = self.find_image_containing_load_addr(load_addr)
                 if image:
-                    image.add_module (self.target)
+                    image.add_module(self.target)
             symbolicated_address = Address(self.target, load_addr)
-            if symbolicated_address.symbolicate (verbose):
+            if symbolicated_address.symbolicate(verbose):
                 if symbolicated_address.so_addr:
                     symbolicated_addresses = list()
                     symbolicated_addresses.append(symbolicated_address)
                     # See if we were able to reconstruct anything?
-                    while 1:
+                    while True:
                         inlined_parent_so_addr = lldb.SBAddress()
-                        inlined_parent_sym_ctx = symbolicated_address.sym_ctx.GetParentOfInlinedScope (symbolicated_address.so_addr, inlined_parent_so_addr)
+                        inlined_parent_sym_ctx = symbolicated_address.sym_ctx.GetParentOfInlinedScope(
+                            symbolicated_address.so_addr, inlined_parent_so_addr)
                         if not inlined_parent_sym_ctx:
                             break
                         if not inlined_parent_so_addr:
                             break
 
-                        symbolicated_address = Address(self.target, inlined_parent_so_addr.GetLoadAddress(self.target))
+                        symbolicated_address = Address(
+                            self.target, inlined_parent_so_addr.GetLoadAddress(
+                                self.target))
                         symbolicated_address.sym_ctx = inlined_parent_sym_ctx
                         symbolicated_address.so_addr = inlined_parent_so_addr
-                        symbolicated_address.symbolicate (verbose)
-            
+                        symbolicated_address.symbolicate(verbose)
+
                         # push the new frame onto the new frame stack
-                        symbolicated_addresses.append (symbolicated_address)
-        
+                        symbolicated_addresses.append(symbolicated_address)
+
                     if symbolicated_addresses:
                         return symbolicated_addresses
         else:
             print 'error: no target in Symbolicator'
         return None
-            
-        
-def disassemble_instructions (target, instructions, pc, insts_before_pc, insts_after_pc, non_zeroeth_frame):
+
+
+def disassemble_instructions(
+        target,
+        instructions,
+        pc,
+        insts_before_pc,
+        insts_after_pc,
+        non_zeroeth_frame):
     lines = list()
     pc_index = -1
     comment_column = 50
     for inst_idx, inst in enumerate(instructions):
-        inst_pc = inst.GetAddress().GetLoadAddress(target);
+        inst_pc = inst.GetAddress().GetLoadAddress(target)
         if pc == inst_pc:
             pc_index = inst_idx
-        mnemonic = inst.GetMnemonic (target)
-        operands =  inst.GetOperands (target)
-        comment =  inst.GetComment (target)
+        mnemonic = inst.GetMnemonic(target)
+        operands = inst.GetOperands(target)
+        comment = inst.GetComment(target)
         #data = inst.GetData (target)
-        lines.append ("%#16.16x: %8s %s" % (inst_pc, mnemonic, operands))
+        lines.append("%#16.16x: %8s %s" % (inst_pc, mnemonic, operands))
         if comment:
             line_len = len(lines[-1])
             if line_len < comment_column:
@@ -545,7 +584,8 @@ def disassemble_instructions (target, instructions, pc, insts_before_pc, insts_a
                 lines[-1] += "; %s" % comment
 
     if pc_index >= 0:
-        # If we are disassembling the non-zeroeth frame, we need to backup the PC by 1
+        # If we are disassembling the non-zeroeth frame, we need to backup the
+        # PC by 1
         if non_zeroeth_frame and pc_index > 0:
             pc_index = pc_index - 1
         if insts_before_pc == -1:
@@ -560,81 +600,128 @@ def disassemble_instructions (target, instructions, pc, insts_before_pc, insts_a
             end_idx = pc_index + insts_after_pc
         if end_idx > inst_idx:
             end_idx = inst_idx
-        for i in range(start_idx, end_idx+1):
+        for i in range(start_idx, end_idx + 1):
             if i == pc_index:
                 print ' -> ', lines[i]
             else:
                 print '    ', lines[i]
 
-def print_module_section_data (section):
+
+def print_module_section_data(section):
     print section
     section_data = section.GetSectionData()
     if section_data:
         ostream = lldb.SBStream()
-        section_data.GetDescription (ostream, section.GetFileAddress())
+        section_data.GetDescription(ostream, section.GetFileAddress())
         print ostream.GetData()
 
-def print_module_section (section, depth):
+
+def print_module_section(section, depth):
     print section
     if depth > 0:
         num_sub_sections = section.GetNumSubSections()
         for sect_idx in range(num_sub_sections):
-            print_module_section (section.GetSubSectionAtIndex(sect_idx), depth - 1)
+            print_module_section(
+                section.GetSubSectionAtIndex(sect_idx), depth - 1)
+
 
-def print_module_sections (module, depth):
+def print_module_sections(module, depth):
     for sect in module.section_iter():
-        print_module_section (sect, depth)
+        print_module_section(sect, depth)
 
-def print_module_symbols (module):
+
+def print_module_symbols(module):
     for sym in module:
         print sym
 
+
 def Symbolicate(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('-v', '--verbose', action='store_true', dest='verbose', help='display verbose debug info', default=False)
-    parser.add_option('-p', '--platform', type='string', metavar='platform', dest='platform', help='Specify the platform to use when creating the debug target. Valid values include "localhost", "darwin-kernel", "ios-simulator", "remote-freebsd", "remote-macosx", "remote-ios", "remote-linux".')
-    parser.add_option('-f', '--file', type='string', metavar='file', dest='file', help='Specify a file to use when symbolicating')
-    parser.add_option('-a', '--arch', type='string', metavar='arch', dest='arch', help='Specify a architecture to use when symbolicating')
-    parser.add_option('-s', '--slide', type='int', metavar='slide', dest='slide', help='Specify the slide to use on the file specified with the --file option', default=None)
-    parser.add_option('--section', type='string', action='append', dest='section_strings', help='specify <sect-name>=<start-addr> or <sect-name>=<start-addr>-<end-addr>')
+    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(
+        '-v',
+        '--verbose',
+        action='store_true',
+        dest='verbose',
+        help='display verbose debug info',
+        default=False)
+    parser.add_option(
+        '-p',
+        '--platform',
+        type='string',
+        metavar='platform',
+        dest='platform',
+        help='Specify the platform to use when creating the debug target. Valid values include "localhost", "darwin-kernel", "ios-simulator", "remote-freebsd", "remote-macosx", "remote-ios", "remote-linux".')
+    parser.add_option(
+        '-f',
+        '--file',
+        type='string',
+        metavar='file',
+        dest='file',
+        help='Specify a file to use when symbolicating')
+    parser.add_option(
+        '-a',
+        '--arch',
+        type='string',
+        metavar='arch',
+        dest='arch',
+        help='Specify a architecture to use when symbolicating')
+    parser.add_option(
+        '-s',
+        '--slide',
+        type='int',
+        metavar='slide',
+        dest='slide',
+        help='Specify the slide to use on the file specified with the --file option',
+        default=None)
+    parser.add_option(
+        '--section',
+        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()
-    images = list();
+    images = list()
     if options.file:
-        image = Image(options.file);
+        image = Image(options.file)
         image.arch = options.arch
-        # Add any sections that were specified with one or more --section options
+        # Add any sections that were specified with one or more --section
+        # options
         if options.section_strings:
             for section_str in options.section_strings:
                 section = Section()
-                if section.set_from_string (section_str):
-                    image.add_section (section)
+                if section.set_from_string(section_str):
+                    image.add_section(section)
                 else:
                     sys.exit(1)
-        if options.slide != None:
+        if options.slide is not None:
             image.slide = options.slide
         symbolicator.images.append(image)
-    
+
     target = symbolicator.create_target()
     if options.verbose:
         print symbolicator
     if target:
         for addr_str in args:
             addr = int(addr_str, 0)
-            symbolicated_addrs = symbolicator.symbolicate(addr, options.verbose)
+            symbolicated_addrs = symbolicator.symbolicate(
+                addr, options.verbose)
             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:])
+    Symbolicate(sys.argv[1:])