python compat - print statement

[lebedev.ri]

Can you please submit the google benchmark diff separately, and submit it upstream at the same time, please?

[michaelplatings]

examples/Kaleidoscope/MCJIT/cached/split-lib.py

3 ↗

(On Diff #180012)

missing underscore

[serge-sans-paille]

@lebedev.ri : it turns out the only print statement in the two files involved in gbench only have one argument, and they already have the required parethesis. This means that as such, even without the import from future, they work the same in Python2 and Python3. So I will just remove these imports to avoid extra noise.

[michaelplatings]

LGTM

llvm/trunk/bindings/python/llvm/core.py

 #===- core.py - Python LLVM Bindings -------------------------*- python -*--===#
 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 #
 #===------------------------------------------------------------------------===#
+from __future__ import print_function
 
 from .common import LLVMObject
 from .common import c_object_p
 from .common import get_library
 
 from . import enumerations
 
 from ctypes import POINTER
enums = [
         (Visibility, enumerations.Visibility),
         (CallConv, enumerations.CallConv),
         (IntPredicate, enumerations.IntPredicate),
         (RealPredicate, enumerations.RealPredicate),
         (LandingPadClauseTy, enumerations.LandingPadClauseTy),
     ]
     for enum_class, enum_spec in enums:
         for name, value in enum_spec:
-            print name, value
+            print(name, value)
             enum_class.register(name, value)
     return enums
 
 def initialize_llvm():
     Context.GetGlobalContext()
     p = PassRegistry()
     lib.LLVMInitializeCore(p)
     lib.LLVMInitializeTransformUtils(p)

llvm/trunk/bindings/python/llvm/tests/test_bitreader.py

+from __future__ import print_function
+
 from .base import TestBase
 from ..core import OpCode
 from ..core import MemoryBuffer
 from ..core import PassRegistry
 from ..core import Context
 from ..core import Module
 from ..bit_reader import parse_bitcode
 
 class TestBitReader(TestBase):
 
     def test_parse_bitcode(self):
         source = self.get_test_bc()
         m = parse_bitcode(MemoryBuffer(filename=source))
-        print m.target
-        print m.datalayout
+        print(m.target)
+        print(m.datalayout)

llvm/trunk/bindings/python/llvm/tests/test_core.py

+from __future__ import print_function
+
 from .base import TestBase
 from ..core import MemoryBuffer
 from ..core import PassRegistry
 from ..core import Context
 from ..core import Module
 from ..core import Enums
 from ..core import OpCode
 from ..bit_reader import parse_bitcode
def test_basicblock_instruction_iteration(self):
         bb = m.first.first
 
         # Forward
         for inst in bb:
             self.assertEqual(inst.name, inst_list[i][0])
             self.assertEqual(inst.opcode, inst_list[i][1])
             for op in range(len(inst)):
                 o = inst.get_operand(op)
-                print o.name
+                print(o.name)
                 o.dump()
             inst.dump()
             i += 1
 
         # Backwards
         for inst in reversed(bb):
             i -= 1
             self.assertEqual(inst.name, inst_list[i][0])
             self.assertEqual(inst.opcode, inst_list[i][1])
             inst.dump()

llvm/trunk/bindings/python/llvm/tests/test_disassembler.py

+from __future__ import print_function
+
 from .base import TestBase
 
 from ..disassembler import Disassembler, Option_UseMarkup
 
 class TestDisassembler(TestBase):
     def test_instantiate(self):
          Disassembler('i686-apple-darwin9')
 
class TestDisassembler(TestBase):
 
     def test_set_options(self):
         sequence = '\x10\x40\x2d\xe9'
         triple = 'arm-linux-android'
 
         disassembler = Disassembler(triple)
         disassembler.set_options(Option_UseMarkup)
         count, s = disassembler.get_instruction(sequence)
-        print s
+        print(s)
         self.assertEqual(count, 4)
         self.assertEqual(s, '\tpush\t{<reg:r4>, <reg:lr>}')

llvm/trunk/docs/conf.py

 # -*- coding: utf-8 -*-
 #
 # LLVM documentation build configuration file.
 #
 # This file is execfile()d with the current directory set to its containing dir.
 #
 # Note that not all possible configuration values are present in this
 # autogenerated file.
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
+from __future__ import print_function
 
 import sys, os
 from datetime import date
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #sys.path.insert(0, os.path.abspath('.'))
for name in os.listdir(command_guide_path):
 
     # Otherwise, automatically extract the description.
     file_subpath = os.path.join(command_guide_subpath, name)
     with open(os.path.join(command_guide_path, name)) as f:
         title = f.readline().rstrip('\n')
         header = f.readline().rstrip('\n')
 
         if len(header) != len(title):
-            print >>sys.stderr, (
+            print((
                 "error: invalid header in %r (does not match title)" % (
-                    file_subpath,))
+                    file_subpath,)), file=sys.stderr)
         if ' - ' not in title:
-            print >>sys.stderr, (
+            print((
                 ("error: invalid title in %r "
                  "(expected '<name> - <description>')") % (
-                    file_subpath,))
+                    file_subpath,)), file=sys.stderr)
 
         # Split the name out of the title.
         name,description = title.split(' - ', 1)
         man_pages.append((file_subpath.replace('.rst',''), name,
                           description, man_page_authors, 1))
 
 # If true, show URL addresses after external links.
 #man_show_urls = False

llvm/trunk/examples/Kaleidoscope/MCJIT/cached/genk-timing.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import sys
 import random
 
 class TimingScriptGenerator:
     """Used to generate a bash script which will invoke the toy and time it"""
     def __init__(self, scriptname, outputname):
         self.timeFile = outputname
         self.shfile = open(scriptname, 'w')
def writeFunctionCall(self):
         self.writeEmptyLine()
         self.updateCalledFunctionList(self.lastFuncNum)
 
     def writeFinalFunctionCounts(self):
         self.writeComment("Called %d of %d functions" % (len(self.calledFunctions), self.lastFuncNum))
 
 def generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript):
     """ Generate a random Kaleidoscope script based on the given parameters """
-    print "Generating " + filename
+    print("Generating " + filename)
     print("  %d functions, %d elements per function, %d functions between execution" %
           (numFuncs, elementsPerFunc, funcsBetweenExec))
     print("  Call weighting = %f" % callWeighting)
     script = KScriptGenerator(filename)
     script.setCallWeighting(callWeighting)
     script.writeComment("===========================================================================")
     script.writeComment("Auto-generated script")
     script.writeComment("  %d functions, %d elements per function, %d functions between execution"
for i in range(numFuncs):
             script.writeFunctionCall()
             funcsSinceLastExec = 0
     # Always end with a function call
     if funcsSinceLastExec > 0:
         script.writeFunctionCall()
     script.writeEmptyLine()
     script.writeFinalFunctionCounts()
     funcsCalled = len(script.calledFunctions)
-    print "  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted)
+    print("  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted))
     timingScript.writeTimingCall(filename, numFuncs, funcsCalled, script.totalCallsExecuted)
 
 # Execution begins here
 random.seed()
 
 timingScript = TimingScriptGenerator("time-toy.sh", "timing-data.txt")
 
 dataSets = [(5000, 3,  50, 0.50), (5000, 10, 100, 0.10), (5000, 10, 5, 0.10), (5000, 10, 1, 0.0),
             (1000, 3,  10, 0.50), (1000, 10, 100, 0.10), (1000, 10, 5, 0.10), (1000, 10, 1, 0.0),
             ( 200, 3,   2, 0.50), ( 200, 10,  40, 0.10), ( 200, 10, 2, 0.10), ( 200, 10, 1, 0.0)]
 
 # Generate the code
 for (numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting) in dataSets:
     filename = "test-%d-%d-%d-%d.k" % (numFuncs, elementsPerFunc, funcsBetweenExec, int(callWeighting * 100))
     generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript)
-print "All done!"
+print("All done!")

llvm/trunk/examples/Kaleidoscope/MCJIT/cached/split-lib.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 class TimingScriptGenerator:
     """Used to generate a bash script which will invoke the toy and time it"""
     def __init__(self, scriptname, outputname):
         self.shfile = open(scriptname, 'w')
         self.timeFile = outputname
         self.shfile.write("echo \"\" > %s\n" % self.timeFile)
 
     def writeTimingCall(self, irname, callname):

 def splitScript(inputname, libGenScript, timingScript):
   rootname = inputname[:-2]
   libname = rootname + "-lib.k"
   irname = rootname + "-lib.ir"
   callname = rootname + "-call.k"
   infile = open(inputname, "r")
   libfile = open(libname, "w")
   callfile = open(callname, "w")
-  print "Splitting %s into %s and %s" % (inputname, callname, libname)
+  print("Splitting %s into %s and %s" % (inputname, callname, libname))
   for line in infile:
     if not line.startswith("#"):
       if line.startswith("print"):
         callfile.write(line)
       else:
         libfile.write(line)
   libGenScript.writeLibGenCall(libname, irname)
   timingScript.writeTimingCall(irname, callname)
 
 # Execution begins here
 libGenScript = LibScriptGenerator("make-libs.sh")
 timingScript = TimingScriptGenerator("time-lib.sh", "lib-timing.txt")
 
 script_list = ["test-5000-3-50-50.k", "test-5000-10-100-10.k", "test-5000-10-5-10.k", "test-5000-10-1-0.k", 
                "test-1000-3-10-50.k", "test-1000-10-100-10.k", "test-1000-10-5-10.k", "test-1000-10-1-0.k",
                "test-200-3-2-50.k", "test-200-10-40-10.k", "test-200-10-2-10.k", "test-200-10-1-0.k"]
 
 for script in script_list:
   splitScript(script, libGenScript, timingScript)
-print "All done!"
+print("All done!")

llvm/trunk/examples/Kaleidoscope/MCJIT/complete/genk-timing.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import sys
 import random
 
 class TimingScriptGenerator:
     """Used to generate a bash script which will invoke the toy and time it"""
     def __init__(self, scriptname, outputname):
         self.timeFile = outputname
         self.shfile = open(scriptname, 'w')
def writeFunctionCall(self):
         self.writeEmptyLine()
         self.updateCalledFunctionList(self.lastFuncNum)
 
     def writeFinalFunctionCounts(self):
         self.writeComment("Called %d of %d functions" % (len(self.calledFunctions), self.lastFuncNum))
 
 def generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript):
     """ Generate a random Kaleidoscope script based on the given parameters """
-    print "Generating " + filename
+    print("Generating " + filename)
     print("  %d functions, %d elements per function, %d functions between execution" %
           (numFuncs, elementsPerFunc, funcsBetweenExec))
     print("  Call weighting = %f" % callWeighting)
     script = KScriptGenerator(filename)
     script.setCallWeighting(callWeighting)
     script.writeComment("===========================================================================")
     script.writeComment("Auto-generated script")
     script.writeComment("  %d functions, %d elements per function, %d functions between execution"
for i in range(numFuncs):
             script.writeFunctionCall()
             funcsSinceLastExec = 0
     # Always end with a function call
     if funcsSinceLastExec > 0:
         script.writeFunctionCall()
     script.writeEmptyLine()
     script.writeFinalFunctionCounts()
     funcsCalled = len(script.calledFunctions)
-    print "  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted)
+    print("  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted))
     timingScript.writeTimingCall(filename, numFuncs, funcsCalled, script.totalCallsExecuted)
 
 # Execution begins here
 random.seed()
 
 timingScript = TimingScriptGenerator("time-toy.sh", "timing-data.txt")
 
 dataSets = [(5000, 3,  50, 0.50), (5000, 10, 100, 0.10), (5000, 10, 5, 0.10), (5000, 10, 1, 0.0),
             (1000, 3,  10, 0.50), (1000, 10, 100, 0.10), (1000, 10, 5, 0.10), (1000, 10, 1, 0.0),
             ( 200, 3,   2, 0.50), ( 200, 10,  40, 0.10), ( 200, 10, 2, 0.10), ( 200, 10, 1, 0.0)]
 
 # Generate the code
 for (numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting) in dataSets:
     filename = "test-%d-%d-%d-%d.k" % (numFuncs, elementsPerFunc, funcsBetweenExec, int(callWeighting * 100))
     generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript)
-print "All done!"
+print("All done!")

llvm/trunk/examples/Kaleidoscope/MCJIT/complete/split-lib.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 class TimingScriptGenerator:
     """Used to generate a bash script which will invoke the toy and time it"""
     def __init__(self, scriptname, outputname):
         self.shfile = open(scriptname, 'w')
         self.timeFile = outputname
         self.shfile.write("echo \"\" > %s\n" % self.timeFile)
 
     def writeTimingCall(self, irname, callname):

 def splitScript(inputname, libGenScript, timingScript):
   rootname = inputname[:-2]
   libname = rootname + "-lib.k"
   irname = rootname + "-lib.ir"
   callname = rootname + "-call.k"
   infile = open(inputname, "r")
   libfile = open(libname, "w")
   callfile = open(callname, "w")
-  print "Splitting %s into %s and %s" % (inputname, callname, libname)
+  print("Splitting %s into %s and %s" % (inputname, callname, libname))
   for line in infile:
     if not line.startswith("#"):
       if line.startswith("print"):
         callfile.write(line)
       else:
         libfile.write(line)
   libGenScript.writeLibGenCall(libname, irname)
   timingScript.writeTimingCall(irname, callname)
 
 # Execution begins here
 libGenScript = LibScriptGenerator("make-libs.sh")
 timingScript = TimingScriptGenerator("time-lib.sh", "lib-timing.txt")
 
 script_list = ["test-5000-3-50-50.k", "test-5000-10-100-10.k", "test-5000-10-5-10.k", "test-5000-10-1-0.k", 
                "test-1000-3-10-50.k", "test-1000-10-100-10.k", "test-1000-10-5-10.k", "test-1000-10-1-0.k",
                "test-200-3-2-50.k", "test-200-10-40-10.k", "test-200-10-2-10.k", "test-200-10-1-0.k"]
 
 for script in script_list:
   splitScript(script, libGenScript, timingScript)
-print "All done!"
+print("All done!")

llvm/trunk/examples/Kaleidoscope/MCJIT/lazy/genk-timing.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import sys
 import random
 
 class TimingScriptGenerator:
     """Used to generate a bash script which will invoke the toy and time it"""
     def __init__(self, scriptname, outputname):
         self.timeFile = outputname
         self.shfile = open(scriptname, 'w')
def writeFunctionCall(self):
         self.writeEmptyLine()
         self.updateCalledFunctionList(self.lastFuncNum)
 
     def writeFinalFunctionCounts(self):
         self.writeComment("Called %d of %d functions" % (len(self.calledFunctions), self.lastFuncNum))
 
 def generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript):
     """ Generate a random Kaleidoscope script based on the given parameters """
-    print "Generating " + filename
+    print("Generating " + filename)
     print("  %d functions, %d elements per function, %d functions between execution" %
           (numFuncs, elementsPerFunc, funcsBetweenExec))
     print("  Call weighting = %f" % callWeighting)
     script = KScriptGenerator(filename)
     script.setCallWeighting(callWeighting)
     script.writeComment("===========================================================================")
     script.writeComment("Auto-generated script")
     script.writeComment("  %d functions, %d elements per function, %d functions between execution"
for i in range(numFuncs):
             script.writeFunctionCall()
             funcsSinceLastExec = 0
     # Always end with a function call
     if funcsSinceLastExec > 0:
         script.writeFunctionCall()
     script.writeEmptyLine()
     script.writeFinalFunctionCounts()
     funcsCalled = len(script.calledFunctions)
-    print "  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted)
+    print("  Called %d of %d functions, %d total" % (funcsCalled, numFuncs, script.totalCallsExecuted))
     timingScript.writeTimingCall(filename, numFuncs, funcsCalled, script.totalCallsExecuted)
 
 # Execution begins here
 random.seed()
 
 timingScript = TimingScriptGenerator("time-toy.sh", "timing-data.txt")
 
 dataSets = [(5000, 3,  50, 0.50), (5000, 10, 100, 0.10), (5000, 10, 5, 0.10), (5000, 10, 1, 0.0),
             (1000, 3,  10, 0.50), (1000, 10, 100, 0.10), (1000, 10, 5, 0.10), (1000, 10, 1, 0.0),
             ( 200, 3,   2, 0.50), ( 200, 10,  40, 0.10), ( 200, 10, 2, 0.10), ( 200, 10, 1, 0.0)]
 
 # Generate the code
 for (numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting) in dataSets:
     filename = "test-%d-%d-%d-%d.k" % (numFuncs, elementsPerFunc, funcsBetweenExec, int(callWeighting * 100))
     generateKScript(filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript)
-print "All done!"
+print("All done!")

llvm/trunk/test/BugPoint/compile-custom.ll.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import sys
 
 # Currently any print-out from the custom tool is interpreted as a crash
 # (i.e. test is still interesting)
 
 print("Error: " + ' '.join(sys.argv[1:]))
 
 sys.exit(1)

llvm/trunk/test/CodeGen/NVPTX/ld-st-addrrspace.py

 # This test generates all variants of load/store instructions and verifies that
 # LLVM generates correct PTX for them.
 
 # RUN: python %s > %t.ll
 # RUN: llc < %t.ll -march=nvptx64 -mcpu=sm_30 | FileCheck -check-prefixes=CHECK,CHECK_P64 %t.ll
 # RUN: llc < %t.ll -march=nvptx -mcpu=sm_30 | FileCheck -check-prefixes=CHECK,CHECK_P32 %t.ll
 
+from __future__ import print_function
+
 from itertools import product
 from string import Template
 
 llvm_type_to_ptx_type = {
     "i8": "u8",
     "i16": "u16",
     "i32": "u32",
     "i64": "u64",

llvm/trunk/test/CodeGen/NVPTX/wmma.py

 # This test generates all variants of wmma intrinsics and verifies that LLVM
 # generates correct instructions for them.
 
 # RUN: python %s > %t.ll
 # RUN: llc < %t.ll -march=nvptx64 -mcpu=sm_70 -mattr=+ptx61 | FileCheck %t.ll
 
+from __future__ import print_function
+
 from itertools import product
 from string import Template
 
 def make_wmma_slice_ty(abcd, itype):
   elt_ty = "<2 x half>" if itype == "f16" else "float"
   num_elts = 4 if abcd in "cd" and itype == "f16" else 8;
   return [elt_ty] * num_elts
 

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-01.py

 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 128(%r3)
 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 132(%r3)
 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 136(%r3)
 # CHECK: jge [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 10
 main_size = 0xffd8
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i32 *%stop, i32 %limit) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i32 *%stop, i32 %limit) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bstop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i)
-    print '  %%bcur%d = load i32 , i32 *%%bstop%d' % (i, i)
-    print '  %%btest%d = icmp eq i32 %%limit, %%bcur%d' % (i, i)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bstop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i))
+    print('  %%bcur%d = load i32 , i32 *%%bstop%d' % (i, i))
+    print('  %%btest%d = icmp eq i32 %%limit, %%bcur%d' % (i, i))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i + 25)
-    print '  %%acur%d = load i32 , i32 *%%astop%d' % (i, i)
-    print '  %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i + 25))
+    print('  %%acur%d = load i32 , i32 *%%astop%d' % (i, i))
+    print('  %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-02.py

 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 1028(%r3)
 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 1032(%r3)
 # CHECK: jge [[LABEL]]
 # CHECK: c %r4, 1036(%r3)
 # CHECK: jge [[LABEL]]
 
+from __future__ import print_function
+
 blocks = 256 + 4
 
-print 'define void @f1(i8 *%base, i32 *%stop, i32 %limit) {'
-print 'entry:'
-print '  br label %b0'
-print ''
+print('define void @f1(i8 *%base, i32 *%stop, i32 %limit) {')
+print('entry:')
+print('  br label %b0')
+print('')
 
 a, b = 1, 1
 for i in xrange(blocks):
     a, b = b, a + b
     value = a % 256
     next = 'b%d' % (i + 1) if i + 1 < blocks else 'end'
     other = 'end' if 2 * i < blocks else 'b0'
-    print 'b%d:' % i
-    print '  store volatile i8 %d, i8 *%%base' % value
-    print '  %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i)
-    print '  %%acur%d = load i32 , i32 *%%astop%d' % (i, i)
-    print '  %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i)
-    print '  br i1 %%atest%d, label %%%s, label %%%s' % (i, other, next)
-
-print ''
-print '%s:' % next
-print '  ret void'
-print '}'
+    print('b%d:' % i)
+    print('  store volatile i8 %d, i8 *%%base' % value)
+    print('  %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i))
+    print('  %%acur%d = load i32 , i32 *%%astop%d' % (i, i))
+    print('  %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i))
+    print('  br i1 %%atest%d, label %%%s, label %%%s' % (i, other, next))
+
+print('')
+print('%s:' % next)
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-03.py

 # CHECK: jge [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 31(%r3)
 # CHECK: cr %r4, [[REG]]
 # CHECK: jge [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 32(%r3)
 # CHECK: cr %r4, [[REG]]
 # CHECK: jge [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop, i32 %limit) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop, i32 %limit) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
-    print '  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
-    print '  %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
-    print '  %%btest%d = icmp eq i32 %%limit, %%bext%d' % (i, i)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i))
+    print('  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i))
+    print('  %%bext%d = sext i8 %%bcur%d to i32' % (i, i))
+    print('  %%btest%d = icmp eq i32 %%limit, %%bext%d' % (i, i))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
-    print '  %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
-    print '  %%aext%d = sext i8 %%acur%d to i32' % (i, i)
-    print '  %%atest%d = icmp eq i32 %%limit, %%aext%d' % (i, i)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25))
+    print('  %%acur%d = load i8 , i8 *%%astop%d' % (i, i))
+    print('  %%aext%d = sext i8 %%acur%d to i32' % (i, i))
+    print('  %%atest%d = icmp eq i32 %%limit, %%aext%d' % (i, i))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-04.py

 # CHECK: jge [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 31(%r3)
 # CHECK: cgr %r4, [[REG]]
 # CHECK: jge [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 32(%r3)
 # CHECK: cgr %r4, [[REG]]
 # CHECK: jge [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop, i64 %limit) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop, i64 %limit) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
-    print '  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
-    print '  %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
-    print '  %%btest%d = icmp eq i64 %%limit, %%bext%d' % (i, i)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i))
+    print('  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i))
+    print('  %%bext%d = sext i8 %%bcur%d to i64' % (i, i))
+    print('  %%btest%d = icmp eq i64 %%limit, %%bext%d' % (i, i))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
-    print '  %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
-    print '  %%aext%d = sext i8 %%acur%d to i64' % (i, i)
-    print '  %%atest%d = icmp eq i64 %%limit, %%aext%d' % (i, i)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25))
+    print('  %%acur%d = load i8 , i8 *%%astop%d' % (i, i))
+    print('  %%aext%d = sext i8 %%acur%d to i64' % (i, i))
+    print('  %%atest%d = icmp eq i64 %%limit, %%aext%d' % (i, i))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-05.py

 # CHECK: jgl [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 0(%r3)
 # CHECK: chi [[REG]], 106
 # CHECK: jgl [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 0(%r3)
 # CHECK: chi [[REG]], 107
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bcur%d = load i8 , i8 *%%stop' % i
-    print '  %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
-    print '  %%btest%d = icmp slt i32 %%bext%d, %d' % (i, i, i + 50)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bcur%d = load i8 , i8 *%%stop' % i)
+    print('  %%bext%d = sext i8 %%bcur%d to i32' % (i, i))
+    print('  %%btest%d = icmp slt i32 %%bext%d, %d' % (i, i, i + 50))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%acur%d = load i8 , i8 *%%stop' % i
-    print '  %%aext%d = sext i8 %%acur%d to i32' % (i, i)
-    print '  %%atest%d = icmp slt i32 %%aext%d, %d' % (i, i, i + 100)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%acur%d = load i8 , i8 *%%stop' % i)
+    print('  %%aext%d = sext i8 %%acur%d to i32' % (i, i))
+    print('  %%atest%d = icmp slt i32 %%aext%d, %d' % (i, i, i + 100))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-06.py

 # CHECK: jgl [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
 # CHECK: cghi [[REG]], 106
 # CHECK: jgl [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
 # CHECK: cghi [[REG]], 107
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bcur%d = load i8 , i8 *%%stop' % i
-    print '  %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
-    print '  %%btest%d = icmp slt i64 %%bext%d, %d' % (i, i, i + 50)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bcur%d = load i8 , i8 *%%stop' % i)
+    print('  %%bext%d = sext i8 %%bcur%d to i64' % (i, i))
+    print('  %%btest%d = icmp slt i64 %%bext%d, %d' % (i, i, i + 50))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%acur%d = load i8 , i8 *%%stop' % i
-    print '  %%aext%d = sext i8 %%acur%d to i64' % (i, i)
-    print '  %%atest%d = icmp slt i64 %%aext%d, %d' % (i, i, i + 100)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%acur%d = load i8 , i8 *%%stop' % i)
+    print('  %%aext%d = sext i8 %%acur%d to i64' % (i, i))
+    print('  %%atest%d = icmp slt i64 %%aext%d, %d' % (i, i, i + 100))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-07.py

 # CHECK: brct {{%r[0-9]+}}
 # CHECK: brct {{%r[0-9]+}}
 # CHECK: brct {{%r[0-9]+}}
 # CHECK: ahi {{%r[0-9]+}}, -1
 # CHECK: jglh
 # CHECK: ahi {{%r[0-9]+}}, -1
 # CHECK: jglh
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffd8
 
-print 'define void @f1(i8 *%base, i32 *%counts) {'
-print 'entry:'
+print('define void @f1(i8 *%base, i32 *%counts) {')
+print('entry:')
 
 for i in xrange(branch_blocks - 1, -1, -1):
-    print '  %%countptr%d = getelementptr i32, i32 *%%counts, i64 %d' % (i, i)
-    print '  %%initcount%d = load i32 , i32 *%%countptr%d' % (i, i)
-    print '  br label %%loop%d' % i
+    print('  %%countptr%d = getelementptr i32, i32 *%%counts, i64 %d' % (i, i))
+    print('  %%initcount%d = load i32 , i32 *%%countptr%d' % (i, i))
+    print('  br label %%loop%d' % i)
     
-    print 'loop%d:' % i
+    print('loop%d:' % i)
     block1 = 'entry' if i == branch_blocks - 1 else 'loop%d' % (i + 1)
     block2 = 'loop0' if i == 0 else 'after%d' % (i - 1)
-    print ('  %%count%d = phi i32 [ %%initcount%d, %%%s ],'
-           ' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2))
+    print(('  %%count%d = phi i32 [ %%initcount%d, %%%s ],'
+           ' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2)))
 
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%nextcount%d = add i32 %%count%d, -1' % (i, i)
-    print '  %%test%d = icmp ne i32 %%nextcount%d, 0' % (i, i)
-    print '  br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i)
-    print ''
-    print 'after%d:' % i
+    print('  %%nextcount%d = add i32 %%count%d, -1' % (i, i))
+    print('  %%test%d = icmp ne i32 %%nextcount%d, 0' % (i, i))
+    print('  br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i))
+    print('')
+    print('after%d:' % i)
 
-print '  ret void'
-print '}'
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-08.py

 # CHECK: brctg {{%r[0-9]+}}
 # CHECK: aghi {{%r[0-9]+}}, -1
 # CHECK: jglh
 # CHECK: aghi {{%r[0-9]+}}, -1
 # CHECK: jglh
 # CHECK: aghi {{%r[0-9]+}}, -1
 # CHECK: jglh
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffd8
 
-print 'define void @f1(i8 *%base, i64 *%counts) {'
-print 'entry:'
+print('define void @f1(i8 *%base, i64 *%counts) {')
+print('entry:')
 
 for i in xrange(branch_blocks - 1, -1, -1):
-    print '  %%countptr%d = getelementptr i64, i64 *%%counts, i64 %d' % (i, i)
-    print '  %%initcount%d = load i64 , i64 *%%countptr%d' % (i, i)
-    print '  br label %%loop%d' % i
+    print('  %%countptr%d = getelementptr i64, i64 *%%counts, i64 %d' % (i, i))
+    print('  %%initcount%d = load i64 , i64 *%%countptr%d' % (i, i))
+    print('  br label %%loop%d' % i)
     
-    print 'loop%d:' % i
+    print('loop%d:' % i)
     block1 = 'entry' if i == branch_blocks - 1 else 'loop%d' % (i + 1)
     block2 = 'loop0' if i == 0 else 'after%d' % (i - 1)
-    print ('  %%count%d = phi i64 [ %%initcount%d, %%%s ],'
-           ' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2))
+    print(('  %%count%d = phi i64 [ %%initcount%d, %%%s ],'
+           ' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2)))
 
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%nextcount%d = add i64 %%count%d, -1' % (i, i)
-    print '  %%test%d = icmp ne i64 %%nextcount%d, 0' % (i, i)
-    print '  br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i)
-    print ''
-    print 'after%d:' % i
+    print('  %%nextcount%d = add i64 %%count%d, -1' % (i, i))
+    print('  %%test%d = icmp ne i64 %%nextcount%d, 0' % (i, i))
+    print('  br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i))
+    print('')
+    print('after%d:' % i)
 
-print '  ret void'
-print '}'
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-09.py

 # CHECK: jgl [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 31(%r3)
 # CHECK: clr %r4, [[REG]]
 # CHECK: jgl [[LABEL]]
 # CHECK: lb [[REG:%r[0-5]]], 32(%r3)
 # CHECK: clr %r4, [[REG]]
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop, i32 %limit) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop, i32 %limit) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
-    print '  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
-    print '  %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
-    print '  %%btest%d = icmp ult i32 %%limit, %%bext%d' % (i, i)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i))
+    print('  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i))
+    print('  %%bext%d = sext i8 %%bcur%d to i32' % (i, i))
+    print('  %%btest%d = icmp ult i32 %%limit, %%bext%d' % (i, i))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
-    print '  %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
-    print '  %%aext%d = sext i8 %%acur%d to i32' % (i, i)
-    print '  %%atest%d = icmp ult i32 %%limit, %%aext%d' % (i, i)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25))
+    print('  %%acur%d = load i8 , i8 *%%astop%d' % (i, i))
+    print('  %%aext%d = sext i8 %%acur%d to i32' % (i, i))
+    print('  %%atest%d = icmp ult i32 %%limit, %%aext%d' % (i, i))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-10.py

 # CHECK: jgl [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 31(%r3)
 # CHECK: clgr %r4, [[REG]]
 # CHECK: jgl [[LABEL]]
 # CHECK: lgb [[REG:%r[0-5]]], 32(%r3)
 # CHECK: clgr %r4, [[REG]]
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffcc
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i8 *%stop, i64 %limit) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i8 *%stop, i64 %limit) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
-    print '  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
-    print '  %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
-    print '  %%btest%d = icmp ult i64 %%limit, %%bext%d' % (i, i)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i))
+    print('  %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i))
+    print('  %%bext%d = sext i8 %%bcur%d to i64' % (i, i))
+    print('  %%btest%d = icmp ult i64 %%limit, %%bext%d' % (i, i))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
-    print '  %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
-    print '  %%aext%d = sext i8 %%acur%d to i64' % (i, i)
-    print '  %%atest%d = icmp ult i64 %%limit, %%aext%d' % (i, i)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25))
+    print('  %%acur%d = load i8 , i8 *%%astop%d' % (i, i))
+    print('  %%aext%d = sext i8 %%acur%d to i64' % (i, i))
+    print('  %%atest%d = icmp ult i64 %%limit, %%aext%d' % (i, i))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-11.py

 # CHECK: s [[REG]], 0(%r4)
 # CHECK: clfi [[REG]], 106
 # CHECK: jgl [[LABEL]]
 # CHECK: l [[REG:%r[0-5]]], 0(%r3)
 # CHECK: s [[REG]], 0(%r4)
 # CHECK: clfi [[REG]], 107
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffc6
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i32 *%stopa, i32 *%stopb) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i32 *%stopa, i32 *%stopb) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bcur%da = load i32 , i32 *%%stopa' % i
-    print '  %%bcur%db = load i32 , i32 *%%stopb' % i
-    print '  %%bsub%d = sub i32 %%bcur%da, %%bcur%db' % (i, i, i)
-    print '  %%btest%d = icmp ult i32 %%bsub%d, %d' % (i, i, i + 50)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bcur%da = load i32 , i32 *%%stopa' % i)
+    print('  %%bcur%db = load i32 , i32 *%%stopb' % i)
+    print('  %%bsub%d = sub i32 %%bcur%da, %%bcur%db' % (i, i, i))
+    print('  %%btest%d = icmp ult i32 %%bsub%d, %d' % (i, i, i + 50))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%acur%da = load i32 , i32 *%%stopa' % i
-    print '  %%acur%db = load i32 , i32 *%%stopb' % i
-    print '  %%asub%d = sub i32 %%acur%da, %%acur%db' % (i, i, i)
-    print '  %%atest%d = icmp ult i32 %%asub%d, %d' % (i, i, i + 100)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%acur%da = load i32 , i32 *%%stopa' % i)
+    print('  %%acur%db = load i32 , i32 *%%stopb' % i)
+    print('  %%asub%d = sub i32 %%acur%da, %%acur%db' % (i, i, i))
+    print('  %%atest%d = icmp ult i32 %%asub%d, %d' % (i, i, i + 100))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/branch-range-12.py

 # CHECK: sg [[REG]], 0(%r4)
 # CHECK: clgfi [[REG]], 106
 # CHECK: jgl [[LABEL]]
 # CHECK: lg [[REG:%r[0-5]]], 0(%r3)
 # CHECK: sg [[REG]], 0(%r4)
 # CHECK: clgfi [[REG]], 107
 # CHECK: jgl [[LABEL]]
 
+from __future__ import print_function
+
 branch_blocks = 8
 main_size = 0xffb4
 
-print '@global = global i32 0'
+print('@global = global i32 0')
 
-print 'define void @f1(i8 *%base, i64 *%stopa, i64 *%stopb) {'
-print 'entry:'
-print '  br label %before0'
-print ''
+print('define void @f1(i8 *%base, i64 *%stopa, i64 *%stopb) {')
+print('entry:')
+print('  br label %before0')
+print('')
 
 for i in xrange(branch_blocks):
     next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
-    print 'before%d:' % i
-    print '  %%bcur%da = load i64 , i64 *%%stopa' % i
-    print '  %%bcur%db = load i64 , i64 *%%stopb' % i
-    print '  %%bsub%d = sub i64 %%bcur%da, %%bcur%db' % (i, i, i)
-    print '  %%btest%d = icmp ult i64 %%bsub%d, %d' % (i, i, i + 50)
-    print '  br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
-    print ''
+    print('before%d:' % i)
+    print('  %%bcur%da = load i64 , i64 *%%stopa' % i)
+    print('  %%bcur%db = load i64 , i64 *%%stopb' % i)
+    print('  %%bsub%d = sub i64 %%bcur%da, %%bcur%db' % (i, i, i))
+    print('  %%btest%d = icmp ult i64 %%bsub%d, %d' % (i, i, i + 50))
+    print('  br i1 %%btest%d, label %%after0, label %%%s' % (i, next))
+    print('')
 
-print '%s:' % next
+print('%s:' % next)
 a, b = 1, 1
 for i in xrange(0, main_size, 6):
     a, b = b, a + b
     offset = 4096 + b % 500000
     value = a % 256
-    print '  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
-    print '  store volatile i8 %d, i8 *%%ptr%d' % (value, i)
+    print('  %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset))
+    print('  store volatile i8 %d, i8 *%%ptr%d' % (value, i))
 
 for i in xrange(branch_blocks):
-    print '  %%acur%da = load i64 , i64 *%%stopa' % i
-    print '  %%acur%db = load i64 , i64 *%%stopb' % i
-    print '  %%asub%d = sub i64 %%acur%da, %%acur%db' % (i, i, i)
-    print '  %%atest%d = icmp ult i64 %%asub%d, %d' % (i, i, i + 100)
-    print '  br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
-    print ''
-    print 'after%d:' % i
-
-print '  %dummy = load volatile i32, i32 *@global'
-print '  ret void'
-print '}'
+    print('  %%acur%da = load i64 , i64 *%%stopa' % i)
+    print('  %%acur%db = load i64 , i64 *%%stopb' % i)
+    print('  %%asub%d = sub i64 %%acur%da, %%acur%db' % (i, i, i))
+    print('  %%atest%d = icmp ult i64 %%asub%d, %d' % (i, i, i + 100))
+    print('  br i1 %%atest%d, label %%main, label %%after%d' % (i, i))
+    print('')
+    print('after%d:' % i)
+
+print('  %dummy = load volatile i32, i32 *@global')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/spill-01.py

 #
 # CHECK: f1:
 # CHECK: lay [[REG:%r[0-5]]], 4096(%r15)
 # CHECK: mvc 0(8,[[REG]]), {{[0-9]+}}({{%r[0-9]+}})
 # CHECK: brasl %r14, foo@PLT
 # CHECK: lay [[REG:%r[0-5]]], 4096(%r15)
 # CHECK: mvc {{[0-9]+}}(8,{{%r[0-9]+}}), 8([[REG]])
 # CHECK: br %r14
+
+from __future__ import print_function
+
 count = 500
 
-print 'declare void @foo()'
-print ''
-print 'define void @f1(i64 *%base0, i64 *%base1) {'
+print('declare void @foo()')
+print('')
+print('define void @f1(i64 *%base0, i64 *%base1) {')
 
 for i in range(count):
-    print '  %%ptr%d = getelementptr i64, i64 *%%base%d, i64 %d' % (i, i % 2, i / 2)
-    print '  %%val%d = load i64 , i64 *%%ptr%d' % (i, i)
-    print ''
+    print('  %%ptr%d = getelementptr i64, i64 *%%base%d, i64 %d' % (i, i % 2, i / 2))
+    print('  %%val%d = load i64 , i64 *%%ptr%d' % (i, i))
+    print('')
 
-print '  call void @foo()'
-print ''
+print('  call void @foo()')
+print('')
 
 for i in range(count):
-    print '  store i64 %%val%d, i64 *%%ptr%d' % (i, i)
+    print('  store i64 %%val%d, i64 *%%ptr%d' % (i, i))
 
-print ''
-print '  ret void'
-print '}'
+print('')
+print('  ret void')
+print('}')

llvm/trunk/test/CodeGen/SystemZ/Large/spill-02.py

 # CHECK: %skip
 # CHECK: br %r14
 
 # Arrange for %foo's spill slot to be at 8184(%r15) and the alloca area to be at
 # 8192(%r15).  The two emergency spill slots live below that, so this requires
 # the first 8168 bytes to be used for the call.  160 of these bytes are
 # allocated for the ABI frame.  There are also 5 argument registers, one of
 # which is used as a base pointer.
+
+from __future__ import print_function
+
 args = (8168 - 160) / 8 + (5 - 1)
 
-print 'declare i64 *@foo(i64 *%s)' % (', i64' * args)
-print 'declare void @bar(i64 *)'
-print ''
-print 'define i64 @f1(i64 %foo) {'
-print 'entry:'
+print('declare i64 *@foo(i64 *%s)' % (', i64' * args))
+print('declare void @bar(i64 *)')
+print('')
+print('define i64 @f1(i64 %foo) {')
+print('entry:')
 
 # Make the allocation big, so that it goes at the top of the frame.
-print '  %array = alloca [1000 x i64]'
-print '  %area = getelementptr [1000 x i64], [1000 x i64] *%array, i64 0, i64 0'
-print '  %%base = call i64 *@foo(i64 *%%area%s)' % (', i64 0' * args)
-print ''
+print('  %array = alloca [1000 x i64]')
+print('  %area = getelementptr [1000 x i64], [1000 x i64] *%array, i64 0, i64 0')
+print('  %%base = call i64 *@foo(i64 *%%area%s)' % (', i64 0' * args))
+print('')
 
 # Make sure all GPRs are used.  One is needed for the stack pointer and
 # another for %base, so we need 14 live values.
 count = 14
 for i in range(count):
-    print '  %%ptr%d = getelementptr i64, i64 *%%base, i64 %d' % (i, i / 2)
-    print '  %%val%d = load volatile i64 , i64 *%%ptr%d' % (i, i)
-    print ''
+    print('  %%ptr%d = getelementptr i64, i64 *%%base, i64 %d' % (i, i / 2))
+    print('  %%val%d = load volatile i64 , i64 *%%ptr%d' % (i, i))
+    print('')
 
 # Encourage the register allocator to give preference to these %vals
 # by using them several times.
 for j in range(4):
     for i in range(count):
-        print '  store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i)
-    print ''
+        print('  store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i))
+    print('')
 
 # Copy the incoming argument, which we expect to be spilled, to the frame
 # index for the alloca area.  Also throw in a volatile store, so that this
 # block cannot be reordered with the surrounding code.
-print '  %cond = icmp eq i64 %val0, %val1'
-print '  br i1 %cond, label %skip, label %fallthru'
-print ''
-print 'fallthru:'
-print '  store i64 %foo, i64 *%area'
-print '  store volatile i64 %val0, i64 *%ptr0'
-print '  br label %skip'
-print ''
-print 'skip:'
+print('  %cond = icmp eq i64 %val0, %val1')
+print('  br i1 %cond, label %skip, label %fallthru')
+print('')
+print('fallthru:')
+print('  store i64 %foo, i64 *%area')
+print('  store volatile i64 %val0, i64 *%ptr0')
+print('  br label %skip')
+print('')
+print('skip:')
 
 # Use each %val a few more times to emphasise the point, and to make sure
 # that they are live across the store of %foo.
 for j in range(4):
     for i in range(count):
-        print '  store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i)
-    print ''
+        print('  store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i))
+    print('')
 
-print '  call void @bar(i64 *%area)'
-print '  ret i64 0'
-print '}'
+print('  call void @bar(i64 *%area)')
+print('  ret i64 0')
+print('}')

llvm/trunk/test/MC/COFF/bigobj.py

 # RUN: python %s | llvm-mc -filetype=obj -triple i686-pc-win32 - | llvm-readobj -h | FileCheck %s
 
+from __future__ import print_function
+
 # This test checks that the COFF object emitter can produce objects with
 # more than 65279 sections.
 
 # While we only generate 65277 sections, an implicit .text, .data and .bss will
 # also be emitted.  This brings the total to 65280.
 num_sections = 65277
 
 # CHECK:      ImageFileHeader {

llvm/trunk/test/Other/opt-bisect-helper.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import os
 import sys
 import argparse
 import subprocess
 
 parser = argparse.ArgumentParser()
 
 parser.add_argument('--start', type=int, default=0)

llvm/trunk/test/tools/llvm-readobj/Inputs/relocs.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 # Generates ELF, COFF and MachO object files for different architectures
 # containing all relocations:
 #
 # ELF:   i386, x86_64, ppc64, aarch64, arm, mips, mips64el
 # COFF:  i386, x86_64
 # MachO: i386, x86_64, arm
 # (see end of file for triples)
 #

llvm/trunk/tools/sancov/coverage-report-server.py

./tools/sancov/symcov-report-server.py \
             --symcov coverage_data.symcov \
             --srcpath root_src_dir
 
 Other options:
     --port port_number - specifies the port to use (8001)
     --host host_name - host name to bind server to (127.0.0.1)
 '''
 
+from __future__ import print_function
+
 import argparse
 import http.server
 import json
 import socketserver
 import time
 import html
 import os
 import string

llvm/trunk/utils/DSAclean.py

 #! /usr/bin/python
 
 #changelog: 
 #10/13/2005b: replaced the # in tmp(.#*)* with alphanumeric and _, this will then remove
 #nodes such as %tmp.1.i and %tmp._i.3
 #10/13/2005: exntended to remove variables of the form %tmp(.#)* rather than just 
 #%tmp.#, i.e. it now will remove %tmp.12.3.15 etc, additionally fixed a spelling error in
 #the comments
 #10/12/2005: now it only removes nodes and edges for which the label is %tmp.# rather
 #than removing all lines for which the lable CONTAINS %tmp.#
+
+from __future__ import print_function
+
 import re
 import sys
 if( len(sys.argv) < 3 ):
-  print 'usage is: ./DSAclean <dot_file_to_be_cleaned> <out_put_file>'
+  print('usage is: ./DSAclean <dot_file_to_be_cleaned> <out_put_file>')
   sys.exit(1)
 #get a file object
 input = open(sys.argv[1], 'r')
 output = open(sys.argv[2], 'w')
 #we'll get this one line at a time...while we could just put the whole thing in a string
 #it would kill old computers
 buffer = input.readline()
 while buffer != '':

llvm/trunk/utils/DSAextract.py

 
 #Specifying escape characters in the name like \n also will not work, 
 #as Python
 #will make it \\n, I'm not really sure how to fix this
 
 #currently the script prints the names it is searching for
 #to STDOUT, so you can check to see if they are what you intend
 
+from __future__ import print_function
+
 import re
 import string
 import sys
 
 
 if len(sys.argv) < 3:
-  print 'usage is ./DSAextract <dot_file_to_modify> \
-      <output_file> [list of nodes to extract]'
+  print('usage is ./DSAextract <dot_file_to_modify> \
+      <output_file> [list of nodes to extract]')
 
 #open the input file
 input = open(sys.argv[1], 'r')
 
 #construct a set of node names
 node_name_set = set()
 for name in sys.argv[3:]:
   node_name_set |= set([name])
for regexp in regexp_list:
         node_set |= set([re.split('\s+',buffer,2)[1]])
         break
   buffer = input.readline()
 
 
 #test code
 #print '\n'
 
-print node_name_set
+print(node_name_set)
 
 #print node_set
   
 
 #open the output file
 output = open(sys.argv[2], 'w')
 #start the second pass over the file
 input = open(sys.argv[1], 'r')

llvm/trunk/utils/Reviewing/find_interesting_reviews.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import argparse
 import email.mime.multipart
 import email.mime.text
 import logging
 import os.path
 import pickle
 import re
 import smtplib

llvm/trunk/utils/Target/ARM/analyze-match-table.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 def analyze_match_table(path):
     # Extract the instruction table.
     data = open(path).read()
     start = data.index("static const MatchEntry MatchTable")
     end = data.index("\n};\n", start)
     lines = data[start:end].split("\n")[1:]
 
     # Parse the instructions.
for insn in insns:
         flags.update(items)
 
     mnemonics = set(mnemonic_flags)
     ccout_mnemonics = set(m for m in mnemonics
                           if 'MCK_CCOut' in mnemonic_flags[m])
     condcode_mnemonics = set(m for m in mnemonics
                              if 'MCK_CondCode' in mnemonic_flags[m])
     noncondcode_mnemonics = mnemonics - condcode_mnemonics
-    print ' || '.join('Mnemonic == "%s"' % m
-                      for m in ccout_mnemonics)
-    print ' || '.join('Mnemonic == "%s"' % m
-                      for m in noncondcode_mnemonics)
+    print(' || '.join('Mnemonic == "%s"' % m
+                      for m in ccout_mnemonics))
+    print(' || '.join('Mnemonic == "%s"' % m
+                      for m in noncondcode_mnemonics))
 
 def main():
     import sys
     if len(sys.argv) == 1:
         import os
         from lit.Util import capture
         llvm_obj_root = capture(["llvm-config", "--obj-root"])
         file = os.path.join(llvm_obj_root,

llvm/trunk/utils/create_ladder_graph.py

 #!/usr/bin/env python
 """A ladder graph creation program.
 
 This is a python program that creates c source code that will generate
 CFGs that are ladder graphs.  Ladder graphs are generally the worst case
 for a lot of dominance related algorithms (Dominance frontiers, etc),
 and often generate N^2 or worse behavior.
 
 One good use of this program is to test whether your linear time algorithm is
 really behaving linearly.
 """
 
+from __future__ import print_function
+
 import argparse
 def main():
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('rungs', type=int,
                       help="Number of ladder rungs. Must be a multiple of 2")
   args = parser.parse_args()
   if (args.rungs % 2) != 0:
-    print "Rungs must be a multiple of 2"
+    print("Rungs must be a multiple of 2")
     return
-  print "int ladder(int *foo, int *bar, int x) {"
+  print("int ladder(int *foo, int *bar, int x) {")
   rung1 = xrange(0, args.rungs, 2)
   rung2 = xrange(1, args.rungs, 2)
   for i in rung1:
-    print "rung1%d:" % i
-    print "*foo = x++;"
+    print("rung1%d:" % i)
+    print("*foo = x++;")
     if i != rung1[-1]:
-      print "if (*bar) goto rung1%d;" % (i+2)
-      print "else goto rung2%d;" % (i+1)
+      print("if (*bar) goto rung1%d;" % (i+2))
+      print("else goto rung2%d;" % (i+1))
     else:
-      print "goto rung2%d;" % (i+1)
+      print("goto rung2%d;" % (i+1))
   for i in rung2:
-    print "rung2%d:" % i
-    print "*foo = x++;"
+    print("rung2%d:" % i)
+    print("*foo = x++;")
     if i != rung2[-1]:
-      print "goto rung2%d;" % (i+2)
+      print("goto rung2%d;" % (i+2))
     else:
-      print "return *foo;"
-  print "}"
+      print("return *foo;")
+  print("}")
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/demangle_tree.py

 # Given a path to llvm-objdump and a directory tree, spider the directory tree
 # dumping every object file encountered with correct options needed to demangle
 # symbols in the object file, and collect statistics about failed / crashed
 # demanglings.  Useful for stress testing the demangler against a large corpus
 # of inputs.
 
+from __future__ import print_function
+
 import argparse
 import functools
 import os
 import re
 import sys
 import subprocess
 import traceback
 from multiprocessing import Pool

llvm/trunk/utils/extract_vplan.py

 #!/usr/bin/env python
 
 # This script extracts the VPlan digraphs from the vectoriser debug messages
 # and saves them in individual dot files (one for each plan). Optionally, and
 # providing 'dot' is installed, it can also render the dot into a PNG file.
 
+from __future__ import print_function
+
 import sys
 import re
 import argparse
 import shutil
 import subprocess
 
 parser = argparse.ArgumentParser()
 parser.add_argument('--png', action='store_true')

llvm/trunk/utils/gdb-scripts/prettyprinters.py

+from __future__ import print_function
+
 import gdb.printing
 
 class Iterator:
   def __iter__(self):
     return self
 
   # Python 2 compatibility
   def next(self):

llvm/trunk/utils/indirect_calls.py

 #!/usr/bin/env python
 
 """A tool for looking for indirect jumps and calls in x86 binaries.
 
    Helpful to verify whether or not retpoline mitigations are catching
    all of the indirect branches in a binary and telling you which
    functions the remaining ones are in (assembly, etc).
 
    Depends on llvm-objdump being in your path and is tied to the
    dump format.
 """
 
+from __future__ import print_function
+
 import os
 import sys
 import re
 import subprocess
 import optparse
 
 # Look for indirect calls/jmps in a binary. re: (call|jmp).*\* 
 def look_for_indirect(file):
     args = ['llvm-objdump']
     args.extend(["-d"])
     args.extend([file])
 
     p = subprocess.Popen(args=args, stdin=None, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
     (stdout,stderr) = p.communicate()
 
     function = ""
     for line in stdout.splitlines():
         if line.startswith(' ') == False:
             function = line
         result = re.search('(call|jmp).*\*', line)
         if result != None:
             # TODO: Perhaps use cxxfilt to demangle functions?
-            print function
-            print line
+            print(function)
+            print(line)
     return
 
 def main(args):
     # No options currently other than the binary.
     parser = optparse.OptionParser("%prog [options] <binary>")
     (opts, args) = parser.parse_args(args)
     if len(args) != 2:
         parser.error("invalid number of arguments: %s" % len(args))
     look_for_indirect(args[1])
 
 if __name__ == '__main__':
     main(sys.argv)

llvm/trunk/utils/lint/common_lint.py

 #!/usr/bin/python
 #
 # Common lint functions applicable to multiple types of files.
 
+from __future__ import print_function
 import re
 
 def VerifyLineLength(filename, lines, max_length):
   """Checks to make sure the file has no lines with lines exceeding the length
   limit.
 
   Args:
     filename: the file under consideration as string
def RunLintOverAllFiles(linter, filenames):
   Returns:
     A list of tuples with format [(filename, line number, msg), ...] with any
     violations found.
   """
   lint = []
   for filename in filenames:
     file = open(filename, 'r')
     if not file:
-      print 'Cound not open %s' % filename
+      print('Cound not open %s' % filename)
       continue
     lines = file.readlines()
     lint.extend(linter.RunOnFile(filename, lines))
 
   return lint

llvm/trunk/utils/lint/cpp_lint.py

 #!/usr/bin/python
 #
 # Checks C++ files to make sure they conform to LLVM standards, as specified in
 # http://llvm.org/docs/CodingStandards.html .
 #
 # TODO: add unittests for the verifier functions:
 # http://docs.python.org/library/unittest.html .
 
+from __future__ import print_function
 import common_lint
 import re
 import sys
 
 def VerifyIncludes(filename, lines):
   """Makes sure the #includes are in proper order and no disallows files are
   #included.
 
def RunOnFile(self, filename, lines):
     lint.extend(common_lint.VerifyTabs(filename, lines))
     lint.extend(common_lint.VerifyTrailingWhitespace(filename, lines))
     return lint
 
 
 def CppLintMain(filenames):
   all_lint = common_lint.RunLintOverAllFiles(CppLint(), filenames)
   for lint in all_lint:
-    print '%s:%d:%s' % (lint[0], lint[1], lint[2])
+    print('%s:%d:%s' % (lint[0], lint[1], lint[2]))
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(CppLintMain(sys.argv[1:]))

llvm/trunk/utils/lit/lit/util.py

+from __future__ import print_function
+
 import errno
 import itertools
 import math
 import numbers
 import os
 import platform
 import signal
 import subprocess

llvm/trunk/utils/lit/tests/Inputs/shtest-env/print_environment.py

 #!/usr/bin/env python
 
+from __future__ import print_statement
 import os
 
 sorted_environment = sorted(os.environ.items())
 
 for name,value in sorted_environment:
-    print name,'=',value
+    print(name,'=',value)

llvm/trunk/utils/lit/tests/Inputs/shtest-shell/check_path.py

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 import os
 import sys
 
 
 def check_path(argv):
     if len(argv) < 3:
         print("Wrong number of args")
         return 1

llvm/trunk/utils/llvm-build/llvmbuild/componentinfo.py

 """
 Descriptor objects for entities that are part of the LLVM project.
 """
 
-from __future__ import absolute_import
+from __future__ import absolute_import, print_function
 try:
     import configparser
 except:
     import ConfigParser as configparser
 import sys
 
 from llvmbuild.util import fatal, warning
 
for section in parser.sections():
             fatal("invalid component %r in %r: %s" % (
                     section, path, "invalid component type: %r" % type_name))
 
         # Instantiate the component based on the remaining values.
         try:
             info = type_class.parse(subpath,
                                     IniFormatParser(parser.items(section)))
         except TypeError:
-            print >>sys.stderr, "error: invalid component %r in %r: %s" % (
-                section, path, "unable to instantiate: %r" % type_name)
+            print("error: invalid component %r in %r: %s" % (
+                section, path, "unable to instantiate: %r" % type_name), file=sys.stderr)
             import traceback
             traceback.print_exc()
             raise SystemExit(1)
         except ParseError:
             e = sys.exc_info()[1]
             fatal("unable to load component %r in %r: %s" % (
                     section, path, e.message))
 
         info._source_path = path
         yield info

llvm/trunk/utils/llvm-gisel-cov.py

 #!/usr/bin/env python
 """
 Summarize the information in the given coverage files.
 
 Emits the number of rules covered or the percentage of rules covered depending
 on whether --num-rules has been used to specify the total number of rules.
 """
+from __future__ import print_function
 
 import argparse
 import struct
 
 class FileFormatError(Exception):
   pass
 
 def backend_int_pair(s):
with open(input_filename, 'rb') as input_fh:
           if rule_id == (2 ** 64) - 1:
             break
           covered_rules[backend] = covered_rules.get(backend, {})
           covered_rules[backend][rule_id] = covered_rules[backend].get(rule_id, 0) + 1
 
   num_rules = dict(args.num_rules)
   for backend, rules_for_backend in covered_rules.items():
     if backend in num_rules:
-      print "%s: %3.2f%% of rules covered" % (backend, (float(len(rules_for_backend.keys())) / num_rules[backend]) * 100)
+      print("%s: %3.2f%% of rules covered" % (backend, float(len(rules_for_backend)) / num_rules[backend]) * 100))
     else:
-      print "%s: %d rules covered" % (backend, len(rules_for_backend.keys()))
+      print("%s: %d rules covered" % (backend, len(rules_for_backend)))
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/release/findRegressions-nightly.py

 #!/usr/bin/env python
+from __future__ import print_function
+
 import re, string, sys, os, time
 
 DEBUG = 0
 testDirName = 'llvm-test'
 test      = ['compile', 'llc', 'jit', 'cbe']
 exectime     = ['llc-time', 'jit-time', 'cbe-time',]
 comptime     = ['llc', 'jit-comptime', 'compile']
 
 (tp, exp) = ('compileTime_', 'executeTime_')
 
 def parse(file):
   f=open(file, 'r')
   d = f.read()
   
   #Cleanup weird stuff
   d = re.sub(r',\d+:\d','', d)
    
   r = re.findall(r'TEST-(PASS|FAIL|RESULT.*?):\s+(.*?)\s+(.*?)\r*\n', d)
    
   test = {}
   fname = ''
   for t in r:
     if DEBUG:
-      print t
+      print(t)
     if t[0] == 'PASS' or t[0] == 'FAIL' :
       tmp = t[2].split(testDirName)
       
       if DEBUG:
-        print tmp
+        print(tmp)
       
       if len(tmp) == 2:
         fname = tmp[1].strip('\r\n')
       else:
         fname = tmp[0].strip('\r\n')
       
       if not test.has_key(fname) :
         test[fname] = {}
       
       for k in test:
         test[fname][k] = 'NA'
         test[fname][t[1]] = t[0]
         if DEBUG:
-          print test[fname][t[1]]
+          print(test[fname][t[1]])
     else :
       try:
         n = t[0].split('RESULT-')[1]
         
         if DEBUG:
-          print n;
+          print(n);
         
         if n == 'llc' or n == 'jit-comptime' or n == 'compile':
           test[fname][tp + n] = float(t[2].split(' ')[2])
           if DEBUG:
-            print test[fname][tp + n]
+            print(test[fname][tp + n])
         
         elif n.endswith('-time') :
             test[fname][exp + n] = float(t[2].strip('\r\n'))
             if DEBUG:
-              print test[fname][exp + n]
+              print(test[fname][exp + n])
         
         else :
-          print "ERROR!"
+          print("ERROR!")
           sys.exit(1)
       
       except:
           continue
 
   return test
 
 # Diff results and look for regressions.
 def diffResults(d_old, d_new):
 
   for t in sorted(d_old.keys()) :
     if DEBUG:
-      print t
+      print(t)
         
     if d_new.has_key(t) :
     
       # Check if the test passed or failed.
       for x in test:
         if d_old[t].has_key(x):
           if d_new[t].has_key(x):
             if d_old[t][x] == 'PASS':
               if d_new[t][x] != 'PASS':
-                print t + " *** REGRESSION (" + x + ")\n"
+                print(t + " *** REGRESSION (" + x + ")\n")
             else:
               if d_new[t][x] == 'PASS':
-                print t + " * NEW PASS (" + x + ")\n"
+                print(t + " * NEW PASS (" + x + ")\n")
                 
           else :
-            print t + "*** REGRESSION (" + x + ")\n"
+            print(t + "*** REGRESSION (" + x + ")\n")
         
         # For execution time, if there is no result, its a fail.
         for x in exectime:
           if d_old[t].has_key(tp + x):
             if not d_new[t].has_key(tp + x):
-              print t + " *** REGRESSION (" + tp + x + ")\n"
+              print(t + " *** REGRESSION (" + tp + x + ")\n")
                 
           else :
             if d_new[t].has_key(tp + x):
-              print t + " * NEW PASS (" + tp + x + ")\n"
+              print(t + " * NEW PASS (" + tp + x + ")\n")
 
        
         for x in comptime:
           if d_old[t].has_key(exp + x):
             if not d_new[t].has_key(exp + x):
-              print t + " *** REGRESSION (" + exp + x + ")\n"
+              print(t + " *** REGRESSION (" + exp + x + ")\n")
                 
           else :
             if d_new[t].has_key(exp + x):
-              print t + " * NEW PASS (" + exp + x + ")\n"
+              print(t + " * NEW PASS (" + exp + x + ")\n")
               
     else :
-      print t + ": Removed from test-suite.\n"
+      print(t + ": Removed from test-suite.\n")
     
 
 #Main
 if len(sys.argv) < 3 :
-    print 'Usage:', sys.argv[0], \
-          '<old log> <new log>'
+    print('Usage:', sys.argv[0], \
+          '<old log> <new log>')
     sys.exit(-1)
 
 d_old = parse(sys.argv[1])
 d_new = parse(sys.argv[2])
 
 
 diffResults(d_old, d_new)
 
 

llvm/trunk/utils/release/findRegressions-simple.py

 #!/usr/bin/env python
+
+from __future__ import print_function
 import re, string, sys, os, time, math
 
 DEBUG = 0
 
 (tp, exp) = ('compile', 'exec')
 
 def parse(file):
   f = open(file, 'r')
   d = f.read()
   
   # Cleanup weird stuff
   d = re.sub(r',\d+:\d', '', d)
 
   r = re.findall(r'TEST-(PASS|FAIL|RESULT.*?):\s+(.*?)\s+(.*?)\r*\n', d)
 
   test = {}
   fname = ''
   for t in r:
     if DEBUG:
-      print t
+      print(t)
 
     if t[0] == 'PASS' or t[0] == 'FAIL' :
       tmp = t[2].split('llvm-test/')
       
       if DEBUG:
-        print tmp
+        print(tmp)
 
       if len(tmp) == 2:
         fname = tmp[1].strip('\r\n')
       else:
         fname = tmp[0].strip('\r\n')
 
       if not test.has_key(fname):
         test[fname] = {}
 
       test[fname][t[1] + ' state'] = t[0]
       test[fname][t[1] + ' time'] = float('nan')
     else :
       try:
         n = t[0].split('RESULT-')[1]
 
         if DEBUG:
-          print "n == ", n;
+          print("n == ", n);
         
         if n == 'compile-success':
           test[fname]['compile time'] = float(t[2].split('program')[1].strip('\r\n'))
 
         elif n == 'exec-success':
           test[fname]['exec time'] = float(t[2].split('program')[1].strip('\r\n'))
           if DEBUG:
-            print test[fname][string.replace(n, '-success', '')]
+            print(test[fname][string.replace(n, '-success', '')])
 
         else :
           # print "ERROR!"
           sys.exit(1)
 
       except:
           continue
 
if d_new.has_key(t):
         if d_new[t][x] > d_old[t][x] and d_old[t][x] > 0.0 and \
               (d_new[t][x] - d_old[t][x]) / d_old[t][x] > .05:
           regressions[x] += t + ": " + "{0:.1f}".format(100 * (d_new[t][x] - d_old[t][x]) / d_old[t][x]) + "%\n"
 
     else :
       removed += t + "\n"
 
   if len(regressions['compile state']) != 0:
-    print 'REGRESSION: Compilation Failed'
-    print regressions['compile state']
+    print('REGRESSION: Compilation Failed')
+    print(regressions['compile state'])
 
   if len(regressions['exec state']) != 0:
-    print 'REGRESSION: Execution Failed'
-    print regressions['exec state']
+    print('REGRESSION: Execution Failed')
+    print(regressions['exec state'])
 
   if len(regressions['compile time']) != 0:
-    print 'REGRESSION: Compilation Time'
-    print regressions['compile time']
+    print('REGRESSION: Compilation Time')
+    print(regressions['compile time'])
 
   if len(regressions['exec time']) != 0:
-    print 'REGRESSION: Execution Time'
-    print regressions['exec time']
+    print('REGRESSION: Execution Time')
+    print(regressions['exec time'])
 
   if len(passes['compile state']) != 0:
-    print 'NEW PASSES: Compilation'
-    print passes['compile state']
+    print('NEW PASSES: Compilation')
+    print(passes['compile state'])
 
   if len(passes['exec state']) != 0:
-    print 'NEW PASSES: Execution'
-    print passes['exec state']
+    print('NEW PASSES: Execution')
+    print(passes['exec state'])
 
   if len(removed) != 0:
-    print 'REMOVED TESTS'
-    print removed
+    print('REMOVED TESTS')
+    print(removed)
 
 # Main
 if len(sys.argv) < 3 :
-  print 'Usage:', sys.argv[0], '<old log> <new log>'
+  print('Usage:', sys.argv[0], '<old log> <new log>')
   sys.exit(-1)
 
 d_old = parse(sys.argv[1])
 d_new = parse(sys.argv[2])
 
 diffResults(d_old, d_new)

llvm/trunk/utils/shuffle_fuzz.py

 #!/usr/bin/env python
 
 """A shuffle vector fuzz tester.
 
 This is a python program to fuzz test the LLVM shufflevector instruction. It
 generates a function with a random sequnece of shufflevectors, maintaining the
 element mapping accumulated across the function. It then generates a main
 function which calls it with a different value in each element and checks that
 the result matches the expected mapping.
 
 Take the output IR printed to stdout, compile it to an executable using whatever
 set of transforms you want to test, and run the program. If it crashes, it found
 a bug.
 """
 
+from __future__ import print_function
+
 import argparse
 import itertools
 import random
 import sys
 import uuid
 
 def main():
   element_types=['i8', 'i16', 'i32', 'i64', 'f32', 'f64']
def main():
   shuffle_tree = [[[-1 if random.random() <= undef_prob
                        else random.choice(range(shuffle_range))
                     for _ in itertools.repeat(None, width)]
                    for _ in itertools.repeat(None, args.max_shuffle_height - i)]
                   for i in xrange(args.max_shuffle_height)]
 
   if args.verbose:
     # Print out the shuffle sequence in a compact form.
-    print >>sys.stderr, ('Testing shuffle sequence "%s" (v%d%s):' %
-                         (args.seed, width, element_type))
+    print(('Testing shuffle sequence "%s" (v%d%s):' %
+                         (args.seed, width, element_type)), file=sys.stderr)
     for i, shuffles in enumerate(shuffle_tree):
-      print >>sys.stderr, '  tree level %d:' % (i,)
+      print('  tree level %d:' % (i,), file=sys.stderr)
       for j, s in enumerate(shuffles):
-        print >>sys.stderr, '    shuffle %d: %s' % (j, s)
-    print >>sys.stderr, ''
+        print('    shuffle %d: %s' % (j, s), file=sys.stderr)
+    print('', file=sys.stderr)
 
   # Symbolically evaluate the shuffle tree.
   inputs = [[int(j % element_modulus)
              for j in xrange(i * width + 1, (i + 1) * width + 1)]
             for i in xrange(args.max_shuffle_height + 1)]
   results = inputs
   for shuffles in shuffle_tree:
     results = [[((results[i] if j < width else results[i + 1])[j % width]
                  if j != -1 else -1)
                 for j in s]
                for i, s in enumerate(shuffles)]
   if len(results) != 1:
-    print >>sys.stderr, 'ERROR: Bad results: %s' % (results,)
+    print('ERROR: Bad results: %s' % (results,), file=sys.stderr)
     sys.exit(1)
   result = results[0]
 
   if args.verbose:
-    print >>sys.stderr, 'Which transforms:'
-    print >>sys.stderr, '  from: %s' % (inputs,)
-    print >>sys.stderr, '  into: %s' % (result,)
-    print >>sys.stderr, ''
+    print('Which transforms:', file=sys.stderr)
+    print('  from: %s' % (inputs,), file=sys.stderr)
+    print('  into: %s' % (result,), file=sys.stderr)
+    print('', file=sys.stderr)
 
   # The IR uses silly names for floating point types. We also need a same-size
   # integer type.
   integral_element_type = element_type
   if element_type == 'f32':
     integral_element_type = 'i32'
     element_type = 'float'
   elif element_type == 'f64':
     integral_element_type = 'i64'
     element_type = 'double'
 
   # Now we need to generate IR for the shuffle function.
   subst = {'N': width, 'T': element_type, 'IT': integral_element_type}
-  print """
+  print("""
 define internal fastcc <%(N)d x %(T)s> @test(%(arguments)s) noinline nounwind {
 entry:""" % dict(subst,
                  arguments=', '.join(
                      ['<%(N)d x %(T)s> %%s.0.%(i)d' % dict(subst, i=i)
-                      for i in xrange(args.max_shuffle_height + 1)]))
+                      for i in xrange(args.max_shuffle_height + 1)])))
 
   for i, shuffles in enumerate(shuffle_tree):
    for j, s in enumerate(shuffles):
-    print """
+    print("""
   %%s.%(next_i)d.%(j)d = shufflevector <%(N)d x %(T)s> %%s.%(i)d.%(j)d, <%(N)d x %(T)s> %%s.%(i)d.%(next_j)d, <%(N)d x i32> <%(S)s>
 """.strip('\n') % dict(subst, i=i, next_i=i + 1, j=j, next_j=j + 1,
                        S=', '.join(['i32 ' + (str(si) if si != -1 else 'undef')
-                                    for si in s]))
+                                    for si in s])))
 
-  print """
+  print("""
   ret <%(N)d x %(T)s> %%s.%(i)d.0
 }
-""" % dict(subst, i=len(shuffle_tree))
+""" % dict(subst, i=len(shuffle_tree)))
 
   # Generate some string constants that we can use to report errors.
   for i, r in enumerate(result):
     if r != -1:
       s = ('FAIL(%(seed)s): lane %(lane)d, expected %(result)d, found %%d\n\\0A' %
            {'seed': args.seed, 'lane': i, 'result': r})
       s += ''.join(['\\00' for _ in itertools.repeat(None, 128 - len(s) + 2)])
-      print """
+      print("""
 @error.%(i)d = private unnamed_addr global [128 x i8] c"%(s)s"
-""".strip() % {'i': i, 's': s}
+""".strip() % {'i': i, 's': s})
 
   # Define a wrapper function which is marked 'optnone' to prevent
   # interprocedural optimizations from deleting the test.
-  print """
+  print("""
 define internal fastcc <%(N)d x %(T)s> @test_wrapper(%(arguments)s) optnone noinline {
   %%result = call fastcc <%(N)d x %(T)s> @test(%(arguments)s)
   ret <%(N)d x %(T)s> %%result
 }
 """ % dict(subst,
            arguments=', '.join(['<%(N)d x %(T)s> %%s.%(i)d' % dict(subst, i=i)
-                                for i in xrange(args.max_shuffle_height + 1)]))
+                                for i in xrange(args.max_shuffle_height + 1)])))
 
   # Finally, generate a main function which will trap if any lanes are mapped
   # incorrectly (in an observable way).
-  print """
+  print("""
 define i32 @main() {
 entry:
   ; Create a scratch space to print error messages.
   %%str = alloca [128 x i8]
   %%str.ptr = getelementptr inbounds [128 x i8], [128 x i8]* %%str, i32 0, i32 0
 
   ; Build the input vector and call the test function.
   %%v = call fastcc <%(N)d x %(T)s> @test_wrapper(%(inputs)s)
   ; We need to cast this back to an integer type vector to easily check the
   ; result.
   %%v.cast = bitcast <%(N)d x %(T)s> %%v to <%(N)d x %(IT)s>
   br label %%test.0
 """ % dict(subst,
            inputs=', '.join(
                [('<%(N)d x %(T)s> bitcast '
                  '(<%(N)d x %(IT)s> <%(input)s> to <%(N)d x %(T)s>)' %
                  dict(subst, input=', '.join(['%(IT)s %(i)d' % dict(subst, i=i)
                                               for i in input])))
-                for input in inputs]))
+                for input in inputs])))
 
   # Test that each non-undef result lane contains the expected value.
   for i, r in enumerate(result):
     if r == -1:
-      print """
+      print("""
 test.%(i)d:
   ; Skip this lane, its value is undef.
   br label %%test.%(next_i)d
-""" % dict(subst, i=i, next_i=i + 1)
+""" % dict(subst, i=i, next_i=i + 1))
     else:
-      print """
+      print("""
 test.%(i)d:
   %%v.%(i)d = extractelement <%(N)d x %(IT)s> %%v.cast, i32 %(i)d
   %%cmp.%(i)d = icmp ne %(IT)s %%v.%(i)d, %(r)d
   br i1 %%cmp.%(i)d, label %%die.%(i)d, label %%test.%(next_i)d
 
 die.%(i)d:
   ; Capture the actual value and print an error message.
   %%tmp.%(i)d = zext %(IT)s %%v.%(i)d to i2048
   %%bad.%(i)d = trunc i2048 %%tmp.%(i)d to i32
   call i32 (i8*, i8*, ...) @sprintf(i8* %%str.ptr, i8* getelementptr inbounds ([128 x i8], [128 x i8]* @error.%(i)d, i32 0, i32 0), i32 %%bad.%(i)d)
   %%length.%(i)d = call i32 @strlen(i8* %%str.ptr)
   call i32 @write(i32 2, i8* %%str.ptr, i32 %%length.%(i)d)
   call void @llvm.trap()
   unreachable
-""" % dict(subst, i=i, next_i=i + 1, r=r)
+""" % dict(subst, i=i, next_i=i + 1, r=r))
 
-  print """
+  print("""
 test.%d:
   ret i32 0
 }
 
 declare i32 @strlen(i8*)
 declare i32 @write(i32, i8*, i32)
 declare i32 @sprintf(i8*, i8*, ...)
 declare void @llvm.trap() noreturn nounwind
-""" % (len(result),)
+""" % (len(result),))
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/shuffle_select_fuzz_tester.py

 #!/usr/bin/env python
 
 """A shuffle-select vector fuzz tester.
 
 This is a python program to fuzz test the LLVM shufflevector and select
 instructions. It generates a function with a random sequnece of shufflevectors
 while optionally attaching it with a select instruction (regular or zero merge),
 maintaining the element mapping accumulated across the function. It then
 generates a main function which calls it with a different value in each element
 and checks that the result matches the expected mapping.
 
 Take the output IR printed to stdout, compile it to an executable using whatever
 set of transforms you want to test, and run the program. If it crashes, it found
 a bug (an error message with the expected and actual result is printed).
 """
+from __future__ import print_function
 
 import random
 import uuid
 import argparse
 
 # Possibility of one undef index in generated mask for shufflevector instruction
 SHUF_UNDEF_POS = 0.15
 
class ShufInstr(Instruction):
   def dump(self):
     str_mask = [('i32 ' + str(idx)) if idx != -1 else 'i32 undef' for idx in self.mask]
     str_mask = '<' + (', ').join(str_mask) + '>'
     return self.shuf_template.format(name = self.name, ty = self.ty.dump(), op0 = self.op0.name,
                                op1 = self.op1.name, num = self.ty.elt_num, mask = str_mask)
 
   def calc_value(self):
     if self.value != None:
-      print 'Trying to calculate the value of a shuffle instruction twice'
+      print('Trying to calculate the value of a shuffle instruction twice')
       exit(1)
 
     result = []
     for i in range(len(self.mask)):
       index = self.mask[i]
 
       if index < self.ty.elt_num and index >= 0:
         result.append(self.op0.value[index])
class SelectInstr(Instruction):
   def dump(self):
     str_mask = [('i1 ' + str(idx)) if idx != -1 else 'i1 undef' for idx in self.mask]
     str_mask = '<' + (', ').join(str_mask) + '>'
     return self.sel_template.format(name = self.name, ty = self.ty.dump(), op0 = self.op0.name,
                                op1 = self.op1.name, num = self.ty.elt_num, mask = str_mask)
 
   def calc_value(self):
     if self.value != None:
-      print 'Trying to calculate the value of a select instruction twice'
+      print('Trying to calculate the value of a select instruction twice')
       exit(1)
 
     result = []
     for i in range(len(self.mask)):
       index = self.mask[i]
 
       if index == 1:
         result.append(self.op0.value[i])
parser.add_argument('--type', default=None,
                       help='''
                           Choose specific type to be tested.
                           i8, i16, i32, i64, f32 or f64.
                           (default: random)''')
   parser.add_argument('--num-elts', default=None, type=int,
                       help='Choose specific number of vector elements to be tested. (default: random)')
   args = parser.parse_args()
 
-  print '; The seed used for this test is ' + args.seed
+  print('; The seed used for this test is ' + args.seed)
 
   assert args.min_num_inputs < args.max_num_inputs , "Minimum value greater than maximum."
   assert args.type in [None, 'i8', 'i16', 'i32', 'i64', 'f32', 'f64'], "Illegal type."
   assert args.num_elts == None or args.num_elts > 0, "num_elts must be a positive integer."
 
   random.seed(args.seed)
   ty = get_random_type(args.type, args.num_elts)
   inputs = gen_inputs(ty, random.randint(args.min_num_inputs, args.max_num_inputs))
   inputs_str = (', ').join([inp.ty.dump() + ' ' + inp.name for inp in inputs])
   inputs_values = [inp.value for inp in inputs]
 
   insts = gen_insts(inputs, ty)
 
   assert len(inputs) == 1, "Only one value should be left after generating phase"
   res = inputs[0]
 
   # print the actual test function by dumping the generated instructions.
   insts_str = ''.join([inst.dump() for inst in insts])
-  print test_template.format(ty = ty.dump(), inputs = inputs_str,
-                             instructions = insts_str, last_name = res.name)
+  print(test_template.format(ty = ty.dump(), inputs = inputs_str,
+                             instructions = insts_str, last_name = res.name))
 
   # Print the error message templates as global strings
   for i in range(len(res.value)):
     pad = ''.join(['\\00']*(31 - len(str(i)) - len(str(res.value[i]))))
-    print error_template.format(lane = str(i), exp = str(res.value[i]),
-                                padding = pad)
+    print(error_template.format(lane = str(i), exp = str(res.value[i]),
+                                padding = pad))
 
   # Prepare the runtime checks and failure handlers.
   scalar_ty = ty.get_scalar_type()
   check_die = ''
   i_f = 'f' if ty.is_float else 'i'
   ordered = 'o' if ty.is_float else ''
   for i in range(len(res.value)):
     if res.value[i] != -1:
def main():
 
   check_die += '\ntest.' + str(len(res.value)) + ':\n'
   check_die += '  ret i32 0'
 
   # Prepare the input values passed to the test function.
   inputs_values = [', '.join([scalar_ty.dump() + ' ' + str(i) for i in inp]) for inp in inputs_values]
   inputs = ', '.join([ty.dump() + ' <' + inp + '>' for inp in inputs_values])
 
-  print main_template.format(ty = ty.dump(), inputs = inputs, check_die = check_die)
+  print(main_template.format(ty = ty.dump(), inputs = inputs, check_die = check_die))
 
 
 if __name__ == '__main__':
   main()
 
 

llvm/trunk/utils/unicode-case-fold.py

<status> can be one of four characters:
   S - mappings for Simple case folding
   F - mappings for Full case folding
   T - special case for Turkish I characters
 
 Right now this generates a function which implements simple case folding (C+S
 entries).
 """
 
+from __future__ import print_function
+
 import sys
 import re
 import urllib2
 
 # This variable will body of the mappings function
 body = ""
 
 # Reads file line-by-line, extracts Common and Simple case fold mappings and
for m in mappings(f):
 
     # Incompatible stride, start a new block.
     dump_block(current_block)
     current_block = [m]
 f.close()
 
 dump_block(current_block)
 
-print '//===---------- Support/UnicodeCaseFold.cpp -------------------------------===//'
-print '//'
-print '// This file was generated by utils/unicode-case-fold.py from the Unicode'
-print '// case folding database at'
-print '//   ', sys.argv[1]
-print '//'
-print '// To regenerate this file, run:'
-print '//   utils/unicode-case-fold.py \\'
-print '//     "{}" \\'.format(sys.argv[1])
-print '//     > lib/Support/UnicodeCaseFold.cpp'
-print '//'
-print '//===----------------------------------------------------------------------===//'
-print ''
-print '#include "llvm/Support/Unicode.h"'
-print ''
-print "int llvm::sys::unicode::foldCharSimple(int C) {"
-print body
-print "  return C;"
-print "}"
+print('//===---------- Support/UnicodeCaseFold.cpp -------------------------------===//')
+print('//')
+print('// This file was generated by utils/unicode-case-fold.py from the Unicode')
+print('// case folding database at')
+print('//   ', sys.argv[1])
+print('//')
+print('// To regenerate this file, run:')
+print('//   utils/unicode-case-fold.py \\')
+print('//     "{}" \\'.format(sys.argv[1]))
+print('//     > lib/Support/UnicodeCaseFold.cpp')
+print('//')
+print('//===----------------------------------------------------------------------===//')
+print('')
+print('#include "llvm/Support/Unicode.h"')
+print('')
+print("int llvm::sys::unicode::foldCharSimple(int C) {")
+print(body)
+print("  return C;")
+print("}")

llvm/trunk/utils/update_analyze_test_checks.py

 9. Submit a patch including the regression test diffs for review.
 
 A common pattern is to have the script insert complete checking of every
 instruction. Then, edit it down to only check the relevant instructions.
 The script is designed to make adding checks to a test case fast, it is *not*
 designed to be authoratitive about what constitutes a good test!
 """
 
+from __future__ import print_function
+
 import argparse
 import itertools
 import os         # Used to advertise this file's name ("autogenerated_note").
 import string
 import subprocess
 import sys
 import tempfile
 import re
parser.add_argument(
       '--function', help='The function in the test file to update')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
   autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
 
   opt_basename = os.path.basename(args.opt_binary)
   if (opt_basename != "opt"):
-    print >>sys.stderr, 'ERROR: Unexpected opt name: ' + opt_basename
+    print('ERROR: Unexpected opt name: ' + opt_basename, file=sys.stderr)
     sys.exit(1)
 
   for test in args.tests:
     if args.verbose:
-      print >>sys.stderr, 'Scanning for RUN lines in test file: %s' % (test,)
+      print('Scanning for RUN lines in test file: %s' % (test,), file=sys.stderr)
     with open(test) as f:
       input_lines = [l.rstrip() for l in f]
 
     raw_lines = [m.group(1)
                  for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
     run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
     for l in raw_lines[1:]:
       if run_lines[-1].endswith("\\"):
         run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
       else:
         run_lines.append(l)
 
     if args.verbose:
-      print >>sys.stderr, 'Found %d RUN lines:' % (len(run_lines),)
+      print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
-        print >>sys.stderr, '  RUN: ' + l
+        print('  RUN: ' + l, file=sys.stderr)
 
     prefix_list = []
     for l in run_lines:
       (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
 
       if not tool_cmd.startswith(opt_basename + ' '):
-        print >>sys.stderr, 'WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l)
+        print('WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l), file=sys.stderr)
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print >>sys.stderr, 'WARNING: Skipping non-FileChecked RUN line: ' + l
+        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
         continue
 
       tool_cmd_args = tool_cmd[len(opt_basename):].strip()
       tool_cmd_args = tool_cmd_args.replace('< %s', '').replace('%s', '').strip()
 
       check_prefixes = [item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd)
                                for item in m.group(1).split(',')]
       if not check_prefixes:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       prefix_list.append((check_prefixes, tool_cmd_args))
 
     func_dict = {}
     for prefixes, _ in prefix_list:
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
     for prefixes, opt_args in prefix_list:
       if args.verbose:
-        print >>sys.stderr, 'Extracted opt cmd: ' + opt_basename + ' ' + opt_args
-        print >>sys.stderr, 'Extracted FileCheck prefixes: ' + str(prefixes)
+        print('Extracted opt cmd: ' + opt_basename + ' ' + opt_args, file=sys.stderr)
+        print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
 
       raw_tool_outputs = common.invoke_tool(args.opt_binary, opt_args, test)
 
       # Split analysis outputs by "Printing analysis " declarations.
       for raw_tool_output in re.split(r'Printing analysis ', raw_tool_outputs):
         common.build_function_body_dictionary(
           common.ANALYZE_FUNCTION_RE, common.scrub_body, [],
           raw_tool_output, prefixes, func_dict, args.verbose)
 
     is_in_function = False
     is_in_function_start = False
     prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
     if args.verbose:
-      print >>sys.stderr, 'Rewriting FileCheck prefixes: %s' % (prefix_set,)
+      print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
     output_lines = []
     output_lines.append(autogenerated_note)
 
     for input_line in input_lines:
       if is_in_function_start:
         if input_line == '':
           continue
         if input_line.lstrip().startswith(';'):
for input_line in input_lines:
         continue
       func_name = m.group(1)
       if args.function is not None and func_name != args.function:
         # When filtering on a specific function, skip all others.
         continue
       is_in_function = is_in_function_start = True
 
     if args.verbose:
-      print>>sys.stderr, 'Writing %d lines to %s...' % (len(output_lines), test)
+      print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
 
     with open(test, 'wb') as f:
       f.writelines([l + '\n' for l in output_lines])
 
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/update_llc_test_checks.py

 #!/usr/bin/env python2.7
 
 """A test case update script.
 
 This script is a utility to update LLVM 'llc' based test cases with new
 FileCheck patterns. It can either update all of the tests in the file or
 a single test function.
 """
 
+from __future__ import print_function
+
 import argparse
 import os         # Used to advertise this file's name ("autogenerated_note").
 import string
 import subprocess
 import sys
 import re
 
 from UpdateTestChecks import asm, common
parser.add_argument(
       '--no_x86_scrub_rip', action='store_false', dest='x86_scrub_rip')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
   autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
 
   for test in args.tests:
     if args.verbose:
-      print >>sys.stderr, 'Scanning for RUN lines in test file: %s' % (test,)
+      print('Scanning for RUN lines in test file: %s' % (test,), file=sys.stderr)
     with open(test) as f:
       input_lines = [l.rstrip() for l in f]
 
     triple_in_ir = None
     for l in input_lines:
       m = common.TRIPLE_IR_RE.match(l)
       if m:
         triple_in_ir = m.groups()[0]
         break
 
     raw_lines = [m.group(1)
                  for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
     run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
     for l in raw_lines[1:]:
       if run_lines[-1].endswith("\\"):
         run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
       else:
         run_lines.append(l)
 
     if args.verbose:
-      print >>sys.stderr, 'Found %d RUN lines:' % (len(run_lines),)
+      print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
-        print >>sys.stderr, '  RUN: ' + l
+        print('  RUN: ' + l, file=sys.stderr)
 
     run_list = []
     for l in run_lines:
       commands = [cmd.strip() for cmd in l.split('|', 1)]
       llc_cmd = commands[0]
 
       triple_in_cmd = None
       m = common.TRIPLE_ARG_RE.search(llc_cmd)
       if m:
         triple_in_cmd = m.groups()[0]
 
       filecheck_cmd = ''
       if len(commands) > 1:
         filecheck_cmd = commands[1]
       if not llc_cmd.startswith('llc '):
-        print >>sys.stderr, 'WARNING: Skipping non-llc RUN line: ' + l
+        print('WARNING: Skipping non-llc RUN line: ' + l, file=sys.stderr)
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print >>sys.stderr, 'WARNING: Skipping non-FileChecked RUN line: ' + l
+        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
         continue
 
       llc_cmd_args = llc_cmd[len('llc'):].strip()
       llc_cmd_args = llc_cmd_args.replace('< %s', '').replace('%s', '').strip()
 
       check_prefixes = [item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd)
                                for item in m.group(1).split(',')]
       if not check_prefixes:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       run_list.append((check_prefixes, llc_cmd_args, triple_in_cmd))
 
     func_dict = {}
     for p in run_list:
       prefixes = p[0]
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
     for prefixes, llc_args, triple_in_cmd in run_list:
       if args.verbose:
-        print >>sys.stderr, 'Extracted LLC cmd: llc ' + llc_args
-        print >>sys.stderr, 'Extracted FileCheck prefixes: ' + str(prefixes)
+        print('Extracted LLC cmd: llc ' + llc_args, file=sys.stderr)
+        print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
 
       raw_tool_output = common.invoke_tool(args.llc_binary, llc_args, test)
       if not (triple_in_cmd or triple_in_ir):
-        print >>sys.stderr, "Cannot find a triple. Assume 'x86'"
+        print("Cannot find a triple. Assume 'x86'", file=sys.stderr)
 
       asm.build_function_body_dictionary_for_triple(args, raw_tool_output,
           triple_in_cmd or triple_in_ir or 'x86', prefixes, func_dict)
 
     is_in_function = False
     is_in_function_start = False
     func_name = None
     prefix_set = set([prefix for p in run_list for prefix in p[0]])
     if args.verbose:
-      print >>sys.stderr, 'Rewriting FileCheck prefixes: %s' % (prefix_set,)
+      print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
     output_lines = []
     output_lines.append(autogenerated_note)
 
     for input_line in input_lines:
       if is_in_function_start:
         if input_line == '':
           continue
         if input_line.lstrip().startswith(';'):
for input_line in input_lines:
         continue
       func_name = m.group(1)
       if args.function is not None and func_name != args.function:
         # When filtering on a specific function, skip all others.
         continue
       is_in_function = is_in_function_start = True
 
     if args.verbose:
-      print>>sys.stderr, 'Writing %d lines to %s...' % (len(output_lines), test)
+      print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
 
     with open(test, 'wb') as f:
       f.writelines([l + '\n' for l in output_lines])
 
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/update_test_checks.py

 9. Submit a patch including the regression test diffs for review.
 
 A common pattern is to have the script insert complete checking of every
 instruction. Then, edit it down to only check the relevant instructions.
 The script is designed to make adding checks to a test case fast, it is *not*
 designed to be authoratitive about what constitutes a good test!
 """
 
+from __future__ import print_function
+
 import argparse
 import itertools
 import os         # Used to advertise this file's name ("autogenerated_note").
 import string
 import subprocess
 import sys
 import tempfile
 import re
parser.add_argument(
       '--function', help='The function in the test file to update')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
   autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
 
   opt_basename = os.path.basename(args.opt_binary)
   if (opt_basename != "opt"):
-    print >>sys.stderr, 'ERROR: Unexpected opt name: ' + opt_basename
+    print('ERROR: Unexpected opt name: ' + opt_basename, file=sys.stderr)
     sys.exit(1)
 
   for test in args.tests:
     if args.verbose:
-      print >>sys.stderr, 'Scanning for RUN lines in test file: %s' % (test,)
+      print('Scanning for RUN lines in test file: %s' % (test,), file=sys.stderr)
     with open(test) as f:
       input_lines = [l.rstrip() for l in f]
 
     raw_lines = [m.group(1)
                  for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
     run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
     for l in raw_lines[1:]:
       if run_lines[-1].endswith("\\"):
         run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
       else:
         run_lines.append(l)
 
     if args.verbose:
-      print >>sys.stderr, 'Found %d RUN lines:' % (len(run_lines),)
+      print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
-        print >>sys.stderr, '  RUN: ' + l
+        print('  RUN: ' + l, file=sys.stderr)
 
     prefix_list = []
     for l in run_lines:
       (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
 
       if not tool_cmd.startswith(opt_basename + ' '):
-        print >>sys.stderr, 'WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l)
+        print('WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l), file=sys.stderr)
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print >>sys.stderr, 'WARNING: Skipping non-FileChecked RUN line: ' + l
+        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
         continue
 
       tool_cmd_args = tool_cmd[len(opt_basename):].strip()
       tool_cmd_args = tool_cmd_args.replace('< %s', '').replace('%s', '').strip()
 
       check_prefixes = [item for m in common.CHECK_PREFIX_RE.finditer(filecheck_cmd)
                                for item in m.group(1).split(',')]
       if not check_prefixes:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       prefix_list.append((check_prefixes, tool_cmd_args))
 
     func_dict = {}
     for prefixes, _ in prefix_list:
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
     for prefixes, opt_args in prefix_list:
       if args.verbose:
-        print >>sys.stderr, 'Extracted opt cmd: ' + opt_basename + ' ' + opt_args
-        print >>sys.stderr, 'Extracted FileCheck prefixes: ' + str(prefixes)
+        print('Extracted opt cmd: ' + opt_basename + ' ' + opt_args, file=sys.stderr)
+        print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
 
       raw_tool_output = common.invoke_tool(args.opt_binary, opt_args, test)
       common.build_function_body_dictionary(
               common.OPT_FUNCTION_RE, common.scrub_body, [],
               raw_tool_output, prefixes, func_dict, args.verbose)
 
     is_in_function = False
     is_in_function_start = False
     prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
     if args.verbose:
-      print >>sys.stderr, 'Rewriting FileCheck prefixes: %s' % (prefix_set,)
+      print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
     output_lines = []
     output_lines.append(autogenerated_note)
 
     for input_line in input_lines:
       if is_in_function_start:
         if input_line == '':
           continue
         if input_line.lstrip().startswith(';'):
for input_line in input_lines:
         continue
       func_name = m.group(1)
       if args.function is not None and func_name != args.function:
         # When filtering on a specific function, skip all others.
         continue
       is_in_function = is_in_function_start = True
 
     if args.verbose:
-      print>>sys.stderr, 'Writing %d lines to %s...' % (len(output_lines), test)
+      print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
 
     with open(test, 'wb') as f:
       f.writelines([l + '\n' for l in output_lines])
 
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/wciia.py

 - must be run from llvm source root
 - very simplistic algorithm
 - only handles * as a wildcard
 - not very user friendly 
 - does not handle the proposed F: field
 
 """
 
+from __future__ import print_function
 import os
 
 code_owners = {}
 
 def process_files_and_folders(owner):
   filesfolders = owner['filesfolders']
   # paths must be in ( ... ) so strip them
   lpar = filesfolders.find('(')
#       print "searching (" + path + ")"
             onames.append(name)
   onames.append('Chris Lattner')
   return onames
   
 # now lest try to find the owner of the file or folder
 import sys
 
 if len(sys.argv) < 2:
-  print "usage " + sys.argv[0] + " file_or_folder"  
+  print("usage " + sys.argv[0] + " file_or_folder")
   exit(-1)
   
 # the path we are checking
 path = str(sys.argv[1])
 
 # check if this is real path
 if not os.path.exists(path):
-  print "path (" + path + ") does not exist"
+  print("path (" + path + ") does not exist")
   exit(-1)
   
 owners_name = find_owners(path)
 
 # be grammatically correct
-print "The owner(s) of the (" + path + ") is(are) : " + str(owners_name)
+print("The owner(s) of the (" + path + ") is(are) : " + str(owners_name))
 
 exit(0)
 
 # bottom up walk of the current .
 # not yet used 
 root = "."
 for dir,subdirList,fileList in os.walk( root , topdown=False ) :
-   print "dir :" , dir
+   print("dir :" , dir)
    for fname in fileList :
-      print "-" , fname
-   print
+      print("-" , fname)
+   print()