Use compatible print statements for Python2/3

[davide]

Thanks for your interest in the subject of Python! I converted everything I was able to find looking at our test suite, it seems that we lack coverage for these scripts.
Did you end up testing them with both py 2 and py 3 or just applied a tool on them?

[serge-sans-paille]

@davide I first applied 2to3 systematically, then manually edited the diff so that it remains backward compatible with python2.

[serge-sans-paille]

I didn't run the check-lldb target though, I'm doing that right now.

[davide]

This looks good to me as long as it doesn't break check-lldb (and from I quick look at the patch I doubt it does). Thanks for helping with this!

[serge-sans-paille]

validates fine on my side with py3

[serge-sans-paille]

@davide : is that ok if I add you to a few other python compat related reviews?

examples/customization/bin-utils/binutils.py

 "Collection of tools for displaying bit representation of numbers."""
 
 import StringIO
 
+from __future__ import print_function
 
 def binary(n, width=None):
     """
     Return a list of (0|1)'s for the binary representation of n where n >= 0.
     If you specify a width, it must be > 0, otherwise it is ignored.  The list
     could be padded with 0 bits if width is specified.
     """
     l = []
def utob(debugger, command_line, result, dict):
     try:
         n = int(args[0], 0)
         width = None
         if len(args) > 1:
             width = int(args[1], 0)
             if width < 0:
                 width = 0
     except:
-        print utob.__doc__
+        print(utob.__doc__)
         return
 
     if len(args) > 2:
         verbose = True
     else:
         verbose = False
 
     bits = binary(n, width)
     if not bits:
-        print "insufficient width value: %d" % width
+        print("insufficient width value: %d" % width)
         return
     if verbose and width > 0:
         pos = positions(width)
-        print ' ' + ' '.join(pos)
-    print ' %s' % str(bits)
+        print(' ' + ' '.join(pos))
+    print(' %s' % str(bits))
 
 
 def itob(debugger, command_line, result, dict):
     """Convert the integer to print its two's complement representation.
     args[0] (mandatory) is the integer to be converted
     args[1] (mandatory) is the bit width of the two's complement representation
     args[2] (optional) if specified, turns on verbose printing"""
     args = command_line.split()
     try:
         n = int(args[0], 0)
         width = int(args[1], 0)
         if width < 0:
             width = 0
     except:
-        print itob.__doc__
+        print(itob.__doc__)
         return
 
     if len(args) > 2:
         verbose = True
     else:
         verbose = False
 
     bits = twos_complement(n, width)
     if not bits:
-        print "insufficient width value: %d" % width
+        print("insufficient width value: %d" % width)
         return
     if verbose and width > 0:
         pos = positions(width)
-        print ' ' + ' '.join(pos)
-    print ' %s' % str(bits)
+        print(' ' + ' '.join(pos))
+    print(' %s' % str(bits))

examples/customization/import-python/importcmd.py

+from __future__ import print_function
 import sys
 import os
 import lldb
 
 
 def check_has_dir_in_path(dirname):
     return sys.path.__contains__(dirname)
 
if (len(modname) > 4 and modname[-4:] == '.pyc'):
         modname = modname[:-4]
     if (len(modname) > 3 and modname[-3:] == '.py'):
         modname = modname[:-3]
     debugger.HandleCommand("script import " + modname)
 
 
 def pyimport_cmd(debugger, args, result, dict):
     """Import a Python module given its full path"""
-    print 'WARNING: obsolete feature - use native command "command script import"'
+    print('WARNING: obsolete feature - use native command "command script import"')
     if args == "":
         return "no module path given"
     if not (os.sep in args):
         modname = args
         ensure_has_dir_in_path('.')
     else:
         endofdir = args.rfind(os.sep)
         modname = args[endofdir + 1:]
         args = args[0:endofdir]
         ensure_has_dir_in_path(args)
     do_import(debugger, modname)
     return None

examples/customization/pwd-cd-and-system/utils.py

 """Utility for changing directories and execution of commands in a subshell."""
+from __future__ import print_function
 
 import os
 import shlex
 import subprocess
 
 # Store the previous working directory for the 'cd -' command.
 
 
def chdir(debugger, args, result, dict):
     """Change the working directory, or cd to ${HOME}.
     You can also issue 'cd -' to change to the previous working directory."""
     new_dir = args.strip()
     if not new_dir:
         new_dir = os.path.expanduser('~')
     elif new_dir == '-':
         if not Holder.prev_dir():
             # Bad directory, not changing.
-            print "bad directory, not changing"
+            print("bad directory, not changing")
             return
         else:
             new_dir = Holder.prev_dir()
 
     Holder.swap(os.getcwd())
     os.chdir(new_dir)
-    print "Current working directory: %s" % os.getcwd()
+    print("Current working directory: %s" % os.getcwd())
 
 
 def system(debugger, command_line, result, dict):
     """Execute the command (a string) in a subshell."""
     args = shlex.split(command_line)
     process = subprocess.Popen(
         args,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     output, error = process.communicate()
     retcode = process.poll()
     if output and error:
-        print "stdout=>\n", output
-        print "stderr=>\n", error
+        print("stdout=>\n", output)
+        print("stderr=>\n", error)
     elif output:
-        print output
+        print(output)
     elif error:
-        print error
-    print "retcode:", retcode
+        print(error)
+    print("retcode:", retcode)

examples/python/bsd.py

 #!/usr/bin/python
+from __future__ import print_function
 
 import cmd
 import optparse
 import os
 import shlex
 import struct
 import sys
 
for path in args:
             archive.dump(flat=not options.verbose)
 
 
 if __name__ == '__main__':
     main()
 
 
 def print_mtime_error(result, dmap_mtime, actual_mtime):
-    print >>result, ("error: modification time in debug map (%#08.8x) doesn't "
+    print("error: modification time in debug map (%#08.8x) doesn't "
                      "match the .o file modification time (%#08.8x)" % (
-                        dmap_mtime, actual_mtime))
+                        dmap_mtime, actual_mtime), file=result)
 
 
 def print_file_missing_error(result, path):
-    print >>result, "error: file \"%s\" doesn't exist" % (path)
+    print("error: file \"%s\" doesn't exist" % (path), file=result)
 
 
 def print_multiple_object_matches(result, object_name, mtime, matches):
-    print >>result, ("error: multiple matches for object '%s' with with "
-                     "modification time %#08.8x:" % (object_name, mtime))
+    print("error: multiple matches for object '%s' with with "
+                     "modification time %#08.8x:" % (object_name, mtime), file=result)
     Archive.dump_header(f=result)
     for match in matches:
         match.dump(f=result, flat=True)
 
 
 def print_archive_object_error(result, object_name, mtime, archive):
     matches = archive.find(object_name, f=result)
     if len(matches) > 0:
-        print >>result, ("error: no objects have a modification time that "
+        print("error: no objects have a modification time that "
                          "matches %#08.8x for '%s'. Potential matches:" % (
-                            mtime, object_name))
+                            mtime, object_name), file=result)
         Archive.dump_header(f=result)
         for match in matches:
             match.dump(f=result, flat=True)
     else:
-        print >>result, "error: no object named \"%s\" found in archive:" % (
-            object_name)
+        print("error: no object named \"%s\" found in archive:" % (
+            object_name), file=result)
         Archive.dump_header(f=result)
         for match in archive.objects:
             match.dump(f=result, flat=True)
         # archive.dump(f=result, flat=True)
 
 
 class VerifyDebugMapCommand:
     name = "verify-debug-map-objects"
def __call__(self, debugger, command, exe_ctx, result):
                 path = symbol.GetName()
                 if not path:
                     continue
                 # Extract the value of the symbol by dumping the
                 # symbol. The value is the mod time.
                 dmap_mtime = int(str(symbol).split('value = ')
                                  [1].split(',')[0], 16)
                 if not options.errors:
-                    print >>result, '%s' % (path)
+                    print('%s' % (path), file=result)
                 if os.path.exists(path):
                     actual_mtime = int(os.stat(path).st_mtime)
                     if dmap_mtime != actual_mtime:
                         num_errors += 1
                         if options.errors:
-                            print >>result, '%s' % (path),
+                            print('%s' % (path), end=' ', file=result)
                         print_mtime_error(result, dmap_mtime,
                                           actual_mtime)
                 elif path[-1] == ')':
                     (archive_path, object_name) = path[0:-1].split('(')
                     if not archive_path and not object_name:
                         num_errors += 1
                         if options.errors:
-                            print >>result, '%s' % (path),
+                            print('%s' % (path), end=' ', file=result)
                         print_file_missing_error(path)
                         continue
                     if not os.path.exists(archive_path):
                         num_errors += 1
                         if options.errors:
-                            print >>result, '%s' % (path),
+                            print('%s' % (path), end=' ', file=result)
                         print_file_missing_error(archive_path)
                         continue
                     if archive_path in archives:
                         archive = archives[archive_path]
                     else:
                         archive = Archive(archive_path)
                         archives[archive_path] = archive
                     matches = archive.find(object_name, dmap_mtime)
                     num_matches = len(matches)
                     if num_matches == 1:
-                        print >>result, '1 match'
+                        print('1 match', file=result)
                         obj = matches[0]
                         if obj.date != dmap_mtime:
                             num_errors += 1
                             if options.errors:
-                                print >>result, '%s' % (path),
+                                print('%s' % (path), end=' ', file=result)
                             print_mtime_error(result, dmap_mtime, obj.date)
                     elif num_matches == 0:
                         num_errors += 1
                         if options.errors:
-                            print >>result, '%s' % (path),
+                            print('%s' % (path), end=' ', file=result)
                         print_archive_object_error(result, object_name,
                                                    dmap_mtime, archive)
                     elif num_matches > 1:
                         num_errors += 1
                         if options.errors:
-                            print >>result, '%s' % (path),
+                            print('%s' % (path), end=' ', file=result)
                         print_multiple_object_matches(result,
                                                       object_name,
                                                       dmap_mtime, matches)
             if num_errors > 0:
-                print >>result, "%u errors found" % (num_errors)
+                print("%u errors found" % (num_errors), file=result)
             else:
-                print >>result, "No errors detected in debug map"
+                print("No errors detected in debug map", file=result)
 
 
 def __lldb_init_module(debugger, dict):
     # This initializer is being run from LLDB in the embedded command
     # interpreter.
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
         'command script add -c %s.VerifyDebugMapCommand %s' % (
             __name__, VerifyDebugMapCommand.name))
     print('The "%s" command has been installed, type "help %s" for detailed '
           'help.' % (VerifyDebugMapCommand.name, VerifyDebugMapCommand.name))

examples/python/cmdtemplate.py

 #!/usr/bin/python
 
 # ---------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 # ---------------------------------------------------------------------
 
+from __future__ import print_function
+
 import inspect
 import lldb
 import optparse
 import shlex
 import sys
 
 
 class FrameStatCommand:
def __call__(self, debugger, command, exe_ctx, result):
 
         variables_list = frame.GetVariables(
             options.arguments,
             options.locals,
             options.statics,
             options.inscope)
         variables_count = variables_list.GetSize()
         if variables_count == 0:
-            print >> result, "no variables here"
+            print("no variables here", file=result)
             return
         total_size = 0
         for i in range(0, variables_count):
             variable = variables_list.GetValueAtIndex(i)
             variable_type = variable.GetType()
             total_size = total_size + variable_type.GetByteSize()
             average_size = float(total_size) / variables_count
-            print >>result, ("Your frame has %d variables. Their total size "
-                             "is %d bytes. The average size is %f bytes") % (
-                                    variables_count, total_size, average_size)
+            print("Your frame has %d variables. Their total size "
+                             "is %d bytes. The average size is %f bytes" % (
+                                    variables_count, total_size, average_size), file=result)
         # not returning anything is akin to returning success
 
 
 def __lldb_init_module(debugger, dict):
     # Register all classes that have a register_lldb_command method
     for _name, cls in inspect.getmembers(sys.modules[__name__]):
         if inspect.isclass(cls) and callable(getattr(cls,
                                                      "register_lldb_command",
                                                      None)):
             cls.register_lldb_command(debugger, __name__)

examples/python/delta.py

 # import it with the full path using the "command script import"
 # command. This can be done from the LLDB command line:
 #   (lldb) command script import /path/to/gdbremote.py
 # Or it can be added to your ~/.lldbinit file so this module is always
 # available.
 #----------------------------------------------------------------------
 
 import commands
+from __future__ import print_function
+
 import optparse
 import os
 import shlex
 import re
 import tempfile
 
 
 def start_gdb_log(debugger, command, result, dict):
def parse_log_file(file, options):
 
     This log file will contain timestamps and this function will then normalize
     those packets to be relative to the first value timestamp that is found and
     show delta times between log lines and also keep track of how long it takes
     for GDB remote commands to make a send/receive round trip. This can be
     handy when trying to figure out why some operation in the debugger is taking
     a long time during a preset set of debugger commands.'''
 
-    print '#----------------------------------------------------------------------'
-    print "# Log file: '%s'" % file
-    print '#----------------------------------------------------------------------'
+    print('#----------------------------------------------------------------------')
+    print("# Log file: '%s'" % file)
+    print('#----------------------------------------------------------------------')
 
     timestamp_regex = re.compile('(\s*)([1-9][0-9]+\.[0-9]+)([^0-9].*)$')
 
     base_time = 0.0
     last_time = 0.0
     file = open(file)
     lines = file.read().splitlines()
     for line in lines:
         match = timestamp_regex.match(line)
         if match:
             curr_time = float(match.group(2))
             delta = 0.0
             if base_time:
                 delta = curr_time - last_time
             else:
                 base_time = curr_time
 
-            print '%s%.6f %+.6f%s' % (match.group(1), curr_time - base_time, delta, match.group(3))
+            print('%s%.6f %+.6f%s' % (match.group(1), curr_time - base_time, delta, match.group(3)))
             last_time = curr_time
         else:
-            print line
+            print(line)
 
 
 if __name__ == '__main__':
     import sys
     parse_time_log_args(sys.argv[1:])
 
 else:
     import lldb
     if lldb.debugger:
         # This initializer is being run from LLDB in the embedded command interpreter
         # Add any commands contained in this module to LLDB
         lldb.debugger.HandleCommand(
             'command script add -f delta.parse_time_log parse_time_log')
-        print 'The "parse_time_log" command is now installed and ready for use, type "parse_time_log --help" for more information'
+        print('The "parse_time_log" command is now installed and ready for use, type "parse_time_log --help" for more information')

examples/python/diagnose_nsstring.py

 # This implements the "diagnose-nsstring" command, usually installed in the debug session like
 #   command script import lldb.diagnose
 # it is used when NSString summary formatter fails to replicate the logic that went into LLDB making the
 # decisions it did and  providing some useful context information that can
 # be used for improving the formatter
 
+from __future__ import print_function
+
 import lldb
 
 
 def read_memory(process, location, size):
     data = ""
     error = lldb.SBError()
     for x in range(0, size - 1):
         byte = process.ReadUnsignedFromMemory(x + location, 1, error)
for x in range(0, size - 1):
                     data = data + "(\\c)"
                 elif byte == '\n':
                     data = data + "(\\n)"
                 else:
                     data = data + "(%s)" % chr(byte)
                 if x < size - 2:
                     data = data + ":"
             except Exception as e:
-                print e
+                print(e)
     return data
 
 
 def diagnose_nsstring_Command_Impl(debugger, command, result, internal_dict):
     """
     A command to diagnose the LLDB NSString data formatter
     invoke as
     (lldb) diagnose-nsstring <expr returning NSString>
     e.g.
     (lldb) diagnose-nsstring @"Hello world"
     """
     target = debugger.GetSelectedTarget()
     process = target.GetProcess()
     thread = process.GetSelectedThread()
     frame = thread.GetSelectedFrame()
     if not target.IsValid() or not process.IsValid():
         return "unable to get target/process - cannot proceed"
     options = lldb.SBExpressionOptions()
     options.SetFetchDynamicValue()
     error = lldb.SBError()
     if frame.IsValid():
         nsstring = frame.EvaluateExpression(command, options)
     else:
         nsstring = target.EvaluateExpression(command, options)
-    print >>result, str(nsstring)
+    print(str(nsstring), file=result)
     nsstring_address = nsstring.GetValueAsUnsigned(0)
     if nsstring_address == 0:
         return "unable to obtain the string - cannot proceed"
     expression = "\
 struct $__lldb__notInlineMutable {\
     char* buffer;\
     signed long length;\
     signed long capacity;\
union {\
         struct $__lldb__notInlineMutable notInlineMutable;\
     } variants;\
 };\
 "
 
     expression = expression + "*(($__lldb__CFString*) %d)" % nsstring_address
     # print expression
     dumped = target.EvaluateExpression(expression, options)
-    print >>result, str(dumped)
+    print(str(dumped), file=result)
 
     little_endian = (target.byte_order == lldb.eByteOrderLittle)
     ptr_size = target.addr_size
 
     info_bits = dumped.GetChildMemberWithName("_cfinfo").GetChildAtIndex(
         0 if little_endian else 3).GetValueAsUnsigned(0)
     is_mutable = (info_bits & 1) == 1
     is_inline = (info_bits & 0x60) == 0
     has_explicit_length = (info_bits & (1 | 4)) != 4
     is_unicode = (info_bits & 0x10) == 0x10
     is_special = (
         nsstring.GetDynamicValue(
             lldb.eDynamicCanRunTarget).GetTypeName() == "NSPathStore2")
     has_null = (info_bits & 8) == 8
 
-    print >>result, "\nInfo=%d\nMutable=%s\nInline=%s\nExplicit=%s\nUnicode=%s\nSpecial=%s\nNull=%s\n" % \
-        (info_bits, "yes" if is_mutable else "no", "yes" if is_inline else "no", "yes" if has_explicit_length else "no", "yes" if is_unicode else "no", "yes" if is_special else "no", "yes" if has_null else "no")
+    print("\nInfo=%d\nMutable=%s\nInline=%s\nExplicit=%s\nUnicode=%s\nSpecial=%s\nNull=%s\n" % \
+        (info_bits, "yes" if is_mutable else "no", "yes" if is_inline else "no", "yes" if has_explicit_length else "no", "yes" if is_unicode else "no", "yes" if is_special else "no", "yes" if has_null else "no"), file=result)
 
     explicit_length_offset = 0
     if not has_null and has_explicit_length and not is_special:
         explicit_length_offset = 2 * ptr_size
         if is_mutable and not is_inline:
             explicit_length_offset = explicit_length_offset + ptr_size
         elif is_inline:
             pass
         elif not is_inline and not is_mutable:
             explicit_length_offset = explicit_length_offset + ptr_size
         else:
             explicit_length_offset = 0
 
     if explicit_length_offset == 0:
-        print >>result, "There is no explicit length marker - skipping this step\n"
+        print("There is no explicit length marker - skipping this step\n", file=result)
     else:
         explicit_length_offset = nsstring_address + explicit_length_offset
         explicit_length = process.ReadUnsignedFromMemory(
             explicit_length_offset, 4, error)
-        print >>result, "Explicit length location is at 0x%x - read value is %d\n" % (
-            explicit_length_offset, explicit_length)
+        print("Explicit length location is at 0x%x - read value is %d\n" % (
+            explicit_length_offset, explicit_length), file=result)
 
     if is_mutable:
         location = 2 * ptr_size + nsstring_address
         location = process.ReadPointerFromMemory(location, error)
     elif is_inline and has_explicit_length and not is_unicode and not is_special and not is_mutable:
         location = 3 * ptr_size + nsstring_address
     elif is_unicode:
         location = 2 * ptr_size + nsstring_address
         if is_inline:
             if not has_explicit_length:
-                print >>result, "Unicode & Inline & !Explicit is a new combo - no formula for it"
+                print("Unicode & Inline & !Explicit is a new combo - no formula for it", file=result)
             else:
                 location += ptr_size
         else:
             location = process.ReadPointerFromMemory(location, error)
     elif is_special:
         location = nsstring_address + ptr_size + 4
     elif is_inline:
         location = 2 * ptr_size + nsstring_address
         if not has_explicit_length:
             location += 1
     else:
         location = 2 * ptr_size + nsstring_address
         location = process.ReadPointerFromMemory(location, error)
-    print >>result, "Expected data location: 0x%x\n" % (location)
-    print >>result, "1K of data around location: %s\n" % read_memory(
-        process, location, 1024)
-    print >>result, "5K of data around string pointer: %s\n" % read_memory(
-        process, nsstring_address, 1024 * 5)
+    print("Expected data location: 0x%x\n" % (location), file=result)
+    print("1K of data around location: %s\n" % read_memory(
+        process, location, 1024), file=result)
+    print("5K of data around string pointer: %s\n" % read_memory(
+        process, nsstring_address, 1024 * 5), file=result)
 
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
         "command script add -f %s.diagnose_nsstring_Command_Impl diagnose-nsstring" %
         __name__)
-    print 'The "diagnose-nsstring" command has been installed, type "help diagnose-nsstring" for detailed help.'
+    print('The "diagnose-nsstring" command has been installed, type "help diagnose-nsstring" for detailed help.')
 
 __lldb_init_module(lldb.debugger, None)
 __lldb_init_module = None

examples/python/diagnose_unwind.py

 # This implements the "diagnose-unwind" command, usually installed
 # in the debug session like
 #   command script import lldb.diagnose
 # it is used when lldb's backtrace fails -- it collects and prints
 # information about the stack frames, and tries an alternate unwind
 # algorithm, that will help to understand why lldb's unwind algorithm
 # did not succeed.
+from __future__ import print_function
 
 import optparse
 import lldb
 import re
 import shlex
 
 # Print the frame number, pc, frame pointer, module UUID and function name
 # Returns the SBModule that contains the PC, if it could be found
try:
             if sbaddr.GetModule().GetFileSpec():
                 module_filename = sbaddr.GetModule().GetFileSpec().GetFilename()
                 if module_filename is None:
                     module_filename = ""
             if module_uuid_str != "" or module_filename != "":
                 module_description = '%s %s' % (
                     module_filename, module_uuid_str)
     except Exception:
-        print '%2d: pc==0x%-*x fp==0x%-*x' % (frame_num, addr_width, addr_for_printing, addr_width, fp)
+        print('%2d: pc==0x%-*x fp==0x%-*x' % (frame_num, addr_width, addr_for_printing, addr_width, fp))
         return
 
     sym_ctx = target.ResolveSymbolContextForAddress(
         sbaddr, lldb.eSymbolContextEverything)
     if sym_ctx.IsValid() and sym_ctx.GetSymbol().IsValid():
         function_start = sym_ctx.GetSymbol().GetStartAddress().GetLoadAddress(target)
         offset = addr - function_start
-        print '%2d: pc==0x%-*x fp==0x%-*x %s %s + %d' % (frame_num, addr_width, addr_for_printing, addr_width, fp, module_description, sym_ctx.GetSymbol().GetName(), offset)
+        print('%2d: pc==0x%-*x fp==0x%-*x %s %s + %d' % (frame_num, addr_width, addr_for_printing, addr_width, fp, module_description, sym_ctx.GetSymbol().GetName(), offset))
     else:
-        print '%2d: pc==0x%-*x fp==0x%-*x %s' % (frame_num, addr_width, addr_for_printing, addr_width, fp, module_description)
+        print('%2d: pc==0x%-*x fp==0x%-*x %s' % (frame_num, addr_width, addr_for_printing, addr_width, fp, module_description))
     return sbaddr.GetModule()
 
 # A simple stack walk algorithm that follows the frame chain.
 # Returns a two-element list; the first element is a list of modules
 # seen and the second element is a list of addresses seen during the backtrace.
 
 
 def simple_backtrace(debugger):
if initial_fp == lldb.LLDB_INVALID_ADDRESS and target.triple[0:3] == "arm":
                     if reg.GetName() == "r7":
                         initial_fp = int(reg.GetValue(), 16)
 
     module_list = []
     address_list = [cur_thread.GetFrameAtIndex(0).GetPC()]
     this_module = backtrace_print_frame(
         target, 0, cur_thread.GetFrameAtIndex(0).GetPC(), initial_fp)
     print_stack_frame(process, initial_fp)
-    print ""
+    print("")
     if this_module is not None:
         module_list.append(this_module)
     if cur_thread.GetNumFrames() < 2:
         return [module_list, address_list]
 
     cur_fp = process.ReadPointerFromMemory(initial_fp, lldb.SBError())
     cur_pc = process.ReadPointerFromMemory(
         initial_fp + process.GetAddressByteSize(), lldb.SBError())
 
     frame_num = 1
 
     while cur_pc != 0 and cur_fp != 0 and cur_pc != lldb.LLDB_INVALID_ADDRESS and cur_fp != lldb.LLDB_INVALID_ADDRESS:
         address_list.append(cur_pc)
         this_module = backtrace_print_frame(target, frame_num, cur_pc, cur_fp)
         print_stack_frame(process, cur_fp)
-        print ""
+        print("")
         if this_module is not None:
             module_list.append(this_module)
         frame_num = frame_num + 1
         next_pc = 0
         next_fp = 0
         if target.triple[
             0:6] == "x86_64" or target.triple[
             0:4] == "i386" or target.triple[
                 0:3] == "arm":
             error = lldb.SBError()
             next_pc = process.ReadPointerFromMemory(
                 cur_fp + process.GetAddressByteSize(), error)
             if not error.Success():
                 next_pc = 0
             next_fp = process.ReadPointerFromMemory(cur_fp, error)
             if not error.Success():
                 next_fp = 0
         # Clear the 0th bit for arm frames - this indicates it is a thumb frame
         if target.triple[0:3] == "arm" and (next_pc & 1) == 1:
             next_pc = next_pc & ~1
         cur_pc = next_pc
         cur_fp = next_fp
     this_module = backtrace_print_frame(target, frame_num, cur_pc, cur_fp)
     print_stack_frame(process, cur_fp)
-    print ""
+    print("")
     if this_module is not None:
         module_list.append(this_module)
     return [module_list, address_list]
 
 
 def print_stack_frame(process, fp):
     if fp == 0 or fp == lldb.LLDB_INVALID_ADDRESS or fp == 1:
         return
     addr_size = process.GetAddressByteSize()
     addr = fp - (2 * addr_size)
     i = 0
     outline = "Stack frame from $fp-%d: " % (2 * addr_size)
     error = lldb.SBError()
     try:
         while i < 5 and error.Success():
             address = process.ReadPointerFromMemory(
                 addr + (i * addr_size), error)
             outline += " 0x%x" % address
             i += 1
-        print outline
+        print(outline)
     except Exception:
         return
 
 
 def diagnose_unwind(debugger, command, result, dict):
     """
   Gather diagnostic information to help debug incorrect unwind (backtrace)
   behavior in lldb.  When there is a backtrace that doesn't look
if target:
                     lldb_major = int(lldb_versions_match.groups()[0])
                 if len(lldb_versions_match.groups()
                        ) >= 5 and lldb_versions_match.groups()[4]:
                     lldb_minor = int(lldb_versions_match.groups()[4])
 
                 modules_seen = []
                 addresses_seen = []
 
-                print 'LLDB version %s' % debugger.GetVersionString()
-                print 'Unwind diagnostics for thread %d' % thread.GetIndexID()
-                print ""
-                print "============================================================================================="
-                print ""
-                print "OS plugin setting:"
+                print('LLDB version %s' % debugger.GetVersionString())
+                print('Unwind diagnostics for thread %d' % thread.GetIndexID())
+                print("")
+                print("=============================================================================================")
+                print("")
+                print("OS plugin setting:")
                 debugger.HandleCommand(
                     "settings show target.process.python-os-plugin-path")
-                print ""
-                print "Live register context:"
+                print("")
+                print("Live register context:")
                 thread.SetSelectedFrame(0)
                 debugger.HandleCommand("register read")
-                print ""
-                print "============================================================================================="
-                print ""
-                print "lldb's unwind algorithm:"
-                print ""
+                print("")
+                print("=============================================================================================")
+                print("")
+                print("lldb's unwind algorithm:")
+                print("")
                 frame_num = 0
                 for frame in thread.frames:
                     if not frame.IsInlined():
                         this_module = backtrace_print_frame(
                             target, frame_num, frame.GetPC(), frame.GetFP())
                         print_stack_frame(process, frame.GetFP())
-                        print ""
+                        print("")
                         if this_module is not None:
                             modules_seen.append(this_module)
                         addresses_seen.append(frame.GetPC())
                         frame_num = frame_num + 1
-                print ""
-                print "============================================================================================="
-                print ""
-                print "Simple stack walk algorithm:"
-                print ""
+                print("")
+                print("=============================================================================================")
+                print("")
+                print("Simple stack walk algorithm:")
+                print("")
                 (module_list, address_list) = simple_backtrace(debugger)
                 if module_list and module_list is not None:
                     modules_seen += module_list
                 if address_list and address_list is not None:
                     addresses_seen = set(addresses_seen)
                     addresses_seen.update(set(address_list))
 
-                print ""
-                print "============================================================================================="
-                print ""
-                print "Modules seen in stack walks:"
-                print ""
+                print("")
+                print("=============================================================================================")
+                print("")
+                print("Modules seen in stack walks:")
+                print("")
                 modules_already_seen = set()
                 for module in modules_seen:
                     if module is not None and module.GetFileSpec().GetFilename() is not None:
                         if not module.GetFileSpec().GetFilename() in modules_already_seen:
                             debugger.HandleCommand(
                                 'image list %s' %
                                 module.GetFileSpec().GetFilename())
                             modules_already_seen.add(
                                 module.GetFileSpec().GetFilename())
 
-                print ""
-                print "============================================================================================="
-                print ""
-                print "Disassembly ofaddresses seen in stack walks:"
-                print ""
+                print("")
+                print("=============================================================================================")
+                print("")
+                print("Disassembly ofaddresses seen in stack walks:")
+                print("")
                 additional_addresses_to_disassemble = addresses_seen
                 for frame in thread.frames:
                     if not frame.IsInlined():
-                        print "--------------------------------------------------------------------------------------"
-                        print ""
-                        print "Disassembly of %s, frame %d, address 0x%x" % (frame.GetFunctionName(), frame.GetFrameID(), frame.GetPC())
-                        print ""
+                        print("--------------------------------------------------------------------------------------")
+                        print("")
+                        print("Disassembly of %s, frame %d, address 0x%x" % (frame.GetFunctionName(), frame.GetFrameID(), frame.GetPC()))
+                        print("")
                         if target.triple[
                                 0:6] == "x86_64" or target.triple[
                                 0:4] == "i386":
                             debugger.HandleCommand(
                                 'disassemble -F att -a 0x%x' % frame.GetPC())
                         else:
                             debugger.HandleCommand(
                                 'disassemble -a 0x%x' %
                                 frame.GetPC())
                         if frame.GetPC() in additional_addresses_to_disassemble:
                             additional_addresses_to_disassemble.remove(
                                 frame.GetPC())
 
                 for address in list(additional_addresses_to_disassemble):
-                    print "--------------------------------------------------------------------------------------"
-                    print ""
-                    print "Disassembly of 0x%x" % address
-                    print ""
+                    print("--------------------------------------------------------------------------------------")
+                    print("")
+                    print("Disassembly of 0x%x" % address)
+                    print("")
                     if target.triple[
                             0:6] == "x86_64" or target.triple[
                             0:4] == "i386":
                         debugger.HandleCommand(
                             'disassemble -F att -a 0x%x' % address)
                     else:
                         debugger.HandleCommand('disassemble -a 0x%x' % address)
 
-                print ""
-                print "============================================================================================="
-                print ""
+                print("")
+                print("=============================================================================================")
+                print("")
                 additional_addresses_to_show_unwind = addresses_seen
                 for frame in thread.frames:
                     if not frame.IsInlined():
-                        print "--------------------------------------------------------------------------------------"
-                        print ""
-                        print "Unwind instructions for %s, frame %d" % (frame.GetFunctionName(), frame.GetFrameID())
-                        print ""
+                        print("--------------------------------------------------------------------------------------")
+                        print("")
+                        print("Unwind instructions for %s, frame %d" % (frame.GetFunctionName(), frame.GetFrameID()))
+                        print("")
                         debugger.HandleCommand(
                             'image show-unwind -a "0x%x"' % frame.GetPC())
                         if frame.GetPC() in additional_addresses_to_show_unwind:
                             additional_addresses_to_show_unwind.remove(
                                 frame.GetPC())
 
                 for address in list(additional_addresses_to_show_unwind):
-                    print "--------------------------------------------------------------------------------------"
-                    print ""
-                    print "Unwind instructions for 0x%x" % address
-                    print ""
+                    print("--------------------------------------------------------------------------------------")
+                    print("")
+                    print("Unwind instructions for 0x%x" % address)
+                    print("")
                     debugger.HandleCommand(
                         'image show-unwind -a "0x%x"' % address)
 
 
 def create_diagnose_unwind_options():
     usage = "usage: %prog"
     description = '''Print diagnostic information about a thread backtrace which will help to debug unwind problems'''
     parser = optparse.OptionParser(
         description=description,
         prog='diagnose_unwind',
         usage=usage)
     return parser
 
 lldb.debugger.HandleCommand(
     'command script add -f %s.diagnose_unwind diagnose-unwind' %
     __name__)
-print 'The "diagnose-unwind" command has been installed, type "help diagnose-unwind" for detailed help.'
+print('The "diagnose-unwind" command has been installed, type "help diagnose-unwind" for detailed help.')

examples/python/disasm-stress-test.py

def GetLLDBFrameworkPath():
         if re_result is None:
             return None
         xcode_contents_path = re_result.group(1)
         return xcode_contents_path + "/SharedFrameworks/LLDB.framework"
 
     lldb_framework_path = GetLLDBFrameworkPath()
 
     if lldb_framework_path is None:
-        print "Couldn't find LLDB.framework"
+        print("Couldn't find LLDB.framework")
         sys.exit(-1)
 
     sys.path.append(lldb_framework_path + "/Resources/Python")
 
 if arg_ns.lldb is None:
     AddLLDBToSysPathOnMacOSX()
 else:
     sys.path.append(arg_ns.lldb + "/Resources/Python")
 
 import lldb
 
 debugger = lldb.SBDebugger.Create()
 
 if debugger.IsValid() == False:
-    print "Couldn't create an SBDebugger"
+    print("Couldn't create an SBDebugger")
     sys.exit(-1)
 
 target = debugger.CreateTargetWithFileAndArch(None, arg_ns.arch)
 
 if target.IsValid() == False:
-    print "Couldn't create an SBTarget for architecture " + arg_ns.arch
+    print("Couldn't create an SBTarget for architecture " + arg_ns.arch)
     sys.exit(-1)
 
 
 def ResetLogFile(log_file):
     if log_file != sys.stdout:
         log_file.seek(0)
 
 
 def PrintByteArray(log_file, byte_array):
     for byte in byte_array:
-        print >>log_file, hex(byte) + " ",
-    print >>log_file
+        print(hex(byte) + " ", end=' ', file=log_file)
+    print(file=log_file)
 
 
 class SequentialInstructionProvider:
 
     def __init__(self, byte_width, log_file, start=0, skip=1):
         self.m_byte_width = byte_width
         self.m_log_file = log_file
         self.m_start = start
         self.m_skip = skip
         self.m_value = start
         self.m_last = (1 << (byte_width * 8)) - 1
 
     def PrintCurrentState(self, ret):
         ResetLogFile(self.m_log_file)
-        print >>self.m_log_file, self.m_value
+        print(self.m_value, file=self.m_log_file)
         PrintByteArray(self.m_log_file, ret)
 
     def GetNextInstruction(self):
         if self.m_value > self.m_last:
             return None
         ret = bytearray(self.m_byte_width)
         for i in range(self.m_byte_width):
             ret[self.m_byte_width - (i + 1)] = (self.m_value >> (i * 8)) & 255
for inst_bytes in instruction_provider:
     if actually_time:
         if (num_instructions_logged != 0) and (
                 num_instructions_logged % 100000 == 0):
             curr_time = time.time()
             elapsed_time = curr_time - start_time
             remaining_time = float(
                 total_num_instructions - num_instructions_logged) * (
                 float(elapsed_time) / float(num_instructions_logged))
-            print str(datetime.timedelta(seconds=remaining_time))
+            print(str(datetime.timedelta(seconds=remaining_time)))
         num_instructions_logged = num_instructions_logged + 1
     inst_list = target.GetInstructions(fake_address, inst_bytes)
     if not inst_list.IsValid():
-        print >>log_file, "Invalid instruction list"
+        print("Invalid instruction list", file=log_file)
         continue
     inst = inst_list.GetInstructionAtIndex(0)
     if not inst.IsValid():
-        print >>log_file, "Invalid instruction"
+        print("Invalid instruction", file=log_file)
         continue
     instr_output_stream = lldb.SBStream()
     inst.GetDescription(instr_output_stream)
-    print >>log_file, instr_output_stream.GetData()
+    print(instr_output_stream.GetData(), file=log_file)

examples/python/disasm.py

 
 import lldb
 import os
 import sys
 
 
 def disassemble_instructions(insts):
     for i in insts:
-        print i
+        print(i)
 
 
 def usage():
-    print "Usage: disasm.py [-n name] executable-image"
-    print "       By default, it breaks at and disassembles the 'main' function."
+    print("Usage: disasm.py [-n name] executable-image")
+    print("       By default, it breaks at and disassembles the 'main' function.")
     sys.exit(0)
 
 if len(sys.argv) == 2:
     fname = 'main'
     exe = sys.argv[1]
 elif len(sys.argv) == 4:
     if sys.argv[1] != '-n':
         usage()
     else:
         fname = sys.argv[2]
         exe = sys.argv[3]
 else:
     usage()
 
 # Create a new debugger instance
 debugger = lldb.SBDebugger.Create()
 
 # When we step or continue, don't return from the function until the process
 # stops. We do this by setting the async mode to false.
 debugger.SetAsync(False)
 
 # Create a target from a file and arch
-print "Creating a target for '%s'" % exe
+print("Creating a target for '%s'" % exe)
 
 target = debugger.CreateTargetWithFileAndArch(exe, lldb.LLDB_ARCH_DEFAULT)
 
 if target:
     # If the target is valid set a breakpoint at main
     main_bp = target.BreakpointCreateByName(
         fname, target.GetExecutable().GetFilename())
 
-    print main_bp
+    print(main_bp)
 
     # Launch the process. Since we specified synchronous mode, we won't return
     # from this function until we hit the breakpoint at main
     process = target.LaunchSimple(None, None, os.getcwd())
 
     # Make sure the launch went ok
     if process:
         # Print some simple process info
         state = process.GetState()
-        print process
+        print(process)
         if state == lldb.eStateStopped:
             # Get the first thread
             thread = process.GetThreadAtIndex(0)
             if thread:
                 # Print some simple thread info
-                print thread
+                print(thread)
                 # Get the first frame
                 frame = thread.GetFrameAtIndex(0)
                 if frame:
                     # Print some simple frame info
-                    print frame
+                    print(frame)
                     function = frame.GetFunction()
                     # See if we have debug info (a function)
                     if function:
                         # We do have a function, print some info for the
                         # function
-                        print function
+                        print(function)
                         # Now get all instructions for this function and print
                         # them
                         insts = function.GetInstructions(target)
                         disassemble_instructions(insts)
                     else:
                         # See if we have a symbol in the symbol table for where
                         # we stopped
                         symbol = frame.GetSymbol()
                         if symbol:
                             # We do have a symbol, print some info for the
                             # symbol
-                            print symbol
+                            print(symbol)
                             # Now get all instructions for this symbol and
                             # print them
                             insts = symbol.GetInstructions(target)
                             disassemble_instructions(insts)
 
                     registerList = frame.GetRegisters()
-                    print "Frame registers (size of register set = %d):" % registerList.GetSize()
+                    print("Frame registers (size of register set = %d):" % registerList.GetSize())
                     for value in registerList:
                         # print value
-                        print "%s (number of children = %d):" % (value.GetName(), value.GetNumChildren())
+                        print("%s (number of children = %d):" % (value.GetName(), value.GetNumChildren()))
                         for child in value:
-                            print "Name: ", child.GetName(), " Value: ", child.GetValue()
+                            print("Name: ", child.GetName(), " Value: ", child.GetValue())
 
-            print "Hit the breakpoint at main, enter to continue and wait for program to exit or 'Ctrl-D'/'quit' to terminate the program"
+            print("Hit the breakpoint at main, enter to continue and wait for program to exit or 'Ctrl-D'/'quit' to terminate the program")
             next = sys.stdin.readline()
             if not next or next.rstrip('\n') == 'quit':
-                print "Terminating the inferior process..."
+                print("Terminating the inferior process...")
                 process.Kill()
             else:
                 # Now continue to the program exit
                 process.Continue()
                 # When we return from the above function we will hopefully be at the
                 # program exit. Print out some process info
-                print process
+                print(process)
         elif state == lldb.eStateExited:
-            print "Didn't hit the breakpoint at main, program has exited..."
+            print("Didn't hit the breakpoint at main, program has exited...")
         else:
-            print "Unexpected process state: %s, killing process..." % debugger.StateAsCString(state)
+            print("Unexpected process state: %s, killing process..." % debugger.StateAsCString(state))
             process.Kill()
 
 
 lldb.SBDebugger.Terminate()

examples/python/file_extract.py

def set_byte_order(self, b):
         elif b == 'swap':
             # swap what ever the current byte order is
             self.byte_order = swap_unpack_char()
         elif b == 'native':
             self.byte_order = '='
         elif b == '<' or b == '>' or b == '@' or b == '=':
             self.byte_order = b
         else:
-            print "error: invalid byte order specified: '%s'" % b
+            print("error: invalid byte order specified: '%s'" % b)
 
     def is_in_memory(self):
         return False
 
     def seek(self, offset, whence=0):
         if self.file:
             return self.file.seek(offset, whence)
         raise ValueError

examples/python/gdb_disassemble.py

elif lldb.frame.symbol:
         start_addr = lldb.frame.symbol.addr.load_addr
         name = lldb.frame.symbol.name
 
     for inst in instructions:
         inst_addr = inst.addr.load_addr
         inst_offset = inst_addr - start_addr
         comment = inst.comment
         if comment:
-            print "<%s + %-4u> 0x%x %8s  %s ; %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands, comment)
+            print("<%s + %-4u> 0x%x %8s  %s ; %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands, comment))
         else:
-            print "<%s + %-4u> 0x%x %8s  %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands)
+            print("<%s + %-4u> 0x%x %8s  %s" % (name, inst_offset, inst_addr, inst.mnemonic, inst.operands))
 
 # Install the command when the module gets imported
 lldb.debugger.HandleCommand(
     'command script add -f gdb_disassemble.disassemble gdb-disassemble')
-print 'Installed "gdb-disassemble" command for disassembly'
+print('Installed "gdb-disassemble" command for disassembly')

examples/python/gdbremote.py

def stop_gdb_log(debugger, command, result, dict):
     options.colors = TerminalColors(options.color)
     options.symbolicator = None
     if options.symbolicate:
         if lldb.target:
             import lldb.utils.symbolication
             options.symbolicator = lldb.utils.symbolication.Symbolicator()
             options.symbolicator.target = lldb.target
         else:
-            print "error: can't symbolicate without a target"
+            print("error: can't symbolicate without a target")
 
     if not g_log_file:
         result.PutCString(
             'error: logging must have been previously enabled with a call to "stop_gdb_log"')
     elif os.path.exists(g_log_file):
         if len(args) == 0:
             debugger.HandleCommand('log disable gdb-remote packets')
             result.PutCString(
                 "GDB packet logging disabled. Logged packets are in '%s'" %
                 g_log_file)
             parse_gdb_log_file(g_log_file, options)
         else:
             result.PutCString(usage)
     else:
-        print 'error: the GDB packet log file "%s" does not exist' % g_log_file
+        print('error: the GDB packet log file "%s" does not exist' % g_log_file)
 
 
 def is_hex_byte(str):
     if len(str) == 2:
         return str[0] in string.hexdigits and str[1] in string.hexdigits
     return False
 
 def get_hex_string_if_all_printable(str):
if str:
         if match:
             return int(match.group(1), 16)
     return None
 
 
 def cmd_qThreadStopInfo(options, cmd, args):
     packet = Packet(args)
     tid = packet.get_hex_uint('big')
-    print "get_thread_stop_info  (tid = 0x%x)" % (tid)
+    print("get_thread_stop_info  (tid = 0x%x)" % (tid))
 
 
 def cmd_stop_reply(options, cmd, args):
-    print "get_last_stop_info()"
+    print("get_last_stop_info()")
     return False
 
 
 def rsp_stop_reply(options, cmd, cmd_args, rsp):
     global g_byte_order
     packet = Packet(rsp)
     stop_type = packet.get_char()
     if stop_type == 'T' or stop_type == 'S':
         signo = packet.get_hex_uint8()
         key_value_pairs = packet.get_key_value_pairs()
         for key_value_pair in key_value_pairs:
             key = key_value_pair[0]
             if is_hex_byte(key):
                 reg_num = Packet(key).get_hex_uint8()
                 if reg_num < len(g_register_infos):
                     reg_info = g_register_infos[reg_num]
                     key_value_pair[0] = reg_info.name()
                     key_value_pair[1] = reg_info.get_value_from_hex_string(
                         key_value_pair[1])
             elif key == 'jthreads' or key == 'jstopinfo':
                 key_value_pair[1] = binascii.unhexlify(key_value_pair[1])
         key_value_pairs.insert(0, ['signal', signo])
-        print 'stop_reply():'
+        print('stop_reply():')
         dump_key_value_pairs(key_value_pairs)
     elif stop_type == 'W':
         exit_status = packet.get_hex_uint8()
-        print 'stop_reply(): exit (status=%i)' % exit_status
+        print('stop_reply(): exit (status=%i)' % exit_status)
     elif stop_type == 'O':
-        print 'stop_reply(): stdout = "%s"' % packet.str
+        print('stop_reply(): stdout = "%s"' % packet.str)
 
 
 def cmd_unknown_packet(options, cmd, args):
     if args:
-        print "cmd: %s, args: %s", cmd, args
+        print("cmd: %s, args: %s", cmd, args)
     else:
-        print "cmd: %s", cmd
+        print("cmd: %s", cmd)
     return False
 
 
 def cmd_qSymbol(options, cmd, args):
     if args == ':':
-        print 'ready to serve symbols'
+        print('ready to serve symbols')
     else:
         packet = Packet(args)
         symbol_addr = packet.get_hex_uint('big')
         if symbol_addr is None:
             if packet.skip_exact_string(':'):
                 symbol_name = packet.get_hex_ascii_str()
-                print 'lookup_symbol("%s") -> symbol not available yet' % (symbol_name)
+                print('lookup_symbol("%s") -> symbol not available yet' % (symbol_name))
             else:
-                print 'error: bad command format'
+                print('error: bad command format')
         else:
             if packet.skip_exact_string(':'):
                 symbol_name = packet.get_hex_ascii_str()
-                print 'lookup_symbol("%s") -> 0x%x' % (symbol_name, symbol_addr)
+                print('lookup_symbol("%s") -> 0x%x' % (symbol_name, symbol_addr))
             else:
-                print 'error: bad command format'
+                print('error: bad command format')
 
 def cmd_QSetWithHexString(options, cmd, args):
-    print '%s("%s")' % (cmd[:-1], binascii.unhexlify(args))
+    print('%s("%s")' % (cmd[:-1], binascii.unhexlify(args)))
 
 def cmd_QSetWithString(options, cmd, args):
-    print '%s("%s")' % (cmd[:-1], args)
+    print('%s("%s")' % (cmd[:-1], args))
 
 def cmd_QSetWithUnsigned(options, cmd, args):
-    print '%s(%i)' % (cmd[:-1], int(args))
+    print('%s(%i)' % (cmd[:-1], int(args)))
 
 def rsp_qSymbol(options, cmd, cmd_args, rsp):
     if len(rsp) == 0:
-        print "Unsupported"
+        print("Unsupported")
     else:
         if rsp == "OK":
-            print "No more symbols to lookup"
+            print("No more symbols to lookup")
         else:
             packet = Packet(rsp)
             if packet.skip_exact_string("qSymbol:"):
                 symbol_name = packet.get_hex_ascii_str()
-                print 'lookup_symbol("%s")' % (symbol_name)
+                print('lookup_symbol("%s")' % (symbol_name))
             else:
-                print 'error: response string should start with "qSymbol:": respnse is "%s"' % (rsp)
+                print('error: response string should start with "qSymbol:": respnse is "%s"' % (rsp))
 
 
 def cmd_qXfer(options, cmd, args):
     # $qXfer:features:read:target.xml:0,1ffff#14
-    print "read target special data %s" % (args)
+    print("read target special data %s" % (args))
     return True
 
 
 def rsp_qXfer(options, cmd, cmd_args, rsp):
     data = string.split(cmd_args, ':')
     if data[0] == 'features':
         if data[1] == 'read':
             filename, extension = os.path.splitext(data[2])
if data[0] == 'features':
                                     reg_info.info['encoding'] = 'uint'
                                 if 'offset' in reg_element.attrib:
                                     reg_info.info[
                                         'offset'] = reg_element.attrib['offset']
                                 if 'bitsize' in reg_element.attrib:
                                     reg_info.info[
                                         'bitsize'] = reg_element.attrib['bitsize']
                                 g_register_infos.append(reg_info)
-                        print 'XML for "%s":' % (data[2])
+                        print('XML for "%s":' % (data[2]))
                         ET.dump(xml_root)
 
 
 def cmd_A(options, cmd, args):
-    print 'launch process:'
+    print('launch process:')
     packet = Packet(args)
     while True:
         arg_len = packet.get_number()
         if arg_len == -1:
             break
         if not packet.skip_exact_string(','):
             break
         arg_idx = packet.get_number()
         if arg_idx == -1:
             break
         if not packet.skip_exact_string(','):
             break
         arg_value = packet.get_hex_ascii_str(arg_len)
-        print 'argv[%u] = "%s"' % (arg_idx, arg_value)
+        print('argv[%u] = "%s"' % (arg_idx, arg_value))
 
 
 def cmd_qC(options, cmd, args):
-    print "query_current_thread_id()"
+    print("query_current_thread_id()")
 
 
 def rsp_qC(options, cmd, cmd_args, rsp):
     packet = Packet(rsp)
     if packet.skip_exact_string("QC"):
         tid = packet.get_thread_id()
-        print "current_thread_id = %#x" % (tid)
+        print("current_thread_id = %#x" % (tid))
     else:
-        print "current_thread_id = old thread ID"
+        print("current_thread_id = old thread ID")
 
 
 def cmd_query_packet(options, cmd, args):
     if args:
-        print "%s%s" % (cmd, args)
+        print("%s%s" % (cmd, args))
     else:
-        print "%s" % (cmd)
+        print("%s" % (cmd))
     return False
 
 
 def rsp_ok_error(rsp):
-    print "rsp: ", rsp
+    print("rsp: ", rsp)
 
 
 def rsp_ok_means_supported(options, cmd, cmd_args, rsp):
     if rsp == 'OK':
-        print "%s%s is supported" % (cmd, cmd_args)
+        print("%s%s is supported" % (cmd, cmd_args))
     elif rsp == '':
-        print "%s%s is not supported" % (cmd, cmd_args)
+        print("%s%s is not supported" % (cmd, cmd_args))
     else:
-        print "%s%s -> %s" % (cmd, cmd_args, rsp)
+        print("%s%s -> %s" % (cmd, cmd_args, rsp))
 
 
 def rsp_ok_means_success(options, cmd, cmd_args, rsp):
     if rsp == 'OK':
-        print "success"
+        print("success")
     elif rsp == '':
-        print "%s%s is not supported" % (cmd, cmd_args)
+        print("%s%s is not supported" % (cmd, cmd_args))
     else:
-        print "%s%s -> %s" % (cmd, cmd_args, rsp)
+        print("%s%s -> %s" % (cmd, cmd_args, rsp))
 
 
 def dump_key_value_pairs(key_value_pairs):
     max_key_len = 0
     for key_value_pair in key_value_pairs:
         key_len = len(key_value_pair[0])
         if max_key_len < key_len:
             max_key_len = key_len
     for key_value_pair in key_value_pairs:
         key = key_value_pair[0]
         value = key_value_pair[1]
         unhex_value = get_hex_string_if_all_printable(value)
         if unhex_value:
-            print "%*s = %s (%s)" % (max_key_len, key, value, unhex_value)
+            print("%*s = %s (%s)" % (max_key_len, key, value, unhex_value))
         else:
-            print "%*s = %s" % (max_key_len, key, value)
+            print("%*s = %s" % (max_key_len, key, value))
 
 
 def rsp_dump_key_value_pairs(options, cmd, cmd_args, rsp):
     if rsp:
-        print '%s response:' % (cmd)
+        print('%s response:' % (cmd))
         packet = Packet(rsp)
         key_value_pairs = packet.get_key_value_pairs()
         dump_key_value_pairs(key_value_pairs)
     else:
-        print "not supported"
+        print("not supported")
 
 
 def cmd_c(options, cmd, args):
-    print "continue()"
+    print("continue()")
     return False
 
 
 def cmd_s(options, cmd, args):
-    print "step()"
+    print("step()")
     return False
 
 
 def cmd_qSpeedTest(options, cmd, args):
-    print("qSpeedTest: cmd='%s', args='%s'" % (cmd, args))
+    print(("qSpeedTest: cmd='%s', args='%s'" % (cmd, args)))
 
 
 def rsp_qSpeedTest(options, cmd, cmd_args, rsp):
-    print("qSpeedTest: rsp='%s' cmd='%s', args='%s'" % (rsp, cmd, args))
+    print(("qSpeedTest: rsp='%s' cmd='%s', args='%s'" % (rsp, cmd, args)))
 
 
 def cmd_vCont(options, cmd, args):
     if args == '?':
-        print "%s: get supported extended continue modes" % (cmd)
+        print("%s: get supported extended continue modes" % (cmd))
     else:
         got_other_threads = 0
         s = ''
         for thread_action in string.split(args[1:], ';'):
             (short_action, thread) = string.split(thread_action, ':')
             tid = int(thread, 16)
             if short_action == 'c':
                 action = 'continue'
             elif short_action == 's':
                 action = 'step'
             elif short_action[0] == 'C':
                 action = 'continue with signal 0x%s' % (short_action[1:])
             elif short_action == 'S':
                 action = 'step with signal 0x%s' % (short_action[1:])
             else:
                 action = short_action
             if s:
                 s += ', '
             if tid == -1:
                 got_other_threads = 1
                 s += 'other-threads:'
             else:
                 s += 'thread 0x%4.4x: %s' % (tid, action)
         if got_other_threads:
-            print "extended_continue (%s)" % (s)
+            print("extended_continue (%s)" % (s))
         else:
-            print "extended_continue (%s, other-threads: suspend)" % (s)
+            print("extended_continue (%s, other-threads: suspend)" % (s))
     return False
 
 
 def rsp_vCont(options, cmd, cmd_args, rsp):
     if cmd_args == '?':
         # Skip the leading 'vCont;'
         rsp = rsp[6:]
         modes = string.split(rsp, ';')
if cmd_args == '?':
             elif mode == 's':
                 s += 'step'
             elif mode == 'S':
                 s += 'step with signal'
             elif mode == 't':
                 s += 'stop'
             # else:
             #     s += 'unrecognized vCont mode: ', str(mode)
-        print s
+        print(s)
     elif rsp:
         if rsp[0] == 'T' or rsp[0] == 'S' or rsp[0] == 'W' or rsp[0] == 'X':
             rsp_stop_reply(options, cmd, cmd_args, rsp)
             return
         if rsp[0] == 'O':
-            print "stdout: %s" % (rsp)
+            print("stdout: %s" % (rsp))
             return
     else:
-        print "not supported (cmd = '%s', args = '%s', rsp = '%s')" % (cmd, cmd_args, rsp)
+        print("not supported (cmd = '%s', args = '%s', rsp = '%s')" % (cmd, cmd_args, rsp))
 
 
 def cmd_vAttach(options, cmd, args):
     (extra_command, args) = string.split(args, ';')
     if extra_command:
-        print "%s%s(%s)" % (cmd, extra_command, args)
+        print("%s%s(%s)" % (cmd, extra_command, args))
     else:
-        print "attach(pid = %u)" % int(args, 16)
+        print("attach(pid = %u)" % int(args, 16))
     return False
 
 
 def cmd_qRegisterInfo(options, cmd, args):
-    print 'query_register_info(reg_num=%i)' % (int(args, 16))
+    print('query_register_info(reg_num=%i)' % (int(args, 16)))
     return False
 
 
 def rsp_qRegisterInfo(options, cmd, cmd_args, rsp):
     global g_max_register_info_name_len
-    print 'query_register_info(reg_num=%i):' % (int(cmd_args, 16)),
+    print('query_register_info(reg_num=%i):' % (int(cmd_args, 16)), end=' ')
     if len(rsp) == 3 and rsp[0] == 'E':
         g_max_register_info_name_len = 0
         for reg_info in g_register_infos:
             name_len = len(reg_info.name())
             if g_max_register_info_name_len < name_len:
                 g_max_register_info_name_len = name_len
-        print' DONE'
+        print(' DONE')
     else:
         packet = Packet(rsp)
         reg_info = RegisterInfo(packet.get_key_value_pairs())
         g_register_infos.append(reg_info)
-        print reg_info
+        print(reg_info)
     return False
 
 
 def cmd_qThreadInfo(options, cmd, args):
     if cmd == 'qfThreadInfo':
         query_type = 'first'
     else:
         query_type = 'subsequent'
-    print 'get_current_thread_list(type=%s)' % (query_type)
+    print('get_current_thread_list(type=%s)' % (query_type))
     return False
 
 
 def rsp_qThreadInfo(options, cmd, cmd_args, rsp):
     packet = Packet(rsp)
     response_type = packet.get_char()
     if response_type == 'm':
         tids = packet.split_hex(';', 'big')
         for i, tid in enumerate(tids):
             if i:
-                print ',',
-            print '0x%x' % (tid),
-        print
+                print(',', end=' ')
+            print('0x%x' % (tid), end=' ')
+        print()
     elif response_type == 'l':
-        print 'END'
+        print('END')
 
 
 def rsp_hex_big_endian(options, cmd, cmd_args, rsp):
     if rsp == '':
-        print "%s%s is not supported" % (cmd, cmd_args)
+        print("%s%s is not supported" % (cmd, cmd_args))
     else:
         packet = Packet(rsp)
         uval = packet.get_hex_uint('big')
-        print '%s: 0x%x' % (cmd, uval)
+        print('%s: 0x%x' % (cmd, uval))
 
 
 def cmd_read_mem_bin(options, cmd, args):
     # x0x7fff5fc39200,0x200
     packet = Packet(args)
     addr = packet.get_hex_uint('big')
     comma = packet.get_char()
     size = packet.get_hex_uint('big')
-    print 'binary_read_memory (addr = 0x%16.16x, size = %u)' % (addr, size)
+    print('binary_read_memory (addr = 0x%16.16x, size = %u)' % (addr, size))
     return False
 
 
 def rsp_mem_bin_bytes(options, cmd, cmd_args, rsp):
     packet = Packet(cmd_args)
     addr = packet.get_hex_uint('big')
     comma = packet.get_char()
     size = packet.get_hex_uint('big')
-    print 'memory:'
+    print('memory:')
     if size > 0:
         dump_hex_memory_buffer(addr, rsp)
 
 
 def cmd_read_memory(options, cmd, args):
     packet = Packet(args)
     addr = packet.get_hex_uint('big')
     comma = packet.get_char()
     size = packet.get_hex_uint('big')
-    print 'read_memory (addr = 0x%16.16x, size = %u)' % (addr, size)
+    print('read_memory (addr = 0x%16.16x, size = %u)' % (addr, size))
     return False
 
 
 def dump_hex_memory_buffer(addr, hex_byte_str):
     packet = Packet(hex_byte_str)
     idx = 0
     ascii = ''
     uval = packet.get_hex_uint8()
     while uval is not None:
         if ((idx % 16) == 0):
             if ascii:
-                print '  ', ascii
+                print('  ', ascii)
                 ascii = ''
-            print '0x%x:' % (addr + idx),
-        print '%2.2x' % (uval),
+            print('0x%x:' % (addr + idx), end=' ')
+        print('%2.2x' % (uval), end=' ')
         if 0x20 <= uval and uval < 0x7f:
             ascii += '%c' % uval
         else:
             ascii += '.'
         uval = packet.get_hex_uint8()
         idx = idx + 1
     if ascii:
-        print '  ', ascii
+        print('  ', ascii)
         ascii = ''
 
 
 def cmd_write_memory(options, cmd, args):
     packet = Packet(args)
     addr = packet.get_hex_uint('big')
     if packet.get_char() != ',':
-        print 'error: invalid write memory command (missing comma after address)'
+        print('error: invalid write memory command (missing comma after address)')
         return
     size = packet.get_hex_uint('big')
     if packet.get_char() != ':':
-        print 'error: invalid write memory command (missing colon after size)'
+        print('error: invalid write memory command (missing colon after size)')
         return
-    print 'write_memory (addr = 0x%16.16x, size = %u, data:' % (addr, size)
+    print('write_memory (addr = 0x%16.16x, size = %u, data:' % (addr, size))
     dump_hex_memory_buffer(addr, packet.str)
     return False
 
 
 def cmd_alloc_memory(options, cmd, args):
     packet = Packet(args)
     byte_size = packet.get_hex_uint('big')
     if packet.get_char() != ',':
-        print 'error: invalid allocate memory command (missing comma after address)'
+        print('error: invalid allocate memory command (missing comma after address)')
         return
-    print 'allocate_memory (byte-size = %u (0x%x), permissions = %s)' % (byte_size, byte_size, packet.str)
+    print('allocate_memory (byte-size = %u (0x%x), permissions = %s)' % (byte_size, byte_size, packet.str))
     return False
 
 
 def rsp_alloc_memory(options, cmd, cmd_args, rsp):
     packet = Packet(rsp)
     addr = packet.get_hex_uint('big')
-    print 'addr = 0x%x' % addr
+    print('addr = 0x%x' % addr)
 
 
 def cmd_dealloc_memory(options, cmd, args):
     packet = Packet(args)
     addr = packet.get_hex_uint('big')
     if packet.get_char() != ',':
-        print 'error: invalid allocate memory command (missing comma after address)'
+        print('error: invalid allocate memory command (missing comma after address)')
     else:
-        print 'deallocate_memory (addr = 0x%x, permissions = %s)' % (addr, packet.str)
+        print('deallocate_memory (addr = 0x%x, permissions = %s)' % (addr, packet.str))
     return False
 
 
 def rsp_memory_bytes(options, cmd, cmd_args, rsp):
     addr = Packet(cmd_args).get_hex_uint('big')
     dump_hex_memory_buffer(addr, rsp)
 
 
if packet.str:
         thread_info = packet.get_key_value_pairs()
         tid = int(thread_info[0][1], 16)
     s = 'read_register (reg_num=%u' % reg_num
     if name:
         s += ' (%s)' % (name)
     if tid is not None:
         s += ', tid = 0x%4.4x' % (tid)
     s += ')'
-    print s
+    print(s)
     return False
 
 
 def rsp_read_one_reg(options, cmd, cmd_args, rsp):
     packet = Packet(cmd_args)
     reg_num = packet.get_hex_uint('big')
-    print get_register_name_equal_value(options, reg_num, rsp)
+    print(get_register_name_equal_value(options, reg_num, rsp))
 
 
 def cmd_write_one_reg(options, cmd, args):
     packet = Packet(args)
     reg_num = packet.get_hex_uint('big')
     if packet.get_char() != '=':
-        print 'error: invalid register write packet'
+        print('error: invalid register write packet')
     else:
         name = None
         hex_value_str = packet.get_hex_chars()
         tid = get_thread_from_thread_suffix(packet.str)
         s = 'write_register (reg_num=%u' % reg_num
         if name:
             s += ' (%s)' % (name)
         s += ', value = '
         s += get_register_name_equal_value(options, reg_num, hex_value_str)
         if tid is not None:
             s += ', tid = 0x%4.4x' % (tid)
         s += ')'
-        print s
+        print(s)
     return False
 
 
 def dump_all_regs(packet):
     for reg_info in g_register_infos:
         nibble_size = reg_info.bit_size() / 4
         hex_value_str = packet.get_hex_chars(nibble_size)
         if hex_value_str is not None:
             value = reg_info.get_value_from_hex_string(hex_value_str)
-            print '%*s = %s' % (g_max_register_info_name_len, reg_info.name(), value)
+            print('%*s = %s' % (g_max_register_info_name_len, reg_info.name(), value))
         else:
             return
 
 
 def cmd_read_all_regs(cmd, cmd_args):
     packet = Packet(cmd_args)
     packet.get_char()  # toss the 'g' command character
     tid = get_thread_from_thread_suffix(packet.str)
     if tid is not None:
-        print 'read_all_register(thread = 0x%4.4x)' % tid
+        print('read_all_register(thread = 0x%4.4x)' % tid)
     else:
-        print 'read_all_register()'
+        print('read_all_register()')
     return False
 
 
 def rsp_read_all_regs(options, cmd, cmd_args, rsp):
     packet = Packet(rsp)
     dump_all_regs(packet)
 
 
 def cmd_write_all_regs(options, cmd, args):
     packet = Packet(args)
-    print 'write_all_registers()'
+    print('write_all_registers()')
     dump_all_regs(packet)
     return False
 
 g_bp_types = ["software_bp", "hardware_bp", "write_wp", "read_wp", "access_wp"]
 
 
 def cmd_bp(options, cmd, args):
     if cmd == 'Z':
         s = 'set_'
     else:
         s = 'clear_'
     packet = Packet(args)
     bp_type = packet.get_hex_uint('big')
     packet.get_char()  # Skip ,
     bp_addr = packet.get_hex_uint('big')
     packet.get_char()  # Skip ,
     bp_size = packet.get_hex_uint('big')
     s += g_bp_types[bp_type]
     s += " (addr = 0x%x, size = %u)" % (bp_addr, bp_size)
-    print s
+    print(s)
     return False
 
 
 def cmd_mem_rgn_info(options, cmd, args):
     packet = Packet(args)
     packet.get_char()  # skip ':' character
     addr = packet.get_hex_uint('big')
-    print 'get_memory_region_info (addr=0x%x)' % (addr)
+    print('get_memory_region_info (addr=0x%x)' % (addr))
     return False
 
 
 def cmd_kill(options, cmd, args):
-    print 'kill_process()'
+    print('kill_process()')
     return False
 
 
 def cmd_jThreadsInfo(options, cmd, args):
-    print 'jThreadsInfo()'
+    print('jThreadsInfo()')
     return False
 
 
 def cmd_jGetLoadedDynamicLibrariesInfos(options, cmd, args):
-    print 'jGetLoadedDynamicLibrariesInfos()'
+    print('jGetLoadedDynamicLibrariesInfos()')
     return False
 
 
 def decode_packet(s, start_index=0):
     # print '\ndecode_packet("%s")' % (s[start_index:])
     index = s.find('}', start_index)
     have_escapes = index != -1
     if have_escapes:
         normal_s = s[start_index:index]
     else:
         normal_s = s[start_index:]
     # print 'normal_s = "%s"' % (normal_s)
     if have_escapes:
         escape_char = '%c' % (ord(s[index + 1]) ^ 0x20)
         # print 'escape_char for "%s" = %c' % (s[index:index+2], escape_char)
         return normal_s + escape_char + decode_packet(s, index + 2)
     else:
         return normal_s
 
 
 def rsp_json(options, cmd, cmd_args, rsp):
-    print '%s() reply:' % (cmd)
+    print('%s() reply:' % (cmd))
     json_tree = json.loads(rsp)
-    print json.dumps(json_tree, indent=4, separators=(',', ': '))
+    print(json.dumps(json_tree, indent=4, separators=(',', ': ')))
 
 
 def rsp_jGetLoadedDynamicLibrariesInfos(options, cmd, cmd_args, rsp):
     if cmd_args:
         rsp_json(options, cmd, cmd_args, rsp)
     else:
         rsp_ok_means_supported(options, cmd, cmd_args, rsp)
 
for (line_index, line) in enumerate(lines):
         is_command = False
         direction = None
         if m:
             direction = m.group('direction')
             is_command = direction == 'send'
             packet = m.group('packet')
             sys.stdout.write(options.colors.green())
             if not options.quiet and not hide_next_response:
-                print '#  ', line
+                print('#  ', line)
             sys.stdout.write(options.colors.reset())
 
             # print 'direction = "%s", packet = "%s"' % (direction, packet)
 
             if packet[0] == '+':
                 if is_command:
-                    print '-->',
+                    print('-->', end=' ')
                 else:
-                    print '<--',
+                    print('<--', end=' ')
                 if not options.quiet:
-                    print 'ACK'
+                    print('ACK')
                 continue
             elif packet[0] == '-':
                 if is_command:
-                    print '-->',
+                    print('-->', end=' ')
                 else:
-                    print '<--',
+                    print('<--', end=' ')
                 if not options.quiet:
-                    print 'NACK'
+                    print('NACK')
                 continue
             elif packet[0] == '$':
                 m = packet_contents_name_regex.match(packet)
                 if not m and packet[0] == '$':
                     multiline_packet = packet
                     idx = line_index + 1
                     while idx < num_lines:
                         if not options.quiet and not hide_next_response:
-                            print '#  ', lines[idx]
+                            print('#  ', lines[idx])
                         multiline_packet += lines[idx]
                         m = packet_contents_name_regex.match(multiline_packet)
                         if m:
                             packet = multiline_packet
                             skip_count = idx - line_index
                             break
                         else:
                             idx += 1
                 if m:
                     if is_command:
-                        print '-->',
+                        print('-->', end=' ')
                     else:
-                        print '<--',
+                        print('<--', end=' ')
                     contents = decode_packet(m.group(1))
                     if is_command:
                         hide_next_response = False
                         m = packet_names_regex.match(contents)
                         if m:
                             last_command = m.group(1)
                             if last_command == '?':
                                 last_command = '\\?'
for (line_index, line) in enumerate(lines):
                                 packet_name = contents
                             last_command = None
                             last_command_args = None
                             last_command_packet = None
                     elif last_command:
                         gdb_remote_commands[last_command]['rsp'](
                             options, last_command, last_command_args, contents)
                 else:
-                    print 'error: invalid packet: "', packet, '"'
+                    print('error: invalid packet: "', packet, '"')
             else:
-                print '???'
+                print('???')
         else:
-            print '## ', line
+            print('## ', line)
         match = timestamp_regex.match(line)
         if match:
             curr_time = float(match.group(2))
             if last_time and not is_command:
                 delta = curr_time - last_time
                 all_packet_times.append(delta)
             delta = 0.0
             if base_time:
for (line_index, line) in enumerate(lines):
                     if packet_name not in packet_times:
                         packet_times[packet_name] = []
                     packet_times[packet_name].append(delta)
                     packet_name = None
                 if min_time > delta:
                     min_time = delta
 
             if not options or not options.quiet:
-                print '%s%.6f %+.6f%s' % (match.group(1),
+                print('%s%.6f %+.6f%s' % (match.group(1),
                                           curr_time - base_time,
                                           delta,
-                                          match.group(3))
+                                          match.group(3)))
             last_time = curr_time
         # else:
         #     print line
     (average, std_dev) = calculate_mean_and_standard_deviation(all_packet_times)
     if average and std_dev:
-        print '%u packets with average packet time of %f and standard deviation of %f' % (len(all_packet_times), average, std_dev)
+        print('%u packets with average packet time of %f and standard deviation of %f' % (len(all_packet_times), average, std_dev))
     if packet_total_times:
         total_packet_time = 0.0
         total_packet_count = 0
         for key, vvv in packet_total_times.items():
             # print '  key = (%s) "%s"' % (type(key), key)
             # print 'value = (%s) %s' % (type(vvv), vvv)
             # if type(vvv) == 'float':
             total_packet_time += vvv
         for key, vvv in packet_counts.items():
             total_packet_count += vvv
 
-        print '#------------------------------------------------------------'
-        print '# Packet timing summary:'
-        print '# Totals: time = %6f, count = %6d' % (total_packet_time,
-                                                     total_packet_count)
-        print '# Min packet time: time = %6f' % (min_time)
-        print '#------------------------------------------------------------'
-        print '# Packet                   Time (sec)  Percent Count  Latency'
-        print '#------------------------- ----------- ------- ------ -------'
+        print('#------------------------------------------------------------')
+        print('# Packet timing summary:')
+        print('# Totals: time = %6f, count = %6d' % (total_packet_time,
+                                                     total_packet_count))
+        print('# Min packet time: time = %6f' % (min_time))
+        print('#------------------------------------------------------------')
+        print('# Packet                   Time (sec)  Percent Count  Latency')
+        print('#------------------------- ----------- ------- ------ -------')
         if options and options.sort_count:
             res = sorted(
                 packet_counts,
                 key=packet_counts.__getitem__,
                 reverse=True)
         else:
             res = sorted(
                 packet_total_times,
                 key=packet_total_times.__getitem__,
                 reverse=True)
 
         if last_time > 0.0:
             for item in res:
                 packet_total_time = packet_total_times[item]
                 packet_percent = (
                     packet_total_time / total_packet_time) * 100.0
                 packet_count = packet_counts[item]
-                print "  %24s %11.6f  %5.2f%% %6d %9.6f" % (
+                print("  %24s %11.6f  %5.2f%% %6d %9.6f" % (
                         item, packet_total_time, packet_percent, packet_count,
-                        float(packet_total_time) / float(packet_count))
+                        float(packet_total_time) / float(packet_count)))
         if options.plot:
             plot_latencies(packet_times)
 
 if __name__ == '__main__':
     usage = "usage: gdbremote [options]"
     description = '''The command disassembles a GDB remote packet log.'''
     parser = optparse.OptionParser(
         description=description,
parser.add_option(
         '--crashlog',
         type='string',
         dest='crashlog',
         help='symbolicate using a darwin crash log file',
         default=False)
     try:
         (options, args) = parser.parse_args(sys.argv[1:])
     except:
-        print 'error: argument error'
+        print('error: argument error')
         sys.exit(1)
 
     options.colors = TerminalColors(options.color)
     options.symbolicator = None
     if options.crashlog:
         import lldb
         lldb.debugger = lldb.SBDebugger.Create()
         import lldb.macosx.crashlog
         options.symbolicator = lldb.macosx.crashlog.CrashLog(options.crashlog)
-        print '%s' % (options.symbolicator)
+        print('%s' % (options.symbolicator))
 
     # This script is being run from the command line, create a debugger in case we are
     # going to use any debugger functions in our function.
     if len(args):
         for file in args:
-            print '#----------------------------------------------------------------------'
-            print "# GDB remote log file: '%s'" % file
-            print '#----------------------------------------------------------------------'
+            print('#----------------------------------------------------------------------')
+            print("# GDB remote log file: '%s'" % file)
+            print('#----------------------------------------------------------------------')
             parse_gdb_log_file(file, options)
         if options.symbolicator:
-            print '%s' % (options.symbolicator)
+            print('%s' % (options.symbolicator))
     else:
         parse_gdb_log(sys.stdin, options)
 
 else:
     import lldb
     if lldb.debugger:
         # This initializer is being run from LLDB in the embedded command interpreter
         # Add any commands contained in this module to LLDB
         lldb.debugger.HandleCommand(
             'command script add -f gdbremote.start_gdb_log start_gdb_log')
         lldb.debugger.HandleCommand(
             'command script add -f gdbremote.stop_gdb_log stop_gdb_log')
-        print 'The "start_gdb_log" and "stop_gdb_log" commands are now installed and ready for use, type "start_gdb_log --help" or "stop_gdb_log --help" for more information'
+        print('The "start_gdb_log" and "stop_gdb_log" commands are now installed and ready for use, type "start_gdb_log --help" or "stop_gdb_log --help" for more information')

examples/python/globals.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # For the shells csh, tcsh:
 #   ( setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ; ./globals.py <path> [<path> ...])
 #
 # For the shells sh, bash:
 #   PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ./globals.py <path> [<path> ...]
 #----------------------------------------------------------------------
+from __future__ import print_function
 
 import lldb
 import commands
 import optparse
 import os
 import shlex
 import sys
 
if target:
                         global_names.append(global_name)
                         # Find all global variables by name
                         global_variable_list = module.FindGlobalVariables(
                             target, global_name, lldb.UINT32_MAX)
                         if global_variable_list:
                             # Print results for anything that matched
                             for global_variable in global_variable_list:
                                 # returns the global variable name as a string
-                                print 'name = %s' % global_variable.name
+                                print('name = %s' % global_variable.name)
                                 # Returns the variable value as a string
-                                print 'value = %s' % global_variable.value
-                                print 'type = %s' % global_variable.type    # Returns an lldb.SBType object
+                                print('value = %s' % global_variable.value)
+                                print('type = %s' % global_variable.type)    # Returns an lldb.SBType object
                                 # Returns an lldb.SBAddress (section offset
                                 # address) for this global
-                                print 'addr = %s' % global_variable.addr
+                                print('addr = %s' % global_variable.addr)
                                 # Returns the file virtual address for this
                                 # global
-                                print 'file_addr = 0x%x' % global_variable.addr.file_addr
+                                print('file_addr = 0x%x' % global_variable.addr.file_addr)
                                 # returns the global variable value as a string
-                                print 'location = %s' % global_variable.location
+                                print('location = %s' % global_variable.location)
                                 # Returns the size in bytes of this global
                                 # variable
-                                print 'size = %s' % global_variable.size
-                                print
+                                print('size = %s' % global_variable.size)
+                                print()
 
 
 def globals(command_args):
     '''Extract all globals from any arguments which must be paths to object files.'''
     usage = "usage: %prog [options] <PATH> [PATH ...]"
     description = '''This command will find all globals in the specified object file and return an list() of lldb.SBValue objects (which might be empty).'''
     parser = optparse.OptionParser(
         description=description,

examples/python/jump.py

+from __future__ import print_function
+
 import lldb
 import re
 
 
 def parse_linespec(linespec, frame, result):
     """Handles a subset of GDB-style linespecs.  Specifically:
 
        number           - A line in the current file
if len(addresses) > 1:
             return
 
     frame.SetPC(desired_address.GetLoadAddress(target))
 
 if lldb.debugger:
     # Module is being run inside the LLDB interpreter
     jump.__doc__ = usage_string()
     lldb.debugger.HandleCommand('command script add -f jump.jump jump')
-    print 'The "jump" command has been installed, type "help jump" or "jump <ENTER>" for detailed help.'
+    print('The "jump" command has been installed, type "help jump" or "jump <ENTER>" for detailed help.')

examples/python/lldb_module_utils.py

 #!/usr/bin/python
+from __future__ import print_function
 
 import lldb
 import optparse
 import shlex
 import string
 import sys
 
 
def __call__(self, debugger, command, exe_ctx, result):
             return
 
         for module_path in args:
             module = target.module[module_path]
             if not module:
                 result.SetError('no module found that matches "%s".' % (module_path))
                 return
             num_cus = module.GetNumCompileUnits()
-            print >>result, 'Module: "%s"' % (module.file.fullpath),
+            print('Module: "%s"' % (module.file.fullpath), end=' ', file=result)
             if num_cus == 0:
-                print >>result, 'no debug info.'
+                print('no debug info.', file=result)
                 continue
-            print >>result, 'has %u compile units:' % (num_cus)
+            print('has %u compile units:' % (num_cus), file=result)
             for cu_idx in range(num_cus):
                 cu = module.GetCompileUnitAtIndex(cu_idx)
-                print >>result, '  Compile Unit: %s' % (cu.file.fullpath)
+                print('  Compile Unit: %s' % (cu.file.fullpath), file=result)
                 for line_idx in range(cu.GetNumLineEntries()):
                     line_entry = cu.GetLineEntryAtIndex(line_idx)
                     start_file_addr = line_entry.addr.file_addr
                     end_file_addr = line_entry.end_addr.file_addr
                     # If the two addresses are equal, this line table entry
                     # is a termination entry
                     if options.verbose:
                         if start_file_addr != end_file_addr:
def __call__(self, debugger, command, exe_ctx, result):
             return
 
         for module_path in args:
             module = target.module[module_path]
             if not module:
                 result.SetError('no module found that matches "%s".' % (module_path))
                 return
             num_cus = module.GetNumCompileUnits()
-            print >>result, 'Module: "%s"' % (module.file.fullpath),
+            print('Module: "%s"' % (module.file.fullpath), end=' ', file=result)
             if num_cus == 0:
-                print >>result, 'no debug info.'
+                print('no debug info.', file=result)
                 continue
-            print >>result, 'has %u compile units:' % (num_cus)
+            print('has %u compile units:' % (num_cus), file=result)
             for i in range(num_cus):
                 cu = module.GetCompileUnitAtIndex(i)
-                print >>result, '  Compile Unit: %s' % (cu.file.fullpath)
+                print('  Compile Unit: %s' % (cu.file.fullpath), file=result)
                 if options.support_files:
                     num_support_files = cu.GetNumSupportFiles()
                     for j in range(num_support_files):
                         path = cu.GetSupportFileAtIndex(j).fullpath
-                        print >>result, '    file[%u]: %s' % (j, path)
+                        print('    file[%u]: %s' % (j, path), file=result)
 
 
 def __lldb_init_module(debugger, dict):
     # This initializer is being run from LLDB in the embedded command interpreter
 
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
         'command script add -c %s.DumpLineTables %s' % (__name__,
                                                         DumpLineTables.command_name))
     debugger.HandleCommand(
         'command script add -c %s.DumpFiles %s' % (__name__, DumpFiles.command_name))
-    print 'The "%s" and "%s" commands have been installed.' % (DumpLineTables.command_name,
-                                                               DumpFiles.command_name)
+    print('The "%s" and "%s" commands have been installed.' % (DumpLineTables.command_name,
+                                                               DumpFiles.command_name))

examples/python/lldbtk.py

 
 
 @lldb.command("tk-variables")
 def tk_variable_display(debugger, command, result, dict):
     # needed for tree creation in TK library as it uses sys.argv...
     sys.argv = ['tk-variables']
     target = debugger.GetSelectedTarget()
     if not target:
-        print >>result, "invalid target"
+        print("invalid target", file=result)
         return
     process = target.GetProcess()
     if not process:
-        print >>result, "invalid process"
+        print("invalid process", file=result)
         return
     thread = process.GetSelectedThread()
     if not thread:
-        print >>result, "invalid thread"
+        print("invalid thread", file=result)
         return
     frame = thread.GetSelectedFrame()
     if not frame:
-        print >>result, "invalid frame"
+        print("invalid frame", file=result)
         return
     # Parse command line args
     command_args = shlex.split(command)
     column_dicts = [{'id': '#0', 'text': 'Name', 'anchor': W, 'stretch': 0},
                     {'id': 'typename', 'text': 'Type', 'anchor': W, 'stretch': 0},
                     {'id': 'value', 'text': 'Value', 'anchor': W, 'stretch': 0},
                     {'id': 'summary', 'text': 'Summary', 'anchor': W, 'stretch': 1}]
     tree = DelegateTree(
         column_dicts,
         FrameTreeItemDelegate(frame),
         'Variables',
         'lldb-tk-variables')
     tree.mainloop()
 
 
 @lldb.command("tk-process")
 def tk_process_display(debugger, command, result, dict):
     # needed for tree creation in TK library as it uses sys.argv...
     sys.argv = ['tk-process']
     target = debugger.GetSelectedTarget()
     if not target:
-        print >>result, "invalid target"
+        print("invalid target", file=result)
         return
     process = target.GetProcess()
     if not process:
-        print >>result, "invalid process"
+        print("invalid process", file=result)
         return
     # Parse command line args
     columnd_dicts = [{'id': '#0', 'text': 'Name', 'anchor': W, 'stretch': 0},
                      {'id': 'value', 'text': 'Value', 'anchor': W, 'stretch': 0},
                      {'id': 'summary', 'text': 'Summary', 'anchor': W, 'stretch': 1}]
     command_args = shlex.split(command)
     tree = DelegateTree(
         columnd_dicts,
         ProcessTreeItemDelegate(process),
         'Process',
         'lldb-tk-process')
     tree.mainloop()
 
 
 @lldb.command("tk-target")
 def tk_target_display(debugger, command, result, dict):
     # needed for tree creation in TK library as it uses sys.argv...
     sys.argv = ['tk-target']
     target = debugger.GetSelectedTarget()
     if not target:
-        print >>result, "invalid target"
+        print("invalid target", file=result)
         return
     # Parse command line args
     columnd_dicts = [{'id': '#0', 'text': 'Name', 'anchor': W, 'stretch': 0},
                      {'id': 'value', 'text': 'Value', 'anchor': W, 'stretch': 0},
                      {'id': 'summary', 'text': 'Summary', 'anchor': W, 'stretch': 1}]
     command_args = shlex.split(command)
     tree = DelegateTree(
         columnd_dicts,
         TargetTreeItemDelegate(target),
         'Target',
         'lldb-tk-target')
     tree.mainloop()

examples/python/mach_o.py

 #!/usr/bin/python
+from __future__ import print_function
 
 import cmd
 import dict_utils
 import file_extract
 import optparse
 import re
 import struct
 import string
def dump_memory(base_addr, data, hex_bytes_len, num_per_line):
     if hex_bytes_len == -1:
         hex_bytes_len = len(hex_bytes)
     addr = base_addr
     ascii_str = ''
     i = 0
     while i < hex_bytes_len:
         if ((i / 2) % num_per_line) == 0:
             if i > 0:
-                print ' %s' % (ascii_str)
+                print(' %s' % (ascii_str))
                 ascii_str = ''
-            print '0x%8.8x:' % (addr + i),
+            print('0x%8.8x:' % (addr + i), end=' ')
         hex_byte = hex_bytes[i:i + 2]
-        print hex_byte,
+        print(hex_byte, end=' ')
         int_byte = int(hex_byte, 16)
         ascii_char = '%c' % (int_byte)
         if int_byte >= 32 and int_byte < 127:
             ascii_str += ascii_char
         else:
             ascii_str += '.'
         i = i + 2
     if ascii_str:
         if (i / 2) % num_per_line:
             padding = num_per_line - ((i / 2) % num_per_line)
         else:
             padding = 0
-        print '%*s%s' % (padding * 3 + 1, '', ascii_str)
-    print
+        print('%*s%s' % (padding * 3 + 1, '', ascii_str))
+    print()
 
 
 class TerminalColors:
     '''Simple terminal colors class'''
 
     def __init__(self, enabled=True):
         # TODO: discover terminal type from "file" and disable if
         # it can't handle the color codes

 
 
 def dump_hex_bytes(addr, s, bytes_per_line=16):
     i = 0
     line = ''
     for ch in s:
         if (i % bytes_per_line) == 0:
             if line:
-                print line
+                print(line)
             line = '%#8.8x: ' % (addr + i)
         line += "%02X " % ord(ch)
         i += 1
-    print line
+    print(line)
 
 
 def dump_hex_byte_string_diff(addr, a, b, bytes_per_line=16):
     i = 0
     line = ''
     a_len = len(a)
     b_len = len(b)
     if a_len < b_len:
for i in range(max_len):
             ch_b = b[i]
             if not ch:
                 ch = ch_b
         else:
             ch_b = None
         mismatch = ch_a != ch_b
         if (i % bytes_per_line) == 0:
             if line:
-                print line
+                print(line)
             line = '%#8.8x: ' % (addr + i)
         if mismatch:
             line += tty_colors.red()
         line += "%02X " % ord(ch)
         if mismatch:
             line += tty_colors.default()
         i += 1
 
-    print line
+    print(line)
 
 
 class Mach:
     """Class that does everything mach-o related"""
 
     class Arch:
         """Class that implements mach-o architectures"""
 
def parse(self, path):
         self.path = path
         try:
             f = open(self.path)
             file_extractor = file_extract.FileExtract(f, '=')
             self.unpack(file_extractor)
             # f.close()
         except IOError as xxx_todo_changeme:
             (errno, strerror) = xxx_todo_changeme.args
-            print "I/O error({0}): {1}".format(errno, strerror)
+            print("I/O error({0}): {1}".format(errno, strerror))
         except ValueError:
-            print "Could not convert data to an integer."
+            print("Could not convert data to an integer.")
         except:
-            print "Unexpected error:", sys.exc_info()[0]
+            print("Unexpected error:", sys.exc_info()[0])
             raise
 
     def compare(self, rhs):
         self.content.compare(rhs.content)
 
     def dump(self, options=None):
         self.content.dump(options)
 
class Universal:
             for i in range(self.nfat_arch):
                 self.archs[i].mach = Mach.Skinny(self.path)
                 data.seek(self.archs[i].offset, 0)
                 skinny_magic = Mach.Magic()
                 skinny_magic.unpack(data)
                 self.archs[i].mach.unpack(data, skinny_magic)
 
         def compare(self, rhs):
-            print 'error: comparing two universal files is not supported yet'
+            print('error: comparing two universal files is not supported yet')
             return False
 
         def dump(self, options):
             if options.dump_header:
-                print
-                print "Universal Mach File: magic = %s, nfat_arch = %u" % (self.magic, self.nfat_arch)
-                print
+                print()
+                print("Universal Mach File: magic = %s, nfat_arch = %u" % (self.magic, self.nfat_arch))
+                print()
             if self.nfat_arch > 0:
                 if options.dump_header:
                     self.archs[0].dump_header(True, options)
                     for i in range(self.nfat_arch):
                         self.archs[i].dump_flat(options)
                 if options.dump_header:
-                    print
+                    print()
                 for i in range(self.nfat_arch):
                     self.archs[i].mach.dump(options)
 
         def dump_header(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_header(True, options)
-                print
+                print()
 
         def dump_load_commands(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_load_commands(True, options)
-                print
+                print()
 
         def dump_sections(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_sections(True, options)
-                print
+                print()
 
         def dump_section_contents(self, options):
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_section_contents(options)
-                print
+                print()
 
         def dump_symtab(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_symtab(True, options)
-                print
+                print()
 
         def dump_symbol_names_matching_regex(self, regex, file=None):
             for i in range(self.nfat_arch):
                 self.archs[i].mach.dump_symbol_names_matching_regex(
                     regex, file)
 
         class ArchInfo:
 
             def __init__(self):
                 self.arch = Mach.Arch(0, 0)
                 self.offset = 0
                 self.size = 0
                 self.align = 0
                 self.mach = None
 
             def unpack(self, data):
                 # Universal headers are always in big endian
                 data.set_byte_order('big')
                 self.arch.cpu, self.arch.sub, self.offset, self.size, self.align = data.get_n_uint32(
                     5)
 
             def dump_header(self, dump_description=True, options=None):
                 if options.verbose:
-                    print "CPU        SUBTYPE    OFFSET     SIZE       ALIGN"
-                    print "---------- ---------- ---------- ---------- ----------"
+                    print("CPU        SUBTYPE    OFFSET     SIZE       ALIGN")
+                    print("---------- ---------- ---------- ---------- ----------")
                 else:
-                    print "ARCH       FILEOFFSET FILESIZE   ALIGN"
-                    print "---------- ---------- ---------- ----------"
+                    print("ARCH       FILEOFFSET FILESIZE   ALIGN")
+                    print("---------- ---------- ---------- ----------")
 
             def dump_flat(self, options):
                 if options.verbose:
-                    print "%#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
+                    print("%#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (self.arch.cpu, self.arch.sub, self.offset, self.size, self.align))
                 else:
-                    print "%-10s %#8.8x %#8.8x %#8.8x" % (self.arch, self.offset, self.size, self.align)
+                    print("%-10s %#8.8x %#8.8x %#8.8x" % (self.arch, self.offset, self.size, self.align))
 
             def dump(self):
-                print "   cputype: %#8.8x" % self.arch.cpu
-                print "cpusubtype: %#8.8x" % self.arch.sub
-                print "    offset: %#8.8x" % self.offset
-                print "      size: %#8.8x" % self.size
-                print "     align: %#8.8x" % self.align
+                print("   cputype: %#8.8x" % self.arch.cpu)
+                print("cpusubtype: %#8.8x" % self.arch.sub)
+                print("    offset: %#8.8x" % self.offset)
+                print("      size: %#8.8x" % self.size)
+                print("     align: %#8.8x" % self.align)
 
             def __str__(self):
                 return "Mach.Universal.ArchInfo: %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (
                     self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
 
             def __repr__(self):
                 return "Mach.Universal.ArchInfo: %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (
                     self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
class Skinny:
                 lc.unpack(self, data)
             elif (lc_command == LC_ENCRYPTION_INFO):
                 lc = Mach.EncryptionInfoLoadCommand(lc)
                 lc.unpack(self, data)
             lc.skip(data)
             return lc
 
         def compare(self, rhs):
-            print "\nComparing:"
-            print "a) %s %s" % (self.arch, self.path)
-            print "b) %s %s" % (rhs.arch, rhs.path)
+            print("\nComparing:")
+            print("a) %s %s" % (self.arch, self.path))
+            print("b) %s %s" % (rhs.arch, rhs.path))
             result = True
             if self.type == rhs.type:
                 for lhs_section in self.sections[1:]:
                     rhs_section = rhs.get_section_by_section(lhs_section)
                     if rhs_section:
-                        print 'comparing %s.%s...' % (lhs_section.segname, lhs_section.sectname),
+                        print('comparing %s.%s...' % (lhs_section.segname, lhs_section.sectname), end=' ')
                         sys.stdout.flush()
                         lhs_data = lhs_section.get_contents(self)
                         rhs_data = rhs_section.get_contents(rhs)
                         if lhs_data and rhs_data:
                             if lhs_data == rhs_data:
-                                print 'ok'
+                                print('ok')
                             else:
                                 lhs_data_len = len(lhs_data)
                                 rhs_data_len = len(rhs_data)
                                 # if lhs_data_len < rhs_data_len:
                                 #     if lhs_data == rhs_data[0:lhs_data_len]:
                                 #         print 'section data for %s matches the first %u bytes' % (lhs_section.sectname, lhs_data_len)
                                 #     else:
                                 #         # TODO: check padding
                                 #         result = False
                                 # elif lhs_data_len > rhs_data_len:
                                 #     if lhs_data[0:rhs_data_len] == rhs_data:
                                 #         print 'section data for %s matches the first %u bytes' % (lhs_section.sectname, lhs_data_len)
                                 #     else:
                                 #         # TODO: check padding
                                 #         result = False
                                 # else:
                                 result = False
-                                print 'error: sections differ'
+                                print('error: sections differ')
                                 # print 'a) %s' % (lhs_section)
                                 # dump_hex_byte_string_diff(0, lhs_data, rhs_data)
                                 # print 'b) %s' % (rhs_section)
                                 # dump_hex_byte_string_diff(0, rhs_data, lhs_data)
                         elif lhs_data and not rhs_data:
-                            print 'error: section data missing from b:'
-                            print 'a) %s' % (lhs_section)
-                            print 'b) %s' % (rhs_section)
+                            print('error: section data missing from b:')
+                            print('a) %s' % (lhs_section))
+                            print('b) %s' % (rhs_section))
                             result = False
                         elif not lhs_data and rhs_data:
-                            print 'error: section data missing from a:'
-                            print 'a) %s' % (lhs_section)
-                            print 'b) %s' % (rhs_section)
+                            print('error: section data missing from a:')
+                            print('a) %s' % (lhs_section))
+                            print('b) %s' % (rhs_section))
                             result = False
                         elif lhs_section.offset or rhs_section.offset:
-                            print 'error: section data missing for both a and b:'
-                            print 'a) %s' % (lhs_section)
-                            print 'b) %s' % (rhs_section)
+                            print('error: section data missing for both a and b:')
+                            print('a) %s' % (lhs_section))
+                            print('b) %s' % (rhs_section))
                             result = False
                         else:
-                            print 'ok'
+                            print('ok')
                     else:
                         result = False
-                        print 'error: section %s is missing in %s' % (lhs_section.sectname, rhs.path)
+                        print('error: section %s is missing in %s' % (lhs_section.sectname, rhs.path))
             else:
-                print 'error: comaparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type)
+                print('error: comaparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type))
                 result = False
             if not result:
-                print 'error: mach files differ'
+                print('error: mach files differ')
             return result
 
         def dump_header(self, dump_description=True, options=None):
             if options.verbose:
-                print "MAGIC      CPU        SUBTYPE    FILETYPE   NUM CMDS SIZE CMDS  FLAGS"
-                print "---------- ---------- ---------- ---------- -------- ---------- ----------"
+                print("MAGIC      CPU        SUBTYPE    FILETYPE   NUM CMDS SIZE CMDS  FLAGS")
+                print("---------- ---------- ---------- ---------- -------- ---------- ----------")
             else:
-                print "MAGIC        ARCH       FILETYPE       NUM CMDS SIZE CMDS  FLAGS"
-                print "------------ ---------- -------------- -------- ---------- ----------"
+                print("MAGIC        ARCH       FILETYPE       NUM CMDS SIZE CMDS  FLAGS")
+                print("------------ ---------- -------------- -------- ---------- ----------")
 
         def dump_flat(self, options):
             if options.verbose:
-                print "%#8.8x %#8.8x %#8.8x %#8.8x %#8u %#8.8x %#8.8x" % (self.magic, self.arch.cpu, self.arch.sub, self.filetype.value, self.ncmds, self.sizeofcmds, self.flags.bits)
+                print("%#8.8x %#8.8x %#8.8x %#8.8x %#8u %#8.8x %#8.8x" % (self.magic, self.arch.cpu, self.arch.sub, self.filetype.value, self.ncmds, self.sizeofcmds, self.flags.bits))
             else:
-                print "%-12s %-10s %-14s %#8u %#8.8x %s" % (self.magic, self.arch, self.filetype, self.ncmds, self.sizeofcmds, self.flags)
+                print("%-12s %-10s %-14s %#8u %#8.8x %s" % (self.magic, self.arch, self.filetype, self.ncmds, self.sizeofcmds, self.flags))
 
         def dump(self, options):
             if options.dump_header:
                 self.dump_header(True, options)
             if options.dump_load_commands:
                 self.dump_load_commands(False, options)
             if options.dump_sections:
                 self.dump_sections(False, options)
             if options.section_names:
                 self.dump_section_contents(options)
             if options.dump_symtab:
                 self.get_symtab()
                 if len(self.symbols):
                     self.dump_sections(False, options)
                 else:
-                    print "No symbols"
+                    print("No symbols")
             if options.find_mangled:
                 self.dump_symbol_names_matching_regex(re.compile('^_?_Z'))
 
         def dump_header(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
-            print "Mach Header"
-            print "       magic: %#8.8x %s" % (self.magic.value, self.magic)
-            print "     cputype: %#8.8x %s" % (self.arch.cpu, self.arch)
-            print "  cpusubtype: %#8.8x" % self.arch.sub
-            print "    filetype: %#8.8x %s" % (self.filetype.get_enum_value(), self.filetype.get_enum_name())
-            print "       ncmds: %#8.8x %u" % (self.ncmds, self.ncmds)
-            print "  sizeofcmds: %#8.8x" % self.sizeofcmds
-            print "       flags: %#8.8x %s" % (self.flags.bits, self.flags)
+                print(self.description())
+            print("Mach Header")
+            print("       magic: %#8.8x %s" % (self.magic.value, self.magic))
+            print("     cputype: %#8.8x %s" % (self.arch.cpu, self.arch))
+            print("  cpusubtype: %#8.8x" % self.arch.sub)
+            print("    filetype: %#8.8x %s" % (self.filetype.get_enum_value(), self.filetype.get_enum_name()))
+            print("       ncmds: %#8.8x %u" % (self.ncmds, self.ncmds))
+            print("  sizeofcmds: %#8.8x" % self.sizeofcmds)
+            print("       flags: %#8.8x %s" % (self.flags.bits, self.flags))
 
         def dump_load_commands(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             for lc in self.commands:
-                print lc
+                print(lc)
 
         def get_section_by_name(self, name):
             for section in self.sections:
                 if section.sectname and section.sectname == name:
                     return section
             return None
 
         def get_section_by_section(self, other_section):
             for section in self.sections:
                 if section.sectname == other_section.sectname and section.segname == other_section.segname:
                     return section
             return None
 
         def dump_sections(self, dump_description=True, options=None):
             if dump_description:
-                print self.description()
+                print(self.description())
             num_sections = len(self.sections)
             if num_sections > 1:
                 self.sections[1].dump_header()
                 for sect_idx in range(1, num_sections):
-                    print "%s" % self.sections[sect_idx]
+                    print("%s" % self.sections[sect_idx])
 
         def dump_section_contents(self, options):
             saved_section_to_disk = False
             for sectname in options.section_names:
                 section = self.get_section_by_name(sectname)
                 if section:
                     sect_bytes = section.get_contents(self)
                     if options.outfile:
class Skinny:
                                     # data_size = %#16.16x, name_offset =
                                     # %#16.16x (%s), language = %u, flags =
                                     # %#x" % (i, data_offset, data_size,
                                     # name_offset, module_name, language,
                                     # flags)
                                     data.seek(data_offset)
                                     outfile.write(data.read_size(data_size))
                             else:
-                                print "Saving section %s to '%s'" % (sectname, options.outfile)
+                                print("Saving section %s to '%s'" % (sectname, options.outfile))
                                 outfile.write(sect_bytes)
                             outfile.close()
                             saved_section_to_disk = True
                         else:
-                            print "error: you can only save a single section to disk at a time, skipping section '%s'" % (sectname)
+                            print("error: you can only save a single section to disk at a time, skipping section '%s'" % (sectname))
                     else:
-                        print 'section %s:\n' % (sectname)
+                        print('section %s:\n' % (sectname))
                         section.dump_header()
-                        print '%s\n' % (section)
+                        print('%s\n' % (section))
                         dump_memory(0, sect_bytes, options.max_count, 16)
                 else:
-                    print 'error: no section named "%s" was found' % (sectname)
+                    print('error: no section named "%s" was found' % (sectname))
 
         def get_segment(self, segname):
             if len(self.segments) == 1 and self.segments[0].segname == '':
                 return self.segments[0]
             for segment in self.segments:
                 if segment.segname == segname:
                     return segment
             return None
class Skinny:
 
                     self.data.seek(symtab_offset)
                     is_64 = self.is_64_bit()
                     for i in range(lc_symtab.nsyms):
                         nlist = Mach.NList()
                         nlist.unpack(self, self.data, lc_symtab)
                         self.symbols.append(nlist)
                 else:
-                    print "no LC_SYMTAB"
+                    print("no LC_SYMTAB")
 
         def dump_symtab(self, dump_description=True, options=None):
             self.get_symtab()
             if dump_description:
-                print self.description()
+                print(self.description())
             for i, symbol in enumerate(self.symbols):
-                print '[%5u] %s' % (i, symbol)
+                print('[%5u] %s' % (i, symbol))
 
         def dump_symbol_names_matching_regex(self, regex, file=None):
             self.get_symtab()
             for symbol in self.symbols:
                 if symbol.name and regex.search(symbol.name):
-                    print symbol.name
+                    print(symbol.name)
                     if file:
                         file.write('%s\n' % (symbol.name))
 
         def is_64_bit(self):
             return self.magic.is_64_bit()
 
     class LoadCommand:
 
class Section:
                     8)
             else:
                 self.addr, self.size = data.get_n_uint32(2)
                 self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2 = data.get_n_uint32(
                     7)
 
         def dump_header(self):
             if self.is_64:
-                print "INDEX ADDRESS            SIZE               OFFSET     ALIGN      RELOFF     NRELOC     FLAGS      RESERVED1  RESERVED2  RESERVED3  NAME"
-                print "===== ------------------ ------------------ ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------------------"
+                print("INDEX ADDRESS            SIZE               OFFSET     ALIGN      RELOFF     NRELOC     FLAGS      RESERVED1  RESERVED2  RESERVED3  NAME")
+                print("===== ------------------ ------------------ ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------------------")
             else:
-                print "INDEX ADDRESS    SIZE       OFFSET     ALIGN      RELOFF     NRELOC     FLAGS      RESERVED1  RESERVED2  NAME"
-                print "===== ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------------------"
+                print("INDEX ADDRESS    SIZE       OFFSET     ALIGN      RELOFF     NRELOC     FLAGS      RESERVED1  RESERVED2  NAME")
+                print("===== ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------------------")
 
         def __str__(self):
             if self.is_64:
                 return "[%3u] %#16.16x %#16.16x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %s.%s" % (
                     self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2, self.reserved3, self.segname, self.sectname)
             else:
                 return "[%3u] %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %#8.8x %s.%s" % (
                     self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2, self.segname, self.sectname)
class Interactive(cmd.Cmd):
             cmd.Cmd.__init__(self)
             self.intro = 'Interactive mach-o command interpreter'
             self.prompt = 'mach-o: %s %% ' % mach.path
             self.mach = mach
             self.options = options
 
         def default(self, line):
             '''Catch all for unknown command, which will exit the interpreter.'''
-            print "uknown command: %s" % line
+            print("uknown command: %s" % line)
             return True
 
         def do_q(self, line):
             '''Quit command'''
             return True
 
         def do_quit(self, line):
             '''Quit command'''
parser.add_option(
         type='int',
         dest='max_count',
         help='Sets the max byte count when dumping section data',
         default=-1)
 
     (options, mach_files) = parser.parse_args()
     if options.extract_modules:
         if options.section_names:
-            print "error: can't use --section option with the --extract-modules option"
+            print("error: can't use --section option with the --extract-modules option")
             exit(1)
         if not options.outfile:
-            print "error: the --output=FILE option must be specified with the --extract-modules option"
+            print("error: the --output=FILE option must be specified with the --extract-modules option")
             exit(1)
         options.section_names.append("__apple_ast")
     if options.compare:
         if len(mach_files) == 2:
             mach_a = Mach()
             mach_b = Mach()
             mach_a.parse(mach_files[0])
             mach_b.parse(mach_files[1])
             mach_a.compare(mach_b)
         else:
-            print 'error: --compare takes two mach files as arguments'
+            print('error: --compare takes two mach files as arguments')
     else:
         if not (options.dump_header or options.dump_load_commands or options.dump_symtab or options.dump_sections or options.find_mangled or options.section_names):
             options.dump_header = True
             options.dump_load_commands = True
         if options.verbose:
-            print 'options', options
-            print 'mach_files', mach_files
+            print('options', options)
+            print('mach_files', mach_files)
         for path in mach_files:
             mach = Mach()
             mach.parse(path)
             if options.interactive:
                 interpreter = Mach.Interactive(mach, options)
                 interpreter.cmdloop()
             else:
                 mach.dump(options)

examples/python/memory.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 #----------------------------------------------------------------------
 
 import commands
+from __future__ import print_function
+
 import platform
 import os
 import re
 import sys
 
 try:
     # Just try for LLDB in case PYTHONPATH is already correctly setup
     import lldb
for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
                 try:
                     import lldb
                 except ImportError:
                     pass
                 else:
-                    print 'imported lldb from: "%s"' % (lldb_python_dir)
+                    print('imported lldb from: "%s"' % (lldb_python_dir))
                     success = True
                     break
     if not success:
-        print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
+        print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly")
         sys.exit(1)
 
 import commands
 import optparse
 import shlex
 import string
 import struct
 import time
def memfind_command(debugger, command, result, dict):
     #     # (courtesy of OptParse dealing with argument errors by throwing SystemExit)
     #     result.SetStatus (lldb.eReturnStatusFailed)
     #     print >>result, "error: option parsing failed" # returning a string is the same as returning an error whose description is the string
     #     return
     memfind(debugger.GetSelectedTarget(), options, args, result)
 
 
 def print_error(str, show_usage, result):
-    print >>result, str
+    print(str, file=result)
     if show_usage:
-        print >>result, create_memfind_options().format_help()
+        print(create_memfind_options().format_help(), file=result)
 
 
 def memfind(target, options, args, result):
     num_args = len(args)
     start_addr = 0
     if num_args == 1:
         if options.size > 0:
             print_error(
elif num_args == 2:
                 (start_addr, end_addr), True, result)
             return
         options.size = end_addr - start_addr
     else:
         print_error("error: memfind takes 1 or 2 arguments", True, result)
         return
 
     if not options.data:
-        print >>result, 'error: no data specified to search for'
+        print('error: no data specified to search for', file=result)
         return
 
     if not target:
-        print >>result, 'error: invalid target'
+        print('error: invalid target', file=result)
         return
     process = target.process
     if not process:
-        print >>result, 'error: invalid process'
+        print('error: invalid process', file=result)
         return
 
     error = lldb.SBError()
     bytes = process.ReadMemory(start_addr, options.size, error)
     if error.Success():
         num_matches = 0
-        print >>result, "Searching memory range [%#x - %#x) for" % (
-            start_addr, end_addr),
+        print("Searching memory range [%#x - %#x) for" % (
+            start_addr, end_addr), end=' ', file=result)
         for byte in options.data:
-            print >>result, '%2.2x' % ord(byte),
-        print >>result
+            print('%2.2x' % ord(byte), end=' ', file=result)
+        print(file=result)
 
         match_index = string.find(bytes, options.data)
         while match_index != -1:
             num_matches = num_matches + 1
-            print >>result, '%#x: %#x + %u' % (start_addr +
-                                               match_index, start_addr, match_index)
+            print('%#x: %#x + %u' % (start_addr +
+                                               match_index, start_addr, match_index), file=result)
             match_index = string.find(bytes, options.data, match_index + 1)
 
         if num_matches == 0:
-            print >>result, "error: no matches found"
+            print("error: no matches found", file=result)
     else:
-        print >>result, 'error: %s' % (error.GetCString())
+        print('error: %s' % (error.GetCString()), file=result)
 
 
 if __name__ == '__main__':
-    print 'error: this script is designed to be used within the embedded script interpreter in LLDB'
+    print('error: this script is designed to be used within the embedded script interpreter in LLDB')
 elif getattr(lldb, 'debugger', None):
     memfind_command.__doc__ = create_memfind_options().format_help()
     lldb.debugger.HandleCommand(
         'command script add -f memory.memfind_command memfind')
-    print '"memfind" command installed, use the "--help" option for detailed help'
+    print('"memfind" command installed, use the "--help" option for detailed help')

examples/python/performance.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------
 
 import commands
+from __future__ import print_function
+
 import optparse
 import os
 import platform
 import re
 import resource
 import sys
 import time
 import types
for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
                 try:
                     import lldb
                 except ImportError:
                     pass
                 else:
-                    print 'imported lldb from: "%s"' % (lldb_python_dir)
+                    print('imported lldb from: "%s"' % (lldb_python_dir))
                     success = True
                     break
     if not success:
-        print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
+        print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly")
         sys.exit(1)
 
 
 class Timer:
 
     def __enter__(self):
         self.start = time.clock()
         return self
class TestCase:
     def Run(self, args):
         assert False, "performance.TestCase.Run(self, args) must be subclassed"
 
     def Launch(self):
         if self.target:
             error = lldb.SBError()
             self.process = self.target.Launch(self.launch_info, error)
             if not error.Success():
-                print "error: %s" % error.GetCString()
+                print("error: %s" % error.GetCString())
             if self.process:
                 self.process.GetBroadcaster().AddListener(self.listener,
                                                           lldb.SBProcess.eBroadcastBitStateChanged | lldb.SBProcess.eBroadcastBitInterrupt)
                 return True
         return False
 
     def WaitForNextProcessEvent(self):
         event = None
         if self.process:
             while event is None:
                 process_event = lldb.SBEvent()
                 if self.listener.WaitForEvent(lldb.UINT32_MAX, process_event):
                     state = lldb.SBProcess.GetStateFromEvent(process_event)
                     if self.verbose:
-                        print "event = %s" % (lldb.SBDebugger.StateAsCString(state))
+                        print("event = %s" % (lldb.SBDebugger.StateAsCString(state)))
                     if lldb.SBProcess.GetRestartedFromEvent(process_event):
                         continue
                     if state == lldb.eStateInvalid or state == lldb.eStateDetached or state == lldb.eStateCrashed or state == lldb.eStateUnloaded or state == lldb.eStateExited:
                         event = process_event
                         self.done = True
                     elif state == lldb.eStateConnected or state == lldb.eStateAttaching or state == lldb.eStateLaunching or state == lldb.eStateRunning or state == lldb.eStateStepping or state == lldb.eStateSuspended:
                         continue
                     elif state == lldb.eStateStopped:
                         event = process_event
                         call_test_step = True
                         fatal = False
                         selected_thread = False
                         for thread in self.process:
                             frame = thread.GetFrameAtIndex(0)
                             select_thread = False
 
                             stop_reason = thread.GetStopReason()
                             if self.verbose:
-                                print "tid = %#x pc = %#x " % (thread.GetThreadID(), frame.GetPC()),
+                                print("tid = %#x pc = %#x " % (thread.GetThreadID(), frame.GetPC()), end=' ')
                             if stop_reason == lldb.eStopReasonNone:
                                 if self.verbose:
-                                    print "none"
+                                    print("none")
                             elif stop_reason == lldb.eStopReasonTrace:
                                 select_thread = True
                                 if self.verbose:
-                                    print "trace"
+                                    print("trace")
                             elif stop_reason == lldb.eStopReasonPlanComplete:
                                 select_thread = True
                                 if self.verbose:
-                                    print "plan complete"
+                                    print("plan complete")
                             elif stop_reason == lldb.eStopReasonThreadExiting:
                                 if self.verbose:
-                                    print "thread exiting"
+                                    print("thread exiting")
                             elif stop_reason == lldb.eStopReasonExec:
                                 if self.verbose:
-                                    print "exec"
+                                    print("exec")
                             elif stop_reason == lldb.eStopReasonInvalid:
                                 if self.verbose:
-                                    print "invalid"
+                                    print("invalid")
                             elif stop_reason == lldb.eStopReasonException:
                                 select_thread = True
                                 if self.verbose:
-                                    print "exception"
+                                    print("exception")
                                 fatal = True
                             elif stop_reason == lldb.eStopReasonBreakpoint:
                                 select_thread = True
                                 bp_id = thread.GetStopReasonDataAtIndex(0)
                                 bp_loc_id = thread.GetStopReasonDataAtIndex(1)
                                 if self.verbose:
-                                    print "breakpoint id = %d.%d" % (bp_id, bp_loc_id)
+                                    print("breakpoint id = %d.%d" % (bp_id, bp_loc_id))
                             elif stop_reason == lldb.eStopReasonWatchpoint:
                                 select_thread = True
                                 if self.verbose:
-                                    print "watchpoint id = %d" % (thread.GetStopReasonDataAtIndex(0))
+                                    print("watchpoint id = %d" % (thread.GetStopReasonDataAtIndex(0)))
                             elif stop_reason == lldb.eStopReasonSignal:
                                 select_thread = True
                                 if self.verbose:
-                                    print "signal %d" % (thread.GetStopReasonDataAtIndex(0))
+                                    print("signal %d" % (thread.GetStopReasonDataAtIndex(0)))
 
                             if select_thread and not selected_thread:
                                 self.thread = thread
                                 selected_thread = self.process.SetSelectedThread(
                                     thread)
 
                             for action in self.user_actions:
                                 action.ThreadStopped(thread)
class TesterTestCase(TestCase):
     def __init__(self):
         TestCase.__init__(self)
         self.verbose = True
         self.num_steps = 5
 
     def BreakpointHit(self, thread):
         bp_id = thread.GetStopReasonDataAtIndex(0)
         loc_id = thread.GetStopReasonDataAtIndex(1)
-        print "Breakpoint %i.%i hit: %s" % (bp_id, loc_id, thread.process.target.FindBreakpointByID(bp_id))
+        print("Breakpoint %i.%i hit: %s" % (bp_id, loc_id, thread.process.target.FindBreakpointByID(bp_id)))
         thread.StepOver()
 
     def PlanComplete(self, thread):
         if self.num_steps > 0:
             thread.StepOver()
             self.num_steps = self.num_steps - 1
         else:
             thread.process.Kill()
def Run(self, args):
                     PlanCompleteAction(
                         callback=TesterTestCase.PlanComplete,
                         callback_owner=self))
 
                 if self.Launch():
                     while not self.done:
                         self.WaitForNextProcessEvent()
                 else:
-                    print "error: failed to launch process"
+                    print("error: failed to launch process")
             else:
-                print "error: failed to create target with '%s'" % (args[0])
+                print("error: failed to create target with '%s'" % (args[0]))
         print('Total time = %.03f sec.' % total_time.interval)
 
 
 if __name__ == '__main__':
     lldb.SBDebugger.Initialize()
     test = TesterTestCase()
     test.Run(sys.argv[1:])
     mem = MemoryMeasurement(os.getpid())
     mem.Measure()
-    print str(mem)
+    print(str(mem))
     lldb.SBDebugger.Terminate()
     # print "sleeeping for 100 seconds"
     # time.sleep(100)

examples/python/process_events.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------
 
 import commands
+from __future__ import print_function
+
 import optparse
 import os
 import platform
 import sys
 
 #----------------------------------------------------------------------
 # Code that auto imports LLDB
 #----------------------------------------------------------------------
for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
                 try:
                     import lldb
                 except ImportError:
                     pass
                 else:
-                    print 'imported lldb from: "%s"' % (lldb_python_dir)
+                    print('imported lldb from: "%s"' % (lldb_python_dir))
                     success = True
                     break
     if not success:
-        print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
+        print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly")
         sys.exit(1)
 
 
 def print_threads(process, options):
     if options.show_threads:
         for thread in process:
-            print '%s %s' % (thread, thread.GetFrameAtIndex(0))
+            print('%s %s' % (thread, thread.GetFrameAtIndex(0)))
 
 
 def run_commands(command_interpreter, commands):
     return_obj = lldb.SBCommandReturnObject()
     for command in commands:
         command_interpreter.HandleCommand(command, return_obj)
         if return_obj.Succeeded():
-            print return_obj.GetOutput()
+            print(return_obj.GetOutput())
         else:
-            print return_obj
+            print(return_obj)
             if options.stop_on_error:
                 break
 
 
 def main(argv):
     description = '''Debugs a program using the LLDB python API and uses asynchronous broadcast events to watch for process state changes.'''
     epilog = '''Examples:
 
if args:
         if options.env_vars:
             launch_info.SetEnvironmentEntries(options.env_vars, True)
         if options.working_dir:
             launch_info.SetWorkingDirectory(options.working_dir)
     elif options.attach_pid != -1:
         if options.run_count == 1:
             attach_info = lldb.SBAttachInfo(options.attach_pid)
         else:
-            print "error: --run-count can't be used with the --attach-pid option"
+            print("error: --run-count can't be used with the --attach-pid option")
             sys.exit(1)
     elif not options.attach_name is None:
         if options.run_count == 1:
             attach_info = lldb.SBAttachInfo(
                 options.attach_name, options.attach_wait)
         else:
-            print "error: --run-count can't be used with the --attach-name option"
+            print("error: --run-count can't be used with the --attach-name option")
             sys.exit(1)
     else:
-        print 'error: a program path for a program to debug and its arguments are required'
+        print('error: a program path for a program to debug and its arguments are required')
         sys.exit(1)
 
     # Create a new debugger instance
     debugger = lldb.SBDebugger.Create()
     debugger.SetAsync(True)
     command_interpreter = debugger.GetCommandInterpreter()
     # Create a target from a file and arch
 
     if exe:
-        print "Creating a target for '%s'" % exe
+        print("Creating a target for '%s'" % exe)
     error = lldb.SBError()
     target = debugger.CreateTarget(
         exe, options.arch, options.platform, True, error)
 
     if target:
 
         # Set any breakpoints that were specified in the args if we are launching. We use the
         # command line command to take advantage of the shorthand breakpoint
         # creation
         if launch_info and options.breakpoints:
             for bp in options.breakpoints:
                 debugger.HandleCommand("_regexp-break %s" % (bp))
             run_commands(command_interpreter, ['breakpoint list'])
 
         for run_idx in range(options.run_count):
             # Launch the process. Since we specified synchronous mode, we won't return
             # from this function until we hit the breakpoint at main
             error = lldb.SBError()
 
             if launch_info:
                 if options.run_count == 1:
-                    print 'Launching "%s"...' % (exe)
+                    print('Launching "%s"...' % (exe))
                 else:
-                    print 'Launching "%s"... (launch %u of %u)' % (exe, run_idx + 1, options.run_count)
+                    print('Launching "%s"... (launch %u of %u)' % (exe, run_idx + 1, options.run_count))
 
                 process = target.Launch(launch_info, error)
             else:
                 if options.attach_pid != -1:
-                    print 'Attaching to process %i...' % (options.attach_pid)
+                    print('Attaching to process %i...' % (options.attach_pid))
                 else:
                     if options.attach_wait:
-                        print 'Waiting for next to process named "%s" to launch...' % (options.attach_name)
+                        print('Waiting for next to process named "%s" to launch...' % (options.attach_name))
                     else:
-                        print 'Attaching to existing process named "%s"...' % (options.attach_name)
+                        print('Attaching to existing process named "%s"...' % (options.attach_name))
                 process = target.Attach(attach_info, error)
 
             # Make sure the launch went ok
             if process and process.GetProcessID() != lldb.LLDB_INVALID_PROCESS_ID:
 
                 pid = process.GetProcessID()
-                print 'Process is %i' % (pid)
+                print('Process is %i' % (pid))
                 if attach_info:
                     # continue process if we attached as we won't get an
                     # initial event
                     process.Continue()
 
                 listener = debugger.GetListener()
                 # sign up for process state change events
                 stop_idx = 0
                 done = False
                 while not done:
                     event = lldb.SBEvent()
                     if listener.WaitForEvent(options.event_timeout, event):
                         if lldb.SBProcess.EventIsProcessEvent(event):
                             state = lldb.SBProcess.GetStateFromEvent(event)
                             if state == lldb.eStateInvalid:
                                 # Not a state event
-                                print 'process event = %s' % (event)
+                                print('process event = %s' % (event))
                             else:
-                                print "process state changed event: %s" % (lldb.SBDebugger.StateAsCString(state))
+                                print("process state changed event: %s" % (lldb.SBDebugger.StateAsCString(state)))
                                 if state == lldb.eStateStopped:
                                     if stop_idx == 0:
                                         if launch_info:
-                                            print "process %u launched" % (pid)
+                                            print("process %u launched" % (pid))
                                             run_commands(
                                                 command_interpreter, ['breakpoint list'])
                                         else:
-                                            print "attached to process %u" % (pid)
+                                            print("attached to process %u" % (pid))
                                             for m in target.modules:
-                                                print m
+                                                print(m)
                                             if options.breakpoints:
                                                 for bp in options.breakpoints:
                                                     debugger.HandleCommand(
                                                         "_regexp-break %s" % (bp))
                                                 run_commands(
                                                     command_interpreter, ['breakpoint list'])
                                         run_commands(
                                             command_interpreter, options.launch_commands)
                                     else:
                                         if options.verbose:
-                                            print "process %u stopped" % (pid)
+                                            print("process %u stopped" % (pid))
                                         run_commands(
                                             command_interpreter, options.stop_commands)
                                     stop_idx += 1
                                     print_threads(process, options)
-                                    print "continuing process %u" % (pid)
+                                    print("continuing process %u" % (pid))
                                     process.Continue()
                                 elif state == lldb.eStateExited:
                                     exit_desc = process.GetExitDescription()
                                     if exit_desc:
-                                        print "process %u exited with status %u: %s" % (pid, process.GetExitStatus(), exit_desc)
+                                        print("process %u exited with status %u: %s" % (pid, process.GetExitStatus(), exit_desc))
                                     else:
-                                        print "process %u exited with status %u" % (pid, process.GetExitStatus())
+                                        print("process %u exited with status %u" % (pid, process.GetExitStatus()))
                                     run_commands(
                                         command_interpreter, options.exit_commands)
                                     done = True
                                 elif state == lldb.eStateCrashed:
-                                    print "process %u crashed" % (pid)
+                                    print("process %u crashed" % (pid))
                                     print_threads(process, options)
                                     run_commands(
                                         command_interpreter, options.crash_commands)
                                     done = True
                                 elif state == lldb.eStateDetached:
-                                    print "process %u detached" % (pid)
+                                    print("process %u detached" % (pid))
                                     done = True
                                 elif state == lldb.eStateRunning:
                                     # process is running, don't say anything,
                                     # we will always get one of these after
                                     # resuming
                                     if options.verbose:
-                                        print "process %u resumed" % (pid)
+                                        print("process %u resumed" % (pid))
                                 elif state == lldb.eStateUnloaded:
-                                    print "process %u unloaded, this shouldn't happen" % (pid)
+                                    print("process %u unloaded, this shouldn't happen" % (pid))
                                     done = True
                                 elif state == lldb.eStateConnected:
-                                    print "process connected"
+                                    print("process connected")
                                 elif state == lldb.eStateAttaching:
-                                    print "process attaching"
+                                    print("process attaching")
                                 elif state == lldb.eStateLaunching:
-                                    print "process launching"
+                                    print("process launching")
                         else:
-                            print 'event = %s' % (event)
+                            print('event = %s' % (event))
                     else:
                         # timeout waiting for an event
-                        print "no process event for %u seconds, killing the process..." % (options.event_timeout)
+                        print("no process event for %u seconds, killing the process..." % (options.event_timeout))
                         done = True
                 # Now that we are done dump the stdout and stderr
                 process_stdout = process.GetSTDOUT(1024)
                 if process_stdout:
-                    print "Process STDOUT:\n%s" % (process_stdout)
+                    print("Process STDOUT:\n%s" % (process_stdout))
                     while process_stdout:
                         process_stdout = process.GetSTDOUT(1024)
-                        print process_stdout
+                        print(process_stdout)
                 process_stderr = process.GetSTDERR(1024)
                 if process_stderr:
-                    print "Process STDERR:\n%s" % (process_stderr)
+                    print("Process STDERR:\n%s" % (process_stderr))
                     while process_stderr:
                         process_stderr = process.GetSTDERR(1024)
-                        print process_stderr
+                        print(process_stderr)
                 process.Kill()  # kill the process
             else:
                 if error:
-                    print error
+                    print(error)
                 else:
                     if launch_info:
-                        print 'error: launch failed'
+                        print('error: launch failed')
                     else:
-                        print 'error: attach failed'
+                        print('error: attach failed')
 
     lldb.SBDebugger.Terminate()
 
 if __name__ == '__main__':
     main(sys.argv[1:])

examples/python/pytracer.py

+from __future__ import print_function
 import sys
 import inspect
 from collections import OrderedDict
 
 
 class TracebackFancy:
 
     def __init__(self, traceback):

 
 def disable():
     sys.settrace(None)
 
 
 class LoggingTracer:
 
     def callEvent(self, frame):
-        print "call " + frame.getName() + " from " + frame.getCaller().getName() + " @ " + str(frame.getCaller().getLineNumber()) + " args are " + str(frame.getArgumentInfo())
+        print("call " + frame.getName() + " from " + frame.getCaller().getName() + " @ " + str(frame.getCaller().getLineNumber()) + " args are " + str(frame.getArgumentInfo()))
 
     def lineEvent(self, frame):
-        print "running " + frame.getName() + " @ " + str(frame.getLineNumber()) + " locals are " + str(frame.getLocals()) + " in " + frame.getFileName()
+        print("running " + frame.getName() + " @ " + str(frame.getLineNumber()) + " locals are " + str(frame.getLocals()) + " in " + frame.getFileName())
 
     def returnEvent(self, frame, retval):
-        print "return from " + frame.getName() + " value is " + str(retval) + " locals are " + str(frame.getLocals())
+        print("return from " + frame.getName() + " value is " + str(retval) + " locals are " + str(frame.getLocals()))
 
     def exceptionEvent(self, frame, exception):
-        print "exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber())
-        print "tb: " + str(exception.getTraceback())
+        print("exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber()))
+        print("tb: " + str(exception.getTraceback()))
 
 # the same functionality as LoggingTracer, but with a little more
 # lldb-specific smarts
 
 
 class LLDBAwareTracer:
 
     def callEvent(self, frame):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
-            print "call run_one_line(%s)" % (frame.getArgumentInfo().getArgs()["input_string"])
+            print("call run_one_line(%s)" % (frame.getArgumentInfo().getArgs()["input_string"]))
             return
         if "Python.framework" in frame.getFileName():
-            print "call into Python at " + frame.getName()
+            print("call into Python at " + frame.getName())
             return
         if frame.getName() == "__init__" and frame.getCaller().getName(
         ) == "run_one_line" and frame.getCaller().getLineNumber() == 101:
             return False
         strout = "call " + frame.getName()
         if (frame.getCaller().getFileName() == ""):
             strout += " from LLDB - args are "
             args = frame.getArgumentInfo().getArgs()
             for arg in args:
                 if arg == "dict" or arg == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (arg, args[arg]))
         else:
             strout += " from " + frame.getCaller().getName() + " @ " + \
                 str(frame.getCaller().getLineNumber()) + " args are " + str(frame.getArgumentInfo())
-        print strout
+        print(strout)
 
     def lineEvent(self, frame):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
-            print "running run_one_line(%s) @ %s" % (frame.getArgumentInfo().getArgs()["input_string"], frame.getLineNumber())
+            print("running run_one_line(%s) @ %s" % (frame.getArgumentInfo().getArgs()["input_string"], frame.getLineNumber()))
             return
         if "Python.framework" in frame.getFileName():
-            print "running into Python at " + frame.getName() + " @ " + str(frame.getLineNumber())
+            print("running into Python at " + frame.getName() + " @ " + str(frame.getLineNumber()))
             return
         strout = "running " + frame.getName() + " @ " + str(frame.getLineNumber()) + \
             " locals are "
         if (frame.getCaller().getFileName() == ""):
             locals = frame.getLocals()
             for local in locals:
                 if local == "dict" or local == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (local, locals[local]))
         else:
             strout = strout + str(frame.getLocals())
         strout = strout + " in " + frame.getFileName()
-        print strout
+        print(strout)
 
     def returnEvent(self, frame, retval):
         if frame.getName() == "<module>":
             return
         if frame.getName() == "run_one_line":
-            print "return from run_one_line(%s) return value is %s" % (frame.getArgumentInfo().getArgs()["input_string"], retval)
+            print("return from run_one_line(%s) return value is %s" % (frame.getArgumentInfo().getArgs()["input_string"], retval))
             return
         if "Python.framework" in frame.getFileName():
-            print "return from Python at " + frame.getName() + " return value is " + str(retval)
+            print("return from Python at " + frame.getName() + " return value is " + str(retval))
             return
         strout = "return from " + frame.getName() + " return value is " + \
             str(retval) + " locals are "
         if (frame.getCaller().getFileName() == ""):
             locals = frame.getLocals()
             for local in locals:
                 if local == "dict" or local == "internal_dict":
                     continue
                 strout = strout + ("%s = %s " % (local, locals[local]))
         else:
             strout = strout + str(frame.getLocals())
         strout = strout + " in " + frame.getFileName()
-        print strout
+        print(strout)
 
     def exceptionEvent(self, frame, exception):
         if frame.getName() == "<module>":
             return
-        print "exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber())
-        print "tb: " + str(exception.getTraceback())
+        print("exception %s %s raised from %s @ %s" % (exception.getType(), str(exception.getValue()), frame.getName(), frame.getLineNumber()))
+        print("tb: " + str(exception.getTraceback()))
 
 
 def f(x, y=None):
     if x > 0:
         return 2 + f(x - 2)
     return 35
 
 
 def g(x):
     return 1.134 / x
 
 
 def print_keyword_args(**kwargs):
     # kwargs is a dict of the keyword args passed to the function
     for key, value in kwargs.items():
-        print "%s = %s" % (key, value)
+        print("%s = %s" % (key, value))
 
 
 def total(initial=5, *numbers, **keywords):
     count = initial
     for number in numbers:
         count += number
     for key in keywords:
         count += keywords[key]

examples/python/scripted_step.py

 # To use these stepping modes, you would do:
 #
 #     (lldb) command script import scripted_step.py
 #     (lldb) thread step-scripted -C scripted_step.SimpleStep
 # or
 #
 #     (lldb) thread step-scripted -C scripted_step.StepWithPlan
 
+from __future__ import print_function
+
 import lldb
 
 
 class SimpleStep:
 
     def __init__(self, thread_plan, dict):
         self.thread_plan = thread_plan
         self.start_address = thread_plan.GetThread().GetFrameAtIndex(0).GetPC()
def should_stop(self, event):
             self.thread_plan.SetPlanComplete(True)
             return True
 
         # This part checks the condition.  In this case we are expecting
         # some integer variable called "a", and will stop when it is 20.
         a_var = frame.FindVariable("a")
 
         if not a_var.IsValid():
-            print "A was not valid."
+            print("A was not valid.")
             return True
 
         error = lldb.SBError()
         a_value = a_var.GetValueAsSigned(error)
         if not error.Success():
-            print "A value was not good."
+            print("A value was not good.")
             return True
 
         if a_value == 20:
             self.thread_plan.SetPlanComplete(True)
             return True
         else:
             self.queue_next_plan()
             return False
def should_stop(self, event):
             self.do_print()
             self.thread_plan.SetPlanComplete(True)
         return False
 
     def do_print(self):
         frame_0 = self.thread.frames[0]
         rax_value = frame_0.FindRegister("rax")
         if rax_value.GetError().Success():
-            print "RAX on exit: ", rax_value.GetValue()
+            print("RAX on exit: ", rax_value.GetValue())
         else:
-            print "Couldn't get rax value:", rax_value.GetError().GetCString()
+            print("Couldn't get rax value:", rax_value.GetError().GetCString())

examples/python/shadow.py

 #!/usr/bin/python
+from __future__ import print_function
 
 import lldb
 import shlex
 
 
 @lldb.command("shadow")
 def check_shadow_command(debugger, command, exe_ctx, result, dict):
     '''Check the currently selected stack frame for shadowed variables'''
     process = exe_ctx.GetProcess()
     state = process.GetState()
     if state != lldb.eStateStopped:
-        print >>result, "process must be stopped, state is %s" % lldb.SBDebugger.StateAsCString(
-            state)
+        print("process must be stopped, state is %s" % lldb.SBDebugger.StateAsCString(
+            state), file=result)
         return
     frame = exe_ctx.GetFrame()
     if not frame:
-        print >>result, "invalid frame"
+        print("invalid frame", file=result)
         return
     # Parse command line args
     command_args = shlex.split(command)
     # TODO: add support for using arguments that are passed to this command...
 
     # Make a dictionary of variable name to "SBBlock and SBValue"
     shadow_dict = {}
 
while block.IsValid():
         # Get the parent block and continue
         block = block.GetParent()
 
     num_shadowed_variables = 0
     if shadow_dict:
         for name in shadow_dict.keys():
             shadow_vars = shadow_dict[name]
             if len(shadow_vars) > 1:
-                print '"%s" is shadowed by the following declarations:' % (name)
+                print('"%s" is shadowed by the following declarations:' % (name))
                 num_shadowed_variables += 1
                 for shadow_var in shadow_vars:
-                    print >>result, str(shadow_var.GetDeclaration())
+                    print(str(shadow_var.GetDeclaration()), file=result)
     if num_shadowed_variables == 0:
-        print >>result, 'no variables are shadowed'
+        print('no variables are shadowed', file=result)

examples/python/sources.py

 #!/usr/bin/python
+from __future__ import print_function
 
 import lldb
 import shlex
 
 
 def dump_module_sources(module, result):
     if module:
-        print >> result, "Module: %s" % (module.file)
+        print("Module: %s" % (module.file), file=result)
         for compile_unit in module.compile_units:
             if compile_unit.file:
-                print >> result, "  %s" % (compile_unit.file)
+                print("  %s" % (compile_unit.file), file=result)
 
 
 def info_sources(debugger, command, result, dict):
     description = '''This command will dump all compile units in any modules that are listed as arguments, or for all modules if no arguments are supplied.'''
     module_names = shlex.split(command)
     target = debugger.GetSelectedTarget()
     if module_names:
         for module_name in module_names:
             dump_module_sources(target.module[module_name], result)
     else:
         for module in target.modules:
             dump_module_sources(module, result)
 
 
 def __lldb_init_module(debugger, dict):
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
         'command script add -f sources.info_sources info_sources')
-    print 'The "info_sources" command has been installed, type "help info_sources" or "info_sources --help" for detailed help.'
+    print('The "info_sources" command has been installed, type "help info_sources" or "info_sources --help" for detailed help.')

examples/python/stacks.py

 #!/usr/bin/python
-
+from __future__ import print_function
 import lldb
 import commands
 import optparse
 import shlex
 
 
 def stack_frames(debugger, command, result, dict):
     command_args = shlex.split(command)
except:
         return
 
     target = debugger.GetSelectedTarget()
     process = target.GetProcess()
 
     frame_info = {}
     for thread in process:
         last_frame = None
-        print "thread %u" % (thread.id)
+        print("thread %u" % (thread.id))
         for frame in thread.frames:
             if last_frame:
                 frame_size = 0
                 if frame.idx == 1:
                     if frame.fp == last_frame.fp:
                         # No frame one the first frame (might be right at the
                         # entry point)
                         first_frame_size = 0
                         frame_size = frame.fp - frame.sp
                     else:
                         # First frame that has a valid size
                         first_frame_size = last_frame.fp - last_frame.sp
-                    print "<%#7x> %s" % (first_frame_size, last_frame)
+                    print("<%#7x> %s" % (first_frame_size, last_frame))
                     if first_frame_size:
                         name = last_frame.name
                         if name not in frame_info:
                             frame_info[name] = first_frame_size
                         else:
                             frame_info[name] += first_frame_size
                 else:
                     # Second or higher frame
                     frame_size = frame.fp - last_frame.fp
-                print "<%#7x> %s" % (frame_size, frame)
+                print("<%#7x> %s" % (frame_size, frame))
                 if frame_size > 0:
                     name = frame.name
                     if name not in frame_info:
                         frame_info[name] = frame_size
                     else:
                         frame_info[name] += frame_size
             last_frame = frame
-    print frame_info
+    print(frame_info)
 
 
 lldb.debugger.HandleCommand(
     "command script add -f stacks.stack_frames stack_frames")
-print "A new command called 'stack_frames' was added, type 'stack_frames --help' for more information."
+print("A new command called 'stack_frames' was added, type 'stack_frames --help' for more information.")

examples/python/types.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 #----------------------------------------------------------------------
 
 import commands
+from __future__ import print_function
+
 import platform
 import os
 import re
 import signal
 import sys
 
 try:
     # Just try for LLDB in case PYTHONPATH is already correctly setup
for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
                 try:
                     import lldb
                 except ImportError:
                     pass
                 else:
-                    print 'imported lldb from: "%s"' % (lldb_python_dir)
+                    print('imported lldb from: "%s"' % (lldb_python_dir))
                     success = True
                     break
     if not success:
-        print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
+        print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly")
         sys.exit(1)
 
 import commands
 import optparse
 import shlex
 import time
 
 
parser.add_option(
         metavar='REGEX',
         dest='skip_type_regexes',
         help="Don't' recurse into types in the std namespace.",
         default=[])
     return parser
 
 
 def verify_type(target, options, type):
-    print type
+    print(type)
     typename = type.GetName()
     # print 'type: %s' % (typename)
     (end_offset, padding) = verify_type_recursive(
         target, options, type, None, 0, 0, 0)
     byte_size = type.GetByteSize()
     # if end_offset < byte_size:
     #     last_member_padding = byte_size - end_offset
     #     print '%+4u <%u> padding' % (end_offset, last_member_padding)
     #     padding += last_member_padding
-    print 'Total byte size: %u' % (byte_size)
-    print 'Total pad bytes: %u' % (padding)
+    print('Total byte size: %u' % (byte_size))
+    print('Total pad bytes: %u' % (padding))
     if padding > 0:
-        print 'Padding percentage: %2.2f %%' % ((float(padding) / float(byte_size)) * 100.0)
-    print
+        print('Padding percentage: %2.2f %%' % ((float(padding) / float(byte_size)) * 100.0))
+    print()
 
 
 def verify_type_recursive(
         target,
         options,
         type,
         member_name,
         depth,
         base_offset,
         padding):
     prev_end_offset = base_offset
     typename = type.GetName()
     byte_size = type.GetByteSize()
     if member_name and member_name != typename:
-        print '%+4u <%3u> %s%s %s;' % (base_offset, byte_size, '    ' * depth, typename, member_name)
+        print('%+4u <%3u> %s%s %s;' % (base_offset, byte_size, '    ' * depth, typename, member_name))
     else:
-        print '%+4u {%3u} %s%s' % (base_offset, byte_size, '    ' * depth, typename)
+        print('%+4u {%3u} %s%s' % (base_offset, byte_size, '    ' * depth, typename))
 
     for type_regex in options.skip_type_regexes:
         match = type_regex.match(typename)
         if match:
             return (base_offset + byte_size, padding)
 
     members = type.members
     if members:
         for member_idx, member in enumerate(members):
             member_type = member.GetType()
             member_canonical_type = member_type.GetCanonicalType()
             member_type_class = member_canonical_type.GetTypeClass()
             member_name = member.GetName()
             member_offset = member.GetOffsetInBytes()
             member_total_offset = member_offset + base_offset
             member_byte_size = member_type.GetByteSize()
             member_is_class_or_struct = False
             if member_type_class == lldb.eTypeClassStruct or member_type_class == lldb.eTypeClassClass:
                 member_is_class_or_struct = True
             if member_idx == 0 and member_offset == target.GetAddressByteSize(
             ) and type.IsPolymorphicClass():
                 ptr_size = target.GetAddressByteSize()
-                print '%+4u <%3u> %s__vtbl_ptr_type * _vptr;' % (prev_end_offset, ptr_size, '    ' * (depth + 1))
+                print('%+4u <%3u> %s__vtbl_ptr_type * _vptr;' % (prev_end_offset, ptr_size, '    ' * (depth + 1)))
                 prev_end_offset = ptr_size
             else:
                 if prev_end_offset < member_total_offset:
                     member_padding = member_total_offset - prev_end_offset
                     padding = padding + member_padding
-                    print '%+4u <%3u> %s<PADDING>' % (prev_end_offset, member_padding, '    ' * (depth + 1))
+                    print('%+4u <%3u> %s<PADDING>' % (prev_end_offset, member_padding, '    ' * (depth + 1)))
 
             if member_is_class_or_struct:
                 (prev_end_offset,
                  padding) = verify_type_recursive(target,
                                                   options,
                                                   member_canonical_type,
                                                   member_name,
                                                   depth + 1,
                                                   member_total_offset,
                                                   padding)
             else:
                 prev_end_offset = member_total_offset + member_byte_size
                 member_typename = member_type.GetName()
                 if member.IsBitfield():
-                    print '%+4u <%3u> %s%s:%u %s;' % (member_total_offset, member_byte_size, '    ' * (depth + 1), member_typename, member.GetBitfieldSizeInBits(), member_name)
+                    print('%+4u <%3u> %s%s:%u %s;' % (member_total_offset, member_byte_size, '    ' * (depth + 1), member_typename, member.GetBitfieldSizeInBits(), member_name))
                 else:
-                    print '%+4u <%3u> %s%s %s;' % (member_total_offset, member_byte_size, '    ' * (depth + 1), member_typename, member_name)
+                    print('%+4u <%3u> %s%s %s;' % (member_total_offset, member_byte_size, '    ' * (depth + 1), member_typename, member_name))
 
         if prev_end_offset < byte_size:
             last_member_padding = byte_size - prev_end_offset
-            print '%+4u <%3u> %s<PADDING>' % (prev_end_offset, last_member_padding, '    ' * (depth + 1))
+            print('%+4u <%3u> %s<PADDING>' % (prev_end_offset, last_member_padding, '    ' * (depth + 1)))
             padding += last_member_padding
     else:
         if type.IsPolymorphicClass():
             ptr_size = target.GetAddressByteSize()
-            print '%+4u <%3u> %s__vtbl_ptr_type * _vptr;' % (prev_end_offset, ptr_size, '    ' * (depth + 1))
+            print('%+4u <%3u> %s__vtbl_ptr_type * _vptr;' % (prev_end_offset, ptr_size, '    ' * (depth + 1)))
             prev_end_offset = ptr_size
         prev_end_offset = base_offset + byte_size
 
     return (prev_end_offset, padding)
 
 
 def check_padding_command(debugger, command, result, dict):
     # Use the Shell Lexer to properly parse up command options just like a

 
 @lldb.command("parse_all_struct_class_types")
 def parse_all_struct_class_types(debugger, command, result, dict):
     command_args = shlex.split(command)
     for f in command_args:
         error = lldb.SBError()
         target = debugger.CreateTarget(f, None, None, False, error)
         module = target.GetModuleAtIndex(0)
-        print "Parsing all types in '%s'" % (module)
+        print("Parsing all types in '%s'" % (module))
         types = module.GetTypes(lldb.eTypeClassClass | lldb.eTypeClassStruct)
         for t in types:
-            print t
-        print ""
+            print(t)
+        print("")
 
 
 def verify_types(target, options):
 
     if not target:
-        print 'error: invalid target'
+        print('error: invalid target')
         return
 
     modules = list()
     if len(options.modules) == 0:
         # Append just the main executable if nothing was specified
         module = target.modules[0]
         if module:
             modules.append(module)
     else:
         for module_name in options.modules:
             module = lldb.target.module[module_name]
             if module:
                 modules.append(module)
 
     if modules:
         for module in modules:
-            print 'module: %s' % (module.file)
+            print('module: %s' % (module.file))
             if options.typenames:
                 for typename in options.typenames:
                     types = module.FindTypes(typename)
                     if types.GetSize():
-                        print 'Found %u types matching "%s" in "%s"' % (len(types), typename, module.file)
+                        print('Found %u types matching "%s" in "%s"' % (len(types), typename, module.file))
                         for type in types:
                             verify_type(target, options, type)
                     else:
-                        print 'error: no type matches "%s" in "%s"' % (typename, module.file)
+                        print('error: no type matches "%s" in "%s"' % (typename, module.file))
             else:
                 types = module.GetTypes(
                     lldb.eTypeClassClass | lldb.eTypeClassStruct)
-                print 'Found %u types in "%s"' % (len(types), module.file)
+                print('Found %u types in "%s"' % (len(types), module.file))
                 for type in types:
                     verify_type(target, options, type)
     else:
-        print 'error: no modules'
+        print('error: no modules')
 
 if __name__ == '__main__':
     debugger = lldb.SBDebugger.Create()
     parser = create_types_options(False)
 
     # try:
     (options, args) = parser.parse_args(sys.argv[1:])
     # except:
     #     print "error: option parsing failed"
     #     sys.exit(1)
 
     if options.debug:
-        print "Waiting for debugger to attach to process %d" % os.getpid()
+        print("Waiting for debugger to attach to process %d" % os.getpid())
         os.kill(os.getpid(), signal.SIGSTOP)
 
     for path in args:
         # in a command - the lldb.* convenience variables are not to be used
         # and their values (if any) are undefined
         # this is the best practice to access those objects from within a
         # command
         error = lldb.SBError()
         target = debugger.CreateTarget(path,
                                        options.arch,
                                        options.platform,
                                        True,
                                        error)
         if error.Fail():
-            print error.GetCString()
+            print(error.GetCString())
             continue
         verify_types(target, options)
 
 elif getattr(lldb, 'debugger', None):
     lldb.debugger.HandleCommand(
         'command script add -f types.check_padding_command check_padding')
-    print '"check_padding" command installed, use the "--help" option for detailed help'
+    print('"check_padding" command installed, use the "--help" option for detailed help')

examples/scripting/tree_utils.py

 functions, and assume that the LLDB Python module has been
 imported.
 
 For a thorough explanation of how the DFS function works, and
 for more information about dictionary.c go to
 http://lldb.llvm.org/scripting.html
 """
 
+from __future__ import print_function
+
 
 def DFS(root, word, cur_path):
     """
     Recursively traverse a binary search tree containing
     words sorted alphabetically, searching for a particular
     word in the tree.  Also maintains a string representing
     the path from the root of the tree to the current node.
     If the word is found in the tree, return the path string.
def print_tree(root):
     This function assumes the binary search tree is
     the one defined in dictionary.c  It uses LLDB API
     functions to examine and traverse the tree nodes.
     """
     if (root.GetChildAtIndex(1).GetValue() is not None) and (
             int(root.GetChildAtIndex(1).GetValue(), 16) != 0):
         print_tree(root.GetChildAtIndex(1))
 
-    print root.GetChildAtIndex(0).GetSummary()
+    print(root.GetChildAtIndex(0).GetSummary())
 
     if (root.GetChildAtIndex(2).GetValue() is not None) and (
             int(root.GetChildAtIndex(2).GetValue(), 16) != 0):
         print_tree(root.GetChildAtIndex(2))

examples/summaries/cocoa/CFBitVector.py

 """
 LLDB AppKit formatters
 
 Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 See https://llvm.org/LICENSE.txt for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """
+from __future__ import print_function
+
 # summary provider for CF(Mutable)BitVector
 import lldb
 import ctypes
 import lldb.runtime.objc.objc_runtime
 import lldb.formatters.metrics
 import lldb.formatters.Logger
 
 # first define some utility functions
if class_data.is_cftype():
                 actual_name = valobj_type.GetName()
         if actual_name == '__CFBitVector' or actual_name == '__CFMutableBitVector':
             wrapper = CFBitVectorKnown_SummaryProvider(
                 valobj, class_data.sys_params)
             statistics.metric_hit('code_notrun', valobj)
         else:
             wrapper = CFBitVectorUnknown_SummaryProvider(
                 valobj, class_data.sys_params)
-            print actual_name
+            print(actual_name)
     else:
         wrapper = CFBitVectorUnknown_SummaryProvider(
             valobj, class_data.sys_params)
-        print name_string
+        print(name_string)
         statistics.metric_hit(
             'unknown_class',
             valobj.GetName() +
             " seen as " +
             name_string)
     return wrapper
 
 

examples/summaries/cocoa/NSNumber.py

 """
 LLDB AppKit formatters
 
 Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 See https://llvm.org/LICENSE.txt for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """
 # example summary provider for NSNumber
 # the real summary is now C++ code built into LLDB
+
+from __future__ import print_function
+
 import lldb
 import ctypes
 import lldb.runtime.objc.objc_runtime
 import lldb.formatters.metrics
 import struct
 import lldb.formatters.Logger
 
 statistics = lldb.formatters.metrics.Metrics()
def NSNumber_SummaryProvider(valobj, dict):
     if provider is not None:
         if isinstance(
                 provider,
                 lldb.runtime.objc.objc_runtime.SpecialSituation_Description):
             return provider.message()
         try:
             summary = provider.value()
         except Exception as foo:
-            print foo
+            print(foo)
 #   except:
             summary = None
         logger >> "got summary " + str(summary)
         if summary is None:
             summary = '<variable is not NSNumber>'
         return str(summary)
     return 'Summary Unavailable'
 
 
 def __lldb_init_module(debugger, dict):
     debugger.HandleCommand(
         "type summary add -F NSNumber.NSNumber_SummaryProvider NSNumber")
     debugger.HandleCommand(
         "type summary add -F NSNumber.NSNumber_SummaryProvider __NSCFBoolean")
     debugger.HandleCommand(
         "type summary add -F NSNumber.NSNumber_SummaryProvider __NSCFNumber")

scripts/Python/android/host_art_bt.py

 # Usage:
 #   art/test/run-test --host --gdb [--64] [--interpreter] 004-JniTest
 #   'b Java_Main_shortMethod'
 #   'r'
 #   'command script import host_art_bt.py'
 #   'host_art_bt'
 
+from __future__ import print_function
+
 import sys
 import re
 
 import lldb
 
 
 def host_art_bt(debugger, command, result, internal_dict):
     prettified_frames = []
     lldb_frame_index = 0
     art_frame_index = 0
     target = debugger.GetSelectedTarget()
     process = target.GetProcess()
     thread = process.GetSelectedThread()
     while lldb_frame_index < thread.GetNumFrames():
         frame = thread.GetFrameAtIndex(lldb_frame_index)
         if frame.GetModule() and re.match(r'JIT\(.*?\)',
                                           frame.GetModule().GetFileSpec().GetFilename()):
             # Compiled Java frame
 
             # Get function/filename/lineno from symbol context
             symbol = frame.GetSymbol()
             if not symbol:
-                print 'No symbol info for compiled Java frame: ', frame
+                print('No symbol info for compiled Java frame: ', frame)
                 sys.exit(1)
             line_entry = frame.GetLineEntry()
             prettified_frames.append({
                 'function': symbol.GetName(),
                 'file': str(line_entry.GetFileSpec()) if line_entry else None,
                 'line': line_entry.GetLine() if line_entry else -1
             })
 
while lldb_frame_index < thread.GetNumFrames():
                     art_method_name_data = frame.EvaluateExpression(
                         art_method_name.GetName() + """.c_str()""").GetValueAsUnsigned()
                     art_method_name_size = frame.EvaluateExpression(
                         art_method_name.GetName() + """.length()""").GetValueAsUnsigned()
                     error = lldb.SBError()
                     art_method_name = process.ReadCStringFromMemory(
                         art_method_name_data, art_method_name_size + 1, error)
                     if not error.Success:
-                        print 'Failed to read method name'
+                        print('Failed to read method name')
                         sys.exit(1)
                     if art_method_name != symbol.GetName():
-                        print 'Function names in native symbol and art runtime stack do not match: ', symbol.GetName(), ' != ', art_method_name
+                        print('Function names in native symbol and art runtime stack do not match: ', symbol.GetName(), ' != ', art_method_name)
                     art_frame_index = art_frame_index + 1
                     break
                 art_frame_index = art_frame_index + 1
 
             # Skip native frames
             lldb_frame_index = lldb_frame_index + 1
             if lldb_frame_index < thread.GetNumFrames():
                 frame = thread.GetFrameAtIndex(lldb_frame_index)
                 if frame.GetModule() and re.match(
                         r'JIT\(.*?\)', frame.GetModule().GetFileSpec().GetFilename()):
                     # Another compile Java frame
                     # Don't skip; leave it to the next iteration
                     continue
                 elif frame.GetSymbol() and (frame.GetSymbol().GetName() == 'art_quick_invoke_stub' or frame.GetSymbol().GetName() == 'art_quick_invoke_static_stub'):
                     # art_quick_invoke_stub / art_quick_invoke_static_stub
                     # Skip until we get past the next ArtMethod::Invoke()
                     while True:
                         lldb_frame_index = lldb_frame_index + 1
                         if lldb_frame_index >= thread.GetNumFrames():
-                            print 'ArtMethod::Invoke not found below art_quick_invoke_stub/art_quick_invoke_static_stub'
+                            print('ArtMethod::Invoke not found below art_quick_invoke_stub/art_quick_invoke_static_stub')
                             sys.exit(1)
                         frame = thread.GetFrameAtIndex(lldb_frame_index)
                         if frame.GetSymbol() and frame.GetSymbol().GetName(
                         ) == 'art::mirror::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)':
                             lldb_frame_index = lldb_frame_index + 1
                             break
                 else:
-                    print 'Invalid frame below compiled Java frame: ', frame
+                    print('Invalid frame below compiled Java frame: ', frame)
         elif frame.GetSymbol() and frame.GetSymbol().GetName() == 'art_quick_generic_jni_trampoline':
             # Interpreted JNI frame for x86_64
 
             # Skip art frames
             while True:
                 art_stack_visitor = frame.EvaluateExpression(
                     """struct GetStackVisitor : public StackVisitor { GetStackVisitor(int depth_) : StackVisitor(Thread::Current(), NULL), depth(depth_) {} bool VisitFrame() { if (cur_depth_ == depth) { return false; } else { return true; } } int depth; }; GetStackVisitor visitor(""" +
                     str(art_frame_index) +
while lldb_frame_index < thread.GetNumFrames():
                 frame = thread.GetFrameAtIndex(lldb_frame_index)
                 if frame.GetSymbol() and (frame.GetSymbol().GetName() ==
                                           'art_quick_invoke_stub' or frame.GetSymbol().GetName() == 'art_quick_invoke_static_stub'):
                     # art_quick_invoke_stub / art_quick_invoke_static_stub
                     # Skip until we get past the next ArtMethod::Invoke()
                     while True:
                         lldb_frame_index = lldb_frame_index + 1
                         if lldb_frame_index >= thread.GetNumFrames():
-                            print 'ArtMethod::Invoke not found below art_quick_invoke_stub/art_quick_invoke_static_stub'
+                            print('ArtMethod::Invoke not found below art_quick_invoke_stub/art_quick_invoke_static_stub')
                             sys.exit(1)
                         frame = thread.GetFrameAtIndex(lldb_frame_index)
                         if frame.GetSymbol() and frame.GetSymbol().GetName(
                         ) == 'art::mirror::ArtMethod::Invoke(art::Thread*, unsigned int*, unsigned int, art::JValue*, char const*)':
                             lldb_frame_index = lldb_frame_index + 1
                             break
                 else:
-                    print 'Invalid frame below compiled Java frame: ', frame
+                    print('Invalid frame below compiled Java frame: ', frame)
         elif frame.GetSymbol() and re.search(r'art::interpreter::', frame.GetSymbol().GetName()):
             # Interpreted Java frame
 
             while True:
                 lldb_frame_index = lldb_frame_index + 1
                 if lldb_frame_index >= thread.GetNumFrames():
-                    print 'art::interpreter::Execute not found in interpreter frame'
+                    print('art::interpreter::Execute not found in interpreter frame')
                     sys.exit(1)
                 frame = thread.GetFrameAtIndex(lldb_frame_index)
                 if frame.GetSymbol() and frame.GetSymbol().GetName(
                 ) == 'art::interpreter::Execute(art::Thread*, art::MethodHelper&, art::DexFile::CodeItem const*, art::ShadowFrame&, art::JValue)':
                     break
 
             # Skip art frames
             while True:
while lldb_frame_index < thread.GetNumFrames():
                         art_method.GetName() + """->GetDeclaringClassSourceFile()""")
                     file_name_data = file_name.GetValueAsUnsigned()
                     file_name_size = frame.EvaluateExpression(
                         """(size_t)strlen(""" + file_name.GetName() + """)""").GetValueAsUnsigned()
                     error = lldb.SBError()
                     file_name = process.ReadCStringFromMemory(
                         file_name_data, file_name_size + 1, error)
                     if not error.Success():
-                        print 'Failed to read source file name'
+                        print('Failed to read source file name')
                         sys.exit(1)
 
                     prettified_frames.append({
                         'function': function,
                         'file': file_name,
                         'line': line
                     })
 
                     art_frame_index = art_frame_index + 1
                     break
                 art_frame_index = art_frame_index + 1
 
             # Skip native frames
             while True:
                 lldb_frame_index = lldb_frame_index + 1
                 if lldb_frame_index >= thread.GetNumFrames():
-                    print 'Can not get past interpreter native frames'
+                    print('Can not get past interpreter native frames')
                     sys.exit(1)
                 frame = thread.GetFrameAtIndex(lldb_frame_index)
                 if frame.GetSymbol() and not re.search(
                         r'art::interpreter::', frame.GetSymbol().GetName()):
                     break
         else:
             # Other frames. Add them as-is.
             frame = thread.GetFrameAtIndex(lldb_frame_index)
             lldb_frame_index = lldb_frame_index + 1
             if frame.GetModule():
                 module_name = frame.GetModule().GetFileSpec().GetFilename()
                 if not module_name in [
                     'libartd.so',
                     'dalvikvm32',
                     'dalvikvm64',
                         'libc.so.6']:
                     prettified_frames.append({
                         'function': frame.GetSymbol().GetName() if frame.GetSymbol() else None,
                         'file': str(frame.GetLineEntry().GetFileSpec()) if frame.GetLineEntry() else None,
                         'line': frame.GetLineEntry().GetLine() if frame.GetLineEntry() else -1
                     })
 
     for prettified_frame in prettified_frames:
-        print prettified_frame['function'], prettified_frame['file'], prettified_frame['line']
+        print(prettified_frame['function'], prettified_frame['file'], prettified_frame['line'])
 
 
 def __lldb_init_module(debugger, internal_dict):
     debugger.HandleCommand(
         'command script add -f host_art_bt.host_art_bt host_art_bt')

scripts/Xcode/build-llvm.py

 
 def should_build_llvm():
     if build_type() == BuildType.Xcode:
         # TODO use md5 sums
         return True
 
 
 def do_symlink(source_path, link_path):
-    print "Symlinking " + source_path + " to " + link_path
+    print("Symlinking " + source_path + " to " + link_path)
     if os.path.islink(link_path):
         os.remove(link_path)
     if not os.path.exists(link_path):
         os.symlink(source_path, link_path)
 
 
 def setup_source_symlink(repo):
     source_path = repo["root"]
def cmake_flags():
     if deployment_target:
         cmake_flags.append(
             "-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target))
     return cmake_flags
 
 
 def run_cmake(cmake_build_dir, ninja_binary_path):
     cmake_binary = find_cmake()
-    print "found cmake binary: using \"{}\"".format(cmake_binary)
+    print("found cmake binary: using \"{}\"".format(cmake_binary))
 
     command_line = [cmake_binary] + cmake_flags() + [
         "-DCMAKE_MAKE_PROGRAM={}".format(ninja_binary_path),
         llvm_source_path()]
-    print "running cmake like so: ({}) in dir ({})".format(command_line, cmake_build_dir)
+    print("running cmake like so: ({}) in dir ({})".format(command_line, cmake_build_dir))
 
     subprocess.check_call(
         command_line,
         cwd=cmake_build_dir,
         env=cmake_environment())
 
 
 def create_directories_as_needed(path):

 
 
 def build_ninja_if_needed():
     # First check if ninja is in our path.  If so, there's nothing to do.
     ninja_binary_path = find_executable_in_paths(
         "ninja", os.environ["PATH"].split(os.pathsep))
     if ninja_binary_path:
         # It's on the path.  cmake will find it.  We're good.
-        print "found ninja here: \"{}\"".format(ninja_binary_path)
+        print("found ninja here: \"{}\"".format(ninja_binary_path))
         return ninja_binary_path
 
     # Figure out if we need to build it.
     ninja_build_dir = ninja_source_path()
     ninja_binary_path = os.path.join(ninja_build_dir, "ninja")
     if not is_executable(ninja_binary_path):
         # Build ninja
         command_line = ["python", "configure.py", "--bootstrap"]
-        print "building ninja like so: ({}) in dir ({})".format(command_line, ninja_build_dir)
+        print("building ninja like so: ({}) in dir ({})".format(command_line, ninja_build_dir))
         subprocess.check_call(
             command_line,
             cwd=ninja_build_dir,
             env=os.environ)
 
     return ninja_binary_path
 
 

scripts/Xcode/package-clang-resource-headers.py

 import os
 import re
 import shutil
 import sys
 
 import lldbbuild
 
 if len(sys.argv) != 3:
-    print "usage: " + sys.argv[0] + " TARGET_DIR LLVM_BUILD_DIR"
+    print("usage: " + sys.argv[0] + " TARGET_DIR LLVM_BUILD_DIR")
     sys.exit(1)
 
 target_dir = sys.argv[1]
 llvm_build_dir = lldbbuild.expected_package_build_path_for("llvm")
 
 if not os.path.isdir(target_dir):
-    print target_dir + " doesn't exist"
+    print(target_dir + " doesn't exist")
     sys.exit(1)
 
 if not os.path.isdir(llvm_build_dir):
     llvm_build_dir = re.sub("-macosx-", "-iphoneos-", llvm_build_dir)
 
 if not os.path.isdir(llvm_build_dir):
     llvm_build_dir = re.sub("-iphoneos-", "-appletvos-", llvm_build_dir)
 
 if not os.path.isdir(llvm_build_dir):
     llvm_build_dir = re.sub("-appletvos-", "-watchos-", llvm_build_dir)
 
 if not os.path.isdir(llvm_build_dir):
     llvm_build_dir = re.sub("-watchos-", "-bridgeos-", llvm_build_dir)
 
 if not os.path.isdir(llvm_build_dir):
-    print llvm_build_dir + " doesn't exist"
+    print(llvm_build_dir + " doesn't exist")
     sys.exit(1)
 
 resources = os.path.join(target_dir, "LLDB.framework", "Resources")
 
 if not os.path.isdir(resources):
-    print resources + " must exist"
+    print(resources + " must exist")
     sys.exit(1)
 
 clang_dir = os.path.join(llvm_build_dir, "lib", "clang")
 
 if not os.path.isdir(clang_dir):
-    print clang_dir + " must exist"
+    print(clang_dir + " must exist")
     sys.exit(1)
 
 version_dir = None
 
 for subdir in os.listdir(clang_dir):
     if (re.match("^[0-9]+(\.[0-9]+)*$", subdir)):
         version_dir = os.path.join(clang_dir, subdir)
         break
 
 if version_dir is None:
-    print "Couldn't find a subdirectory of the form #(.#)... in " + clang_dir
+    print("Couldn't find a subdirectory of the form #(.#)... in " + clang_dir)
     sys.exit(1)
 
 if not os.path.isdir(version_dir):
-    print version_dir + " is not a directory"
+    print(version_dir + " is not a directory")
     sys.exit(1)
 
 # Just checking... we're actually going to copy all of version_dir
 include_dir = os.path.join(version_dir, "include")
 
 if not os.path.isdir(include_dir):
-    print version_dir + " is not a directory"
+    print(version_dir + " is not a directory")
     sys.exit(1)
 
 clang_resources = os.path.join(resources, "Clang")
 
 if os.path.isdir(clang_resources):
     shutil.rmtree(clang_resources)
 
 shutil.copytree(version_dir, clang_resources)

scripts/buildbot.py

 
 build_bot = LLDBBuildBot(build_directory_path=arg_dict["build_path"],
                          log_path=arg_dict["log_file"],
                          revision=arg_dict["revision"])
 
 try:
     build_bot.Run()
 except BuildError as err:
-    print err
+    print(err)

scripts/install_custom_python.py

 import os
 import shutil
 import sys
 
 
 def copy_one_file(dest_dir, source_dir, filename):
     source_path = os.path.join(source_dir, filename)
     dest_path = os.path.join(dest_dir, filename)
-    print 'Copying file %s ==> %s...' % (source_path, dest_path)
+    print('Copying file %s ==> %s...' % (source_path, dest_path))
     shutil.copyfile(source_path, dest_path)
 
 
 def copy_named_files(
         dest_dir,
         source_dir,
         files,
         extensions,
         copy_debug_suffix_also):
     for (file, ext) in itertools.product(files, extensions):
         copy_one_file(dest_dir, source_dir, file + '.' + ext)
         if copy_debug_suffix_also:
             copy_one_file(dest_dir, source_dir, file + '_d.' + ext)
 
 
 def copy_subdirectory(dest_dir, source_dir, subdir):
     dest_dir = os.path.join(dest_dir, subdir)
     source_dir = os.path.join(source_dir, subdir)
-    print 'Copying directory %s ==> %s...' % (source_dir, dest_dir)
+    print('Copying directory %s ==> %s...' % (source_dir, dest_dir))
     shutil.copytree(source_dir, dest_dir)
 
 
 def copy_distro(dest_dir, dest_subdir, source_dir, source_prefix):
     dest_dir = os.path.join(dest_dir, dest_subdir)
 
-    print 'Copying distribution %s ==> %s' % (source_dir, dest_dir)
+    print('Copying distribution %s ==> %s' % (source_dir, dest_dir))
 
     os.mkdir(dest_dir)
     PCbuild_dir = os.path.join(source_dir, 'PCbuild')
     if source_prefix:
         PCbuild_dir = os.path.join(PCbuild_dir, source_prefix)
     # First copy the files that go into the root of the new distribution. This
     # includes the Python executables, python27(_d).dll, and relevant PDB
     # files.
-    print 'Copying Python executables...'
+    print('Copying Python executables...')
     copy_named_files(
         dest_dir, PCbuild_dir, ['w9xpopen'], [
             'exe', 'pdb'], False)
     copy_named_files(
         dest_dir, PCbuild_dir, [
             'python_d', 'pythonw_d'], ['exe'], False)
     copy_named_files(
         dest_dir, PCbuild_dir, [
             'python', 'pythonw'], [
             'exe', 'pdb'], False)
     copy_named_files(dest_dir, PCbuild_dir, ['python27'], ['dll', 'pdb'], True)
 
     # Next copy everything in the Include directory.
-    print 'Copying Python include directory'
+    print('Copying Python include directory')
     copy_subdirectory(dest_dir, source_dir, 'Include')
 
     # Copy Lib folder (builtin Python modules)
-    print 'Copying Python Lib directory'
+    print('Copying Python Lib directory')
     copy_subdirectory(dest_dir, source_dir, 'Lib')
 
     # Copy tools folder.  These are probably not necessary, but we copy them anyway to
     # match an official distribution as closely as possible.  Note that we don't just copy
     # the subdirectory recursively.  The source distribution ships with many more tools
     # than what you get by installing python regularly.  We only copy the tools that appear
     # in an installed distribution.
     tools_dest_dir = os.path.join(dest_dir, 'Tools')
pyd_names = [
         'pyexpat',
         'select',
         'unicodedata',
         'winsound']
 
     # Copy builtin extension modules (pyd files)
     dlls_dir = os.path.join(dest_dir, 'DLLs')
     os.mkdir(dlls_dir)
-    print 'Copying DLLs directory'
+    print('Copying DLLs directory')
     copy_named_files(dlls_dir, PCbuild_dir, pyd_names, ['pyd', 'pdb'], True)
 
     # Copy libs folder (implibs for the pyd files)
     libs_dir = os.path.join(dest_dir, 'libs')
     os.mkdir(libs_dir)
-    print 'Copying libs directory'
+    print('Copying libs directory')
     copy_named_files(libs_dir, PCbuild_dir, pyd_names, ['lib'], False)
     copy_named_files(libs_dir, PCbuild_dir, ['python27'], ['lib'], True)
 
 
 parser = argparse.ArgumentParser(
     description='Install a custom Python distribution')
 parser.add_argument(
     '--source',
parser.add_argument(
     help='If --overwite was specified, suppress confirmation before deleting a directory tree.')
 
 args = parser.parse_args()
 
 args.source = os.path.normpath(args.source)
 args.dest = os.path.normpath(args.dest)
 
 if not os.path.exists(args.source):
-    print 'The source directory %s does not exist.  Exiting...'
+    print('The source directory %s does not exist.  Exiting...')
     sys.exit(1)
 
 if os.path.exists(args.dest):
     if not args.overwrite:
-        print 'The destination directory \'%s\' already exists and --overwrite was not specified.  Exiting...' % args.dest
+        print('The destination directory \'%s\' already exists and --overwrite was not specified.  Exiting...' % args.dest)
         sys.exit(1)
     while not args.silent:
-        print 'Ok to recursively delete \'%s\' and all contents (Y/N)?  Choosing Y will permanently delete the contents.' % args.dest
+        print('Ok to recursively delete \'%s\' and all contents (Y/N)?  Choosing Y will permanently delete the contents.' % args.dest)
         result = str.upper(sys.stdin.read(1))
         if result == 'N':
-            print 'Unable to copy files to the destination.  The destination already exists.'
+            print('Unable to copy files to the destination.  The destination already exists.')
             sys.exit(1)
         elif result == 'Y':
             break
     shutil.rmtree(args.dest)
 
 os.mkdir(args.dest)
 copy_distro(args.dest, 'x86', args.source, None)
 copy_distro(args.dest, 'x64', args.source, 'amd64')

scripts/verify_api.py

 def extract_exe_symbol_names(arch, exe_path, match_str):
     command = 'dsymutil --arch %s -s "%s" | grep "%s" | colrm 1 69' % (
         arch, exe_path, match_str)
     (command_exit_status, command_output) = commands.getstatusoutput(command)
     if command_exit_status == 0:
         if command_output:
             return command_output[0:-1].split("'\n")
         else:
-            print 'error: command returned no output'
+            print('error: command returned no output')
     else:
-        print 'error: command failed with exit status %i\n    command: %s' % (command_exit_status, command)
+        print('error: command failed with exit status %i\n    command: %s' % (command_exit_status, command))
     return list()
 
 
 def verify_api(all_args):
     '''Verify the API in the specified library is valid given one or more binaries.'''
     usage = "usage: verify_api --library <path> [ --library <path> ...] executable1 [executable2 ...]"
     description = '''Verify the API in the specified library is valid given one or more binaries.
 
if options.archs:
                 external_symbols = extract_exe_symbol_names(
                     arch, library, "(     SECT EXT)")
                 if external_symbols:
                     for external_symbol in external_symbols:
                         api_external_symbols.append(external_symbol)
                 else:
                     sys.exit(1)
     else:
-        print 'error: must specify one or more architectures with the --arch option'
+        print('error: must specify one or more architectures with the --arch option')
         sys.exit(4)
     if options.verbose:
-        print "API symbols:"
+        print("API symbols:")
         for (i, external_symbol) in enumerate(api_external_symbols):
-            print "[%u] %s" % (i, external_symbol)
+            print("[%u] %s" % (i, external_symbol))
 
     api_regex = None
     if options.api_regex_str:
         api_regex = re.compile(options.api_regex_str)
 
     for arch in options.archs:
         for exe_path in args:
-            print 'Verifying (%s) "%s"...' % (arch, exe_path)
+            print('Verifying (%s) "%s"...' % (arch, exe_path))
             exe_errors = 0
             undefined_symbols = extract_exe_symbol_names(
                 arch, exe_path, "(     UNDF EXT)")
             for undefined_symbol in undefined_symbols:
                 if api_regex:
                     match = api_regex.search(undefined_symbol)
                     if not match:
                         if options.verbose:
-                            print 'ignoring symbol: %s' % (undefined_symbol)
+                            print('ignoring symbol: %s' % (undefined_symbol))
                         continue
                 if undefined_symbol in api_external_symbols:
                     if options.verbose:
-                        print 'verified symbol: %s' % (undefined_symbol)
+                        print('verified symbol: %s' % (undefined_symbol))
                 else:
-                    print 'missing symbol: %s' % (undefined_symbol)
+                    print('missing symbol: %s' % (undefined_symbol))
                     exe_errors += 1
             if exe_errors:
-                print 'error: missing %u API symbols from %s' % (exe_errors, options.libraries)
+                print('error: missing %u API symbols from %s' % (exe_errors, options.libraries))
             else:
-                print 'success'
+                print('success')
 
 if __name__ == '__main__':
     verify_api(sys.argv[1:])

utils/git-svn/convert.py

 #!/usr/bin/env python
 
 """
 Convert the raw message sources from git patch emails to git-am friendly files.
 
 Usage:
 
 1. Mail.app -> Save As -> api.eml (Raw Message Source)
 2. .../convert.py api.eml
 3. git am [--signoff] < api.eml
 4. git svn dcommit [--commit-url https://[e-mail]/svn/llvm-project/lldb/trunk]
 """
 
+from __future__ import print_function
+
 import os
 import re
 import sys
 import StringIO
 
 
 def usage(problem_file=None):
     if problem_file:
-        print "%s is not a file" % problem_file
-    print "Usage: convert.py raw-message-source [raw-message-source2 ...]"
+        print("%s is not a file" % problem_file)
+    print("Usage: convert.py raw-message-source [raw-message-source2 ...]")
     sys.exit(0)
 
 
 def do_convert(file):
     """Skip all preceding mail message headers until 'From: ' is encountered.
     Then for each line ('From: ' header included), replace the dos style CRLF
     end-of-line with unix style LF end-of-line.
     """
-    print "converting %s ..." % file
+    print("converting %s ..." % file)
 
     with open(file, 'r') as f_in:
         content = f_in.read()
 
     # The new content to be written back to the same file.
     new_content = StringIO.StringIO()
 
     # Boolean flag controls whether to start printing lines.
     from_header_seen = False
 
     # By default, splitlines() don't include line breaks.  CRLF should be gone.
     for line in content.splitlines():
         # Wait till we scan the 'From: ' header before start printing the
         # lines.
         if not from_header_seen:
             if not line.startswith('From: '):
                 continue
             else:
                 from_header_seen = True
 
-        print >> new_content, line
+        print(line, file=new_content)
 
     with open(file, 'w') as f_out:
         f_out.write(new_content.getvalue())
 
-    print "done"
+    print("done")
 
 
 def main():
     if len(sys.argv) == 1:
         usage()
     # Convert the raw message source one by one.
     for file in sys.argv[1:]:
         if not os.path.isfile(file):
             usage(file)
         do_convert(file)
 
 if __name__ == '__main__':
     main()

utils/lui/lldbutil.py

 ##===-- lldbutil.py ------------------------------------------*- Python -*-===##
 ##
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ##
 ##===----------------------------------------------------------------------===##
 
 """
 This LLDB module contains miscellaneous utilities.
 Some of the test suite takes advantage of the utility functions defined here.
 They can also be useful for general purpose lldb scripting.
 """
 
+from __future__ import print_function
+
 import lldb
 import os
 import sys
 import StringIO
 
 # ===================================================
 # Utilities for locating/checking executable programs
 # ===================================================

 def disassemble(target, function_or_symbol):
     """Disassemble the function or symbol given a target.
 
     It returns the disassembly content in a string object.
     """
     buf = StringIO.StringIO()
     insts = function_or_symbol.GetInstructions(target)
     for i in insts:
-        print >> buf, i
+        print(i, file=buf)
     return buf.getvalue()
 
 # ==========================================================
 # Integer (byte size 1, 2, 4, and 8) to bytearray conversion
 # ==========================================================
 
 
 def int_to_bytearray(val, bytesize):
def print_stacktrace(thread, string_buffer=False):
     files = get_filenames(thread)
     lines = get_line_numbers(thread)
     addrs = get_pc_addresses(thread)
 
     if thread.GetStopReason() != lldb.eStopReasonInvalid:
         desc = "stop reason=" + stop_reason_to_str(thread.GetStopReason())
     else:
         desc = ""
-    print >> output, "Stack trace for thread id={0:#x} name={1} queue={2} ".format(
-        thread.GetThreadID(), thread.GetName(), thread.GetQueueName()) + desc
+    print("Stack trace for thread id={0:#x} name={1} queue={2} ".format(
+        thread.GetThreadID(), thread.GetName(), thread.GetQueueName()) + desc, file=output)
 
     for i in range(depth):
         frame = thread.GetFrameAtIndex(i)
         function = frame.GetFunction()
 
         load_addr = addrs[i].GetLoadAddress(target)
         if not function:
             file_addr = addrs[i].GetFileAddress()
             start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
             symbol_offset = file_addr - start_addr
-            print >> output, "  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}".format(
-                num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
+            print("  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}".format(
+                num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset), file=output)
         else:
-            print >> output, "  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}".format(
+            print("  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}".format(
                 num=i, addr=load_addr, mod=mods[i], func='%s [inlined]' %
                 funcs[i] if frame.IsInlined() else funcs[i], file=files[i], line=lines[i], args=get_args_as_string(
-                    frame, showFuncName=False) if not frame.IsInlined() else '()')
+                    frame, showFuncName=False) if not frame.IsInlined() else '()'), file=output)
 
     if string_buffer:
         return output.getvalue()
 
 
 def print_stacktraces(process, string_buffer=False):
     """Prints the stack traces of all the threads."""
 
     output = StringIO.StringIO() if string_buffer else sys.stdout
 
-    print >> output, "Stack traces for " + str(process)
+    print("Stack traces for " + str(process), file=output)
 
     for thread in process:
-        print >> output, print_stacktrace(thread, string_buffer=True)
+        print(print_stacktrace(thread, string_buffer=True), file=output)
 
     if string_buffer:
         return output.getvalue()
 
 # ===================================
 # Utility functions related to Frames
 # ===================================
 
else:
         return "(%s)" % (", ".join(args))
 
 
 def print_registers(frame, string_buffer=False):
     """Prints all the register sets of the frame."""
 
     output = StringIO.StringIO() if string_buffer else sys.stdout
 
-    print >> output, "Register sets for " + str(frame)
+    print("Register sets for " + str(frame), file=output)
 
     registerSet = frame.GetRegisters()  # Return type of SBValueList.
-    print >> output, "Frame registers (size of register set = %d):" % registerSet.GetSize(
-    )
+    print("Frame registers (size of register set = %d):" % registerSet.GetSize(
+    ), file=output)
     for value in registerSet:
         #print >> output, value
-        print >> output, "%s (number of children = %d):" % (
-            value.GetName(), value.GetNumChildren())
+        print("%s (number of children = %d):" % (
+            value.GetName(), value.GetNumChildren()), file=output)
         for child in value:
-            print >> output, "Name: %s, Value: %s" % (
-                child.GetName(), child.GetValue())
+            print("Name: %s, Value: %s" % (
+                child.GetName(), child.GetValue()), file=output)
 
     if string_buffer:
         return output.getvalue()
 
 
 def get_registers(frame, kind):
     """Returns the registers given the frame and the kind of registers desired.
 
def format(self, value, buffer=None, indent=0):
             output = buffer
         # If there is a summary, it suffices.
         val = value.GetSummary()
         # Otherwise, get the value.
         if val is None:
             val = value.GetValue()
         if val is None and value.GetNumChildren() > 0:
             val = "%s (location)" % value.GetLocation()
-        print >> output, "{indentation}({type}) {name} = {value}".format(
+        print("{indentation}({type}) {name} = {value}".format(
             indentation=' ' * indent,
             type=value.GetTypeName(),
             name=value.GetName(),
-            value=val)
+            value=val), file=output)
         return output.getvalue()
 
 
 class ChildVisitingFormatter(BasicFormatter):
     """The child visiting formatter prints the value and its immediate children.
 
     The constructor takes a keyword arg: indent_child, which defaults to 2.
     """

utils/lui/lui.py

def handle_args(driver, argv):
 
     (options, args) = parser.parse_args(argv)
 
     if options.pid is not None:
         try:
             pid = int(options.pid)
             driver.attachProcess(ui, pid)
         except ValueError:
-            print "Error: expecting integer PID, got '%s'" % options.pid
+            print("Error: expecting integer PID, got '%s'" % options.pid)
     elif options.core is not None:
         if not os.path.exists(options.core):
             raise Exception(
                 "Specified core file '%s' does not exist." %
                 options.core)
         driver.loadCore(options.core)
     elif len(args) == 2:
         if not os.path.isfile(args[1]):

utils/misc/grep-svn-log.py

 #!/usr/bin/env python
 
 """
 Greps and returns the first svn log entry containing a line matching the regular
 expression pattern passed as the only arg.
 
 Example:
 
 svn log -v | grep-svn-log.py '^   D.+why_are_you_missing.h$'
 """
+from __future__ import print_function
 
 import fileinput
 import re
 import sys
 import StringIO
 
 # Separator string for "svn log -v" output.
 separator = '-' * 72
 
 usage = """Usage: grep-svn-log.py line-pattern
 Example:
     svn log -v | grep-svn-log.py '^   D.+why_are_you_missing.h'"""
 
 
 class Log(StringIO.StringIO):
     """Simple facade to keep track of the log content."""
 
     def __init__(self):
         self.reset()
 
     def add_line(self, a_line):
         """Add a line to the content, if there is a previous line, commit it."""
         global separator
         if self.prev_line is not None:
-            print >> self, self.prev_line
+            print(self.prev_line, file=self)
         self.prev_line = a_line
         self.separator_added = (a_line == separator)
 
     def del_line(self):
         """Forget about the previous line, do not commit it."""
         self.prev_line = None
 
     def reset(self):
         """Forget about the previous lines entered."""
-        StringIO.StringIO.__init__(self)
+        io.StringIO.__init__(self)
         self.prev_line = None
 
     def finish(self):
         """Call this when you're finished with populating content."""
         if self.prev_line is not None:
-            print >> self, self.prev_line
+            print(self.prev_line, file=self)
         self.prev_line = None
 
 
 def grep(regexp):
     # The log content to be written out once a match is found.
     log = Log()
 
     LOOKING_FOR_MATCH = 0
     FOUND_LINE_MATCH = 1
     state = LOOKING_FOR_MATCH
 
     while True:
         line = sys.stdin.readline()
         if not line:
             return
         line = line.splitlines()[0]
         if state == FOUND_LINE_MATCH:
             # At this state, we keep on accumulating lines until the separator
             # is encountered.  At which point, we can return the log content.
             if line == separator:
                 log.finish()
-                print log.getvalue()
+                print(log.getvalue())
                 return
             log.add_line(line)
 
         elif state == LOOKING_FOR_MATCH:
             if line == separator:
                 log.reset()
             log.add_line(line)
             # Update next state if necessary.
             if regexp.search(line):
                 state = FOUND_LINE_MATCH
 
 
 def main():
     if len(sys.argv) != 2:
-        print usage
+        print(usage)
         sys.exit(0)
 
     regexp = re.compile(sys.argv[1])
     grep(regexp)
     sys.stdin.close()
 
 if __name__ == '__main__':
     main()

utils/sync-source/lib/transfer/rsync.py

def transfer(self, transfer_specs, dry_run):
         if self.options.verbose:
             printer = pprint.PrettyPrinter()
             for spec in transfer_specs:
                 printer.pprint(spec)
 
         for spec in transfer_specs:
             cmd = self.build_rsync_command(spec, dry_run)
             if self.options.verbose:
-                print "executing the following command:\n{}".format(cmd)
+                print("executing the following command:\n{}".format(cmd))
             result = subprocess.call(
                 cmd, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
             if result != 0:
                 return result

utils/sync-source/syncsource.py

while next_config_name:
             raise "failed to find specified parent config '{}'".format(
                 next_config_name)
     return Configuration(rcdata_configs)
 
 
 def create_transfer_agent(options, configuration):
     transfer_class_spec = configuration.get_value("transfer_class")
     if options.verbose:
-        print "specified transfer class: '{}'".format(transfer_class_spec)
+        print("specified transfer class: '{}'".format(transfer_class_spec))
 
     # Load the module (possibly package-qualified).
     components = transfer_class_spec.split(".")
     module = importlib.import_module(".".join(components[:-1]))
 
     # Create the class name we need to load.
     clazz = getattr(module, components[-1])
     return clazz(options, configuration)
if options.default_excludes and len(options.default_excludes) > 0:
         default_excludes = options.default_excludes.split(",")
     else:
         default_excludes = []
 
     # Locate the rc filename to load, then load it.
     rc_filename = find_appropriate_rcfile(options)
     if rc_filename:
         if options.verbose:
-            print "reading rc data from file '{}'".format(rc_filename)
+            print("reading rc data from file '{}'".format(rc_filename))
         rcdata = read_rcfile(rc_filename)
     else:
         sys.stderr.write("no rcfile specified, cannot guess configuration")
         exit(1)
 
     # Find configuration.
     configuration = get_configuration(options, rcdata, options.config_name)
     if not configuration:

utils/test/disasm.py

 #!/usr/bin/env python
 
 """
 Run gdb to disassemble a function, feed the bytes to 'llvm-mc -disassemble' command,
 and display the disassembly result.
 
 """
 
+from __future__ import print_function
+
 import os
 import sys
 from optparse import OptionParser
 
 
 def is_exe(fpath):
     """Check whether fpath is an executable."""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
for line in gdb_output.split(os.linesep):
             x_output = gdb.before
             # Get the last output line from the gdb examine memory command,
             # split the string into a 3-tuple with separator '>:' to handle
             # objc method names.
             memory_dump = x_output.split(
                 os.linesep)[-1].partition('>:')[2].strip()
             # print "\nbytes:", memory_dump
             disasm_str = prev_line.partition('>:')[2]
-            print >> mc_input, '%s # %s' % (memory_dump, disasm_str)
+            print('%s # %s' % (memory_dump, disasm_str), file=mc_input)
 
         # We're done with the processing.  Assign the current line to be
         # prev_line.
         prev_line = line
 
     # Close the gdb session now that we are done with it.
     gdb.sendline('quit')
     gdb.expect(pexpect.EOF)
     gdb.close()
 
     # Write the memory dump into a file.
     with open('disasm-input.txt', 'w') as f:
         f.write(mc_input.getvalue())
 
     mc_cmd = '%s -disassemble %s disasm-input.txt' % (mc, mc_options)
-    print "\nExecuting command:", mc_cmd
+    print("\nExecuting command:", mc_cmd)
     os.system(mc_cmd)
 
     # And invoke llvm-mc with the just recorded file.
     #mc = pexpect.spawn('%s -disassemble %s disasm-input.txt' % (mc, mc_options))
     #mc.logfile_read = sys.stdout
     # print "mc:", mc
     # mc.close()
 
if not llvm_mc:
         parser.print_help()
         sys.exit(1)
 
     # This is optional.  For example:
     # --options='-triple=arm-apple-darwin -debug-only=arm-disassembler'
     llvm_mc_options = opts.llvm_mc_options
 
     # We have parsed the options.
-    print "gdb commands:", gdb_commands
-    print "gdb options:", gdb_options
-    print "executable:", executable
-    print "function:", function
-    print "llvm-mc:", llvm_mc
-    print "llvm-mc options:", llvm_mc_options
+    print("gdb commands:", gdb_commands)
+    print("gdb options:", gdb_options)
+    print("executable:", executable)
+    print("function:", function)
+    print("llvm-mc:", llvm_mc)
+    print("llvm-mc options:", llvm_mc_options)
 
     do_llvm_mc_disassembly(
         gdb_commands,
         gdb_options,
         executable,
         function,
         llvm_mc,
         llvm_mc_options)
 
 if __name__ == '__main__':
     main()

utils/test/lldb-disasm.py

 #!/usr/bin/env python
 
 """
 Run lldb to disassemble all the available functions for an executable image.
 
 """
 
+from __future__ import print_function
+
 import os
 import re
 import sys
 from optparse import OptionParser
 
 
 def setupSysPath():
     """
     Add LLDB.framework/Resources/Python and the test dir to the sys.path.
     """
     # Get the directory containing the current script.
     scriptPath = sys.path[0]
     if not scriptPath.endswith(os.path.join('utils', 'test')):
-        print "This script expects to reside in lldb's utils/test directory."
+        print("This script expects to reside in lldb's utils/test directory.")
         sys.exit(-1)
 
     # This is our base name component.
     base = os.path.abspath(os.path.join(scriptPath, os.pardir, os.pardir))
 
     # This is for the goodies in the test directory under base.
     sys.path.append(os.path.join(base, 'test'))
 
def setupSysPath():
     elif os.path.isfile(os.path.join(relPath2, 'lldb.py')):
         lldbPath = relPath2
     elif os.path.isfile(os.path.join(baiPath, 'lldb.py')):
         lldbPath = baiPath
     elif os.path.isfile(os.path.join(baiPath2, 'lldb.py')):
         lldbPath = baiPath2
 
     if not lldbPath:
-        print 'This script requires lldb.py to be in either ' + dbgPath + ',',
-        print relPath + ', or ' + baiPath
+        print('This script requires lldb.py to be in either ' + dbgPath + ',', end=' ')
+        print(relPath + ', or ' + baiPath)
         sys.exit(-1)
 
     # This is to locate the lldb.py module.  Insert it right after sys.path[0].
     sys.path[1:1] = [lldbPath]
     # print "sys.path:", sys.path
 
 
 def run_command(ci, cmd, res, echo=True):
     if echo:
-        print "run command:", cmd
+        print("run command:", cmd)
     ci.HandleCommand(cmd, res)
     if res.Succeeded():
         if echo:
-            print "run_command output:", res.GetOutput()
+            print("run_command output:", res.GetOutput())
     else:
         if echo:
-            print "run command failed!"
-            print "run_command error:", res.GetError()
+            print("run command failed!")
+            print("run_command error:", res.GetError())
 
 
 def do_lldb_disassembly(lldb_commands, exe, disassemble_options, num_symbols,
                         symbols_to_disassemble,
                         re_symbol_pattern,
                         quiet_disassembly):
     import lldb
     import atexit
def IsCodeType(symbol):
         return symbol.GetType() == lldb.eSymbolTypeCode
 
     # Define a generator for the symbols to disassemble.
     def symbol_iter(num, symbols, re_symbol_pattern, target, verbose):
         # If we specify the symbols to disassemble, ignore symbol table dump.
         if symbols:
             for i in range(len(symbols)):
                 if verbose:
-                    print "symbol:", symbols[i]
+                    print("symbol:", symbols[i])
                 yield symbols[i]
         else:
             limited = True if num != -1 else False
             if limited:
                 count = 0
             if re_symbol_pattern:
                 pattern = re.compile(re_symbol_pattern)
             stream = lldb.SBStream()
             for m in target.module_iter():
                 if verbose:
-                    print "module:", m
+                    print("module:", m)
                 for s in m:
                     if limited and count >= num:
                         return
                     # If a regexp symbol pattern is supplied, consult it.
                     if re_symbol_pattern:
                         # If the pattern does not match, look for the next
                         # symbol.
                         if not pattern.match(s.GetName()):
                             continue
 
                     # If we come here, we're ready to disassemble the symbol.
                     if verbose:
-                        print "symbol:", s.GetName()
+                        print("symbol:", s.GetName())
                     if IsCodeType(s):
                         if limited:
                             count = count + 1
                             if verbose:
-                                print "returning symbol:", s.GetName()
+                                print("returning symbol:", s.GetName())
                         yield s.GetName()
                     if verbose:
-                        print "start address:", s.GetStartAddress()
-                        print "end address:", s.GetEndAddress()
+                        print("start address:", s.GetStartAddress())
+                        print("end address:", s.GetEndAddress())
                         s.GetDescription(stream)
-                        print "symbol description:", stream.GetData()
+                        print("symbol description:", stream.GetData())
                         stream.Clear()
 
     # Disassembly time.
     for symbol in symbol_iter(
             num_symbols,
             symbols_to_disassemble,
             re_symbol_pattern,
             target,
""")
     disassemble_options = opts.disassemble_options
     quiet_disassembly = opts.quiet_disassembly
     num_symbols = opts.num_symbols
     symbols_to_disassemble = opts.symbols_to_disassemble
     re_symbol_pattern = opts.re_symbol_pattern
 
     # We have parsed the options.
     if not quiet_disassembly:
-        print "lldb commands:", lldb_commands
-        print "executable:", executable
-        print "disassemble options:", disassemble_options
-        print "quiet disassembly output:", quiet_disassembly
-        print "num of symbols to disassemble:", num_symbols
-        print "symbols to disassemble:", symbols_to_disassemble
-        print "regular expression of symbols to disassemble:", re_symbol_pattern
+        print("lldb commands:", lldb_commands)
+        print("executable:", executable)
+        print("disassemble options:", disassemble_options)
+        print("quiet disassembly output:", quiet_disassembly)
+        print("num of symbols to disassemble:", num_symbols)
+        print("symbols to disassemble:", symbols_to_disassemble)
+        print("regular expression of symbols to disassemble:", re_symbol_pattern)
 
     setupSysPath()
     do_lldb_disassembly(lldb_commands, executable, disassemble_options,
                         num_symbols,
                         symbols_to_disassemble,
                         re_symbol_pattern,
                         quiet_disassembly)
 
 if __name__ == '__main__':
     main()

utils/test/llvm-mc-shell.py

 #!/usr/bin/env python
 
 """
 Run llvm-mc interactively.
 
 """
 
+from __future__ import print_function
+
 import os
 import sys
 from optparse import OptionParser
 
 
 def is_exe(fpath):
     """Check whether fpath is an executable."""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
if not llvm_mc:
         parser.print_help()
         sys.exit(1)
 
     # This is optional.  For example:
     # --options='-disassemble -triple=arm-apple-darwin -debug-only=arm-disassembler'
     llvm_mc_options = opts.llvm_mc_options
 
     # We have parsed the options.
-    print "llvm-mc:", llvm_mc
-    print "llvm-mc options:", llvm_mc_options
+    print("llvm-mc:", llvm_mc)
+    print("llvm-mc options:", llvm_mc_options)
 
     llvm_mc_loop(llvm_mc, llvm_mc_options)
 
 if __name__ == '__main__':
     main()

utils/test/ras.py

 #!/usr/bin/env python
 
 """
 Run the test suite and send the result as an email message.
 
 The code for sending of the directory is copied from
 http://docs.python.org/library/email-examples.html.
 """
 
+from __future__ import print_function
+
 import os
 import sys
 import shutil
 import smtplib
 # For guessing MIME type based on file name extension
 import mimetypes
 
 from optparse import OptionParser

 def runTestsuite(testDir, sessDir, envs=None):
     """Run the testsuite and return a (summary, output) tuple."""
     os.chdir(testDir)
 
     for env in envs:
         list = env.split('=')
         var = list[0].strip()
         val = list[1].strip()
-        print var + "=" + val
+        print(var + "=" + val)
         os.environ[var] = val
 
     import shlex
     import subprocess
 
     command_line = "./dotest.py -w -s %s" % sessDir
     # Apply correct tokenization for subprocess.Popen().
     args = shlex.split(command_line)

utils/test/run-dis.py

 #!/usr/bin/env python
 
 """
 Run lldb disassembler on all the binaries specified by a combination of root dir
 and path pattern.
 """
 
+from __future__ import print_function
+
 import os
 import sys
 import subprocess
 import re
 from optparse import OptionParser
 
 # The directory of this Python script as well as the lldb-disasm.py workhorse.
 scriptPath = None
for root, dirs, files in os.walk(sdk_root, topdown=False):
             # If a suffix is specified, check it, too.
             if suffix and not name.endswith(suffix):
                 continue
             if not isbinary(path):
                 continue
 
             command = template % (
                 scriptPath, path, num_symbols if num_symbols > 0 else 1000)
-            print "Running %s" % (command)
+            print("Running %s" % (command))
             os.system(command)
 
 
 def main():
     """Read the root dir and the path spec, invoke lldb-disasm.py on the file."""
     global scriptPath
     global root_dir
     global path_pattern
if not os.path.isdir(root_dir):
         parser.print_help()
         sys.exit(1)
 
     path_pattern = opts.path_pattern
     path_regexp = re.compile(path_pattern)
     suffix = opts.suffix
     num_symbols = opts.num_symbols
 
-    print "Root directory for SDK symbols:", root_dir
-    print "Regular expression for the binaries:", path_pattern
-    print "Suffix of the binaries to look for:", suffix
-    print "num of symbols to disassemble:", num_symbols
+    print("Root directory for SDK symbols:", root_dir)
+    print("Regular expression for the binaries:", path_pattern)
+    print("Suffix of the binaries to look for:", suffix)
+    print("num of symbols to disassemble:", num_symbols)
 
     walk_and_invoke(root_dir, path_regexp, suffix, num_symbols)
 
 
 if __name__ == '__main__':
     main()

utils/test/run-until-faulted.py

 #!/usr/bin/env python
 
 """
 Run a program via lldb until it fails.
 The lldb executable is located via your PATH env variable, if not specified.
 """
 
+from __future__ import print_function
+
 import os
 import sys
 from optparse import OptionParser
 
 
 def is_exe(fpath):
     """Check whether fpath is an executable."""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
for i in range(100):
         if index == 0:
             # We'll try again later.
             time.sleep(3)
         elif index == 1:
             # Perfect, our process had stopped; break out of the loop.
             break
         elif index == 2:
             # Something went wrong.
-            print "TIMEOUT occurred:", str(lldb)
+            print("TIMEOUT occurred:", str(lldb))
 
     # Give control of lldb shell to the user.
     lldb.interact()
 
 
 def main():
     # This is to set up the Python path to include the pexpect-2.4 dir.
     # Remember to update this when/if things change.
""")
     if not opts.exe:
         parser.print_help()
         sys.exit(1)
     exe = opts.exe
 
     exe_options = opts.exe_options
 
     # We have parsed the options.
-    print "lldb command:", lldb_command
-    print "executable:", exe
-    print "executable options:", exe_options
+    print("lldb command:", lldb_command)
+    print("executable:", exe)
+    print("executable options:", exe_options)
 
     do_lldb_launch_loop(lldb_command, exe, exe_options)
 
 if __name__ == '__main__':
     main()

utils/vim-lldb/python-vim-lldb/lldb_controller.py

 
 #
 # This file defines the layer that talks to lldb
 #
 
+from __future__ import print_function
+
 import os
 import re
 import sys
 import lldb
 import vim
 from vim_ui import UI
 
 # =================================================
def doAttach(self, process_name):
             self.processListener, process_name, False, error)
         if not error.Success():
             sys.stderr.write("Error during attach: " + str(error))
             return
 
         self.ui.activate()
         self.pid = self.process.GetProcessID()
 
-        print "Attached to %s (pid=%d)" % (process_name, self.pid)
+        print("Attached to %s (pid=%d)" % (process_name, self.pid))
 
     def doDetach(self):
         if self.process is not None and self.process.IsValid():
             pid = self.process.GetProcessID()
             state = state_type_to_str(self.process.GetState())
             self.process.Detach()
             self.processPendingEvents(self.eventDelayLaunch)
 
def doLaunch(self, stop_at_entry, args):
             return
 
         # launch succeeded, store pid and add some event listeners
         self.pid = self.process.GetProcessID()
         self.processListener = lldb.SBListener("process_event_listener")
         self.process.GetBroadcaster().AddListener(
             self.processListener, lldb.SBProcess.eBroadcastBitStateChanged)
 
-        print "Launched %s %s (pid=%d)" % (exe, args, self.pid)
+        print("Launched %s %s (pid=%d)" % (exe, args, self.pid))
 
         if not stop_at_entry:
             self.doContinue()
         else:
             self.processPendingEvents(self.eventDelayLaunch)
 
     def doTarget(self, args):
         """ Pass target command to interpreter, except if argument is not one of the valid options, or
def doCommand(
             command_args,
             print_on_success=True,
             goto_file=False):
         """ Run cmd in interpreter and print result (success or failure) on the vim status line. """
         (success, output) = self.getCommandResult(command, command_args)
         if success:
             self.ui.update(self.target, "", self, goto_file)
             if len(output) > 0 and print_on_success:
-                print output
+                print(output)
         else:
             sys.stderr.write(output)
 
     def getCommandOutput(self, command, command_args=""):
         """ runs cmd in the command interpreter andreturns (status, result) """
         result = lldb.SBCommandReturnObject()
         cmd = "%s %s" % (command, command_args)
         self.commandInterpreter.HandleCommand(cmd, result)

utils/vim-lldb/python-vim-lldb/vim_ui.py

 
 # LLDB UI state in the Vim user interface.
 
+from __future__ import print_function
+
 import os
 import re
 import sys
 import lldb
 import vim
 from vim_panes import *
 from vim_signs import *
 
def update_pc(self, process, buffers, goto_file):
 
             if is_selected and goto_file:
                 # if the selected file has a PC marker, move the cursor there
                 # too
                 curname = vim.current.buffer.name
                 if curname is not None and is_same_file(curname, fname):
                     move_cursor(line, 0)
                 elif move_cursor:
-                    print "FIXME: not sure where to move cursor because %s != %s " % (vim.current.buffer.name, fname)
+                    print("FIXME: not sure where to move cursor because %s != %s " % (vim.current.buffer.name, fname))
 
     def update_breakpoints(self, target, buffers):
         """ Decorates buffer with signs corresponding to breakpoints in target. """
 
         def GetBreakpointLocations(bp):
             """ Returns a list of tuples (resolved, filename, line) where a breakpoint was resolved. """
             if not bp.IsValid():
                 sys.stderr.write("breakpoint is invalid, no locations")
def update(self, target, status, controller, goto_file=False):
         self.update_breakpoints(target, self.get_user_buffers())
 
         if target is not None and target.IsValid():
             process = target.GetProcess()
             if process is not None and process.IsValid():
                 self.update_pc(process, self.get_user_buffers, goto_file)
 
         if status is not None and len(status) > 0:
-            print status
+            print(status)
 
     def haveBreakpoint(self, file, line):
         """ Returns True if we have a breakpoint at file:line, False otherwise  """
         return (file, line) in self.markedBreakpoints
 
     def getBreakpoints(self, fname, line):
         """ Returns the LLDB SBBreakpoint object at fname:line """
         if self.haveBreakpoint(fname, line):