[utils] Convert update_{llc_,}test_checks.py to Python 3

[MaskRay]

Summary

Python 2.7 will retire in 2 years. We may extract common parts of the two files to deduplicate. By converting to Python 3, we'll have less trouble dealing with different import mechanism.

[MatzeB]

LLVM's GettingStarted.html says "python >= 2.7" is fine for LLVM development.

The old recurring theme here is that:

• macOS only ships with python 2.7 to this day. So people need to install extra packages there for python 3.
• Modern linux distributions only install python 3 by default o people need to install extra packages there for python 2.7.

Admittedly macOS doesn't even ship with a python2.7 symlink so this script may have been broken for an out-of-the box macOS configuration anyway...

[MaskRay]

In D42450#985807, @MatzeB wrote:

LLVM's GettingStarted.html says "python >= 2.7" is fine for LLVM development.

The old recurring theme here is that:

• macOS only ships with python 2.7 to this day. So people need to install extra packages there for python 3.
• Modern linux distributions only install python 3 by default o people need to install extra packages there for python 2.7.

Admittedly macOS doesn't even ship with a python2.7 symlink so this script may have been broken for an out-of-the box macOS configuration anyway...

Thanks for your attention... I'd like to see llvm moving away from legacy python2.7

I intent to add something called update_clang_test_checks.py (.cc -> .ll or .cc -> .s) and find these scripts really should be combined..

[spatel]

In D42450#985851, @MaskRay wrote:

I intent to add something called update_clang_test_checks.py (.cc -> .ll or .cc -> .s) and find these scripts really should be combined..

I fully support automating clang test checks - see D17999 for some existing work in this direction.

I also support combining the opt and llc scripts, but I don't have the python skills to do it - rL305208 . My only experience with python is a couple of days on these scripts, so you can assume anything I've done is amateur at best.

For this reason, I'm also not qualified to review major improvements to the scripts, but I appreciate being cc'd here to know about the direction (and of course I use the scripts all the time).

re: macOS - I develop on macOS almost exclusively (I may even be the last one using Xcode to hack on LLVM!)...so I must've done something to be able to run these scripts on my machine. :)

[bogner]

In D42450#985851, @MaskRay wrote:

Thanks for your attention... I'd like to see llvm moving away from legacy python2.7

Changes to make these scripts work with both 2.7 and 3 are probably a more practical approach in the short term. I suspect there will still be a fair amount of resistance to dropping python2.7 support in LLVM for a bit yet.

I intent to add something called update_clang_test_checks.py (.cc -> .ll or .cc -> .s) and find these scripts really should be combined..

As Sanjay mentioned, this has been attempted in the past. It may make more sense to break out some of the common parts into a library and use it in both, as the scripts do have slightly different needs. I've been thinking about how to approach this, and suspect some of the ideas implemented in update_mir_test_checks will help.

[MatzeB]

I'd like to see llvm moving away from legacy python2.7

That needs discussion on llvm-dev to make sure everyone is on the same page, GettingStarted.rst is updated etc. Forcing just a single script to python3 is not a good idea.

FWIW I don't understand why we waste time making our script compatible to python2 and python3 at the same time, it just doubles testing efforts. I'd rather see us go all-in on python3 (or stay with python2 and don't bother). And I personally think we should go all-in for python3...

so I must've done something to be able to run these scripts on my machine. :)

Well installing any homebrew or macports python (which is often a dependency for other packages) will give you a python2 with the proper symlinks in place. It's usually people maintaining CI infrastructured that are bothered by macOS (or linux) default installations.

[bogner]

In D42450#987039, @MatzeB wrote:

so I must've done something to be able to run these scripts on my machine. :)

Well installing any homebrew or macports python (which is often a dependency for other packages) will give you a python2 with the proper symlinks in place. It's usually people maintaining CI infrastructured that are bothered by macOS (or linux) default installations.

Mac's system python comes with a python2.7 symlink. Today you don't need to do anything for this script to work.

[MatzeB]

In D42450#987234, @bogner wrote:

In D42450#987039, @MatzeB wrote:

so I must've done something to be able to run these scripts on my machine. :)

Well installing any homebrew or macports python (which is often a dependency for other packages) will give you a python2 with the proper symlinks in place. It's usually people maintaining CI infrastructured that are bothered by macOS (or linux) default installations.

Mac's system python comes with a python2.7 symlink. Today you don't need to do anything for this script to work.

I remembered that some scripts didn't work on macOS out of the box, but indeed python2.7 exists. It looks like just a python2 symlink is missing.

[MaskRay]

Thanks for your preference of python3 over python2.7. Is the only objection

1. not out-of-box on Mac OS X
2. inconsistency with other scripts with the shebang (#!/usr/bin/python or python2)

[MaskRay]

Rebase

[MaskRay]

Is the decision "we should not make it Python 3" ?

[MatzeB]

In D42450#990855, @MaskRay wrote:

Is the decision "we should not make it Python 3" ?

I think it is: "We should not make it python 3 without discussing this on the llvm-dev mailing list".

[MaskRay]

Abandoned by https://reviews.llvm.org/rL324803

utils/update_llc_test_checks.py

-#!/usr/bin/env python2.7
+#!/usr/bin/env python3
 
 """A test case update script.
 
 This script is a utility to update LLVM X86 'llc' based test cases with new
 FileCheck patterns. It can either update all of the tests in the file or
 a single test function.
 """
 
 import argparse
 import os         # Used to advertise this file's name ("autogenerated_note").
-import string
 import subprocess
 import sys
 import re
 
 # Invoke the tool that is being tested.
 def llc(args, cmd_args, ir):
   with open(ir) as ir_file:
     stdout = subprocess.check_output(args.llc_binary + ' ' + cmd_args,
-                                     shell=True, stdin=ir_file)
+                                     shell=True, stdin=ir_file).decode()
   # Fix line endings to unix CR style.
   stdout = stdout.replace('\r\n', '\n')
   return stdout
 
 
 # RegEx: this is where the magic happens.
 
 ASM_FUNCTION_X86_RE = re.compile(

 CHECK_PREFIX_RE = re.compile('--?check-prefix(?:es)?=(\S+)')
 CHECK_RE = re.compile(r'^\s*;\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:')
 
 def scrub_asm_x86(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Detect shuffle asm comments and hide the operands in favor of the comments.
   asm = SCRUB_X86_SHUFFLES_RE.sub(r'\1 {{.*#+}} \2', asm)
   # Generically match the stack offset of a memory operand.
   asm = SCRUB_X86_SP_RE.sub(r'{{[0-9]+}}(%\1)', asm)
   # Generically match a RIP-relative memory operand.
   asm = SCRUB_X86_RIP_RE.sub(r'{{.*}}(%rip)', asm)
   # Generically match a LCP symbol.
   asm = SCRUB_X86_LCP_RE.sub(r'{{\.LCPI.*}}', asm)
   if args.x86_extra_scrub:
     # Avoid generating different checks for 32- and 64-bit because of 'retl' vs 'retq'.
     asm = SCRUB_X86_RET_RE.sub(r'ret{{[l|q]}}', asm)
   # Strip kill operands inserted into the asm.
   asm = SCRUB_KILL_COMMENT_RE.sub('', asm)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 def scrub_asm_arm_eabi(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Strip kill operands inserted into the asm.
   asm = SCRUB_KILL_COMMENT_RE.sub('', asm)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 def scrub_asm_powerpc64(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Stripe unimportant comments
   asm = SCRUB_LOOP_COMMENT_RE.sub(r'', asm)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 def scrub_asm_mips(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 def scrub_asm_riscv(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 def scrub_asm_systemz(asm, args):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   asm = SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
-  asm = string.expandtabs(asm, 2)
+  asm = str.expandtabs(asm, 2)
   # Strip trailing whitespace.
   asm = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
 
 # Build up a dictionary of all the function bodies.
 def build_function_body_dictionary(raw_tool_output, triple, prefixes, func_dict,
                                    args):
target_handlers = {
       'mips': (scrub_asm_mips, ASM_FUNCTION_MIPS_RE),
       'powerpc64': (scrub_asm_powerpc64, ASM_FUNCTION_PPC_RE),
       'powerpc64le': (scrub_asm_powerpc64, ASM_FUNCTION_PPC_RE),
       'riscv32': (scrub_asm_riscv, ASM_FUNCTION_RISCV_RE),
       'riscv64': (scrub_asm_riscv, ASM_FUNCTION_RISCV_RE),
       's390x': (scrub_asm_systemz, ASM_FUNCTION_SYSTEMZ_RE),
   }
   handlers = None
-  for prefix, s in target_handlers.items():
+  for prefix, s in list(target_handlers.items()):
     if triple.startswith(prefix):
       handlers = s
       break
   else:
     raise KeyError('Triple %r is not supported' % (triple))
 
   scrubber, function_re = handlers
   for m in function_re.finditer(raw_tool_output):
     if not m:
       continue
     func = m.group('func')
     scrubbed_body = scrubber(m.group('body'), args)
     if func.startswith('stress'):
       # We only use the last line of the function body for stress tests.
       scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:])
     if args.verbose:
-      print >>sys.stderr, 'Processing function: ' + func
+      print('Processing function: ' + func, file=sys.stderr)
       for l in scrubbed_body.splitlines():
-        print >>sys.stderr, '  ' + l
+        print('  ' + l, file=sys.stderr)
     for prefix in prefixes:
       if func in func_dict[prefix] and func_dict[prefix][func] != scrubbed_body:
         if prefix == prefixes[-1]:
-          print >>sys.stderr, ('WARNING: Found conflicting asm under the '
-                               'same prefix: %r!' % (prefix,))
+          print(('WARNING: Found conflicting asm under the '
+                               'same prefix: %r!' % (prefix,)), file=sys.stderr)
         else:
           func_dict[prefix][func] = None
           continue
 
       func_dict[prefix][func] = scrubbed_body
 
 
 def add_checks(output_lines, run_list, func_dict, func_name):
def main():
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
   autogenerated_note = ('; NOTE: Assertions have been autogenerated by '
                         '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 = TRIPLE_IR_RE.match(l)
       if m:
         triple_in_ir = m.groups()[0]
         break
 
     raw_lines = [m.group(1)
                  for m in [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 = 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 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 = llc(args, 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)
 
       build_function_body_dictionary(raw_tool_output,
           triple_in_cmd or triple_in_ir or 'x86', prefixes, func_dict, args)
 
     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:
+    with open(test, 'w') as f:
       f.writelines([l + '\n' for l in output_lines])
 
 
 if __name__ == '__main__':
   main()

utils/update_test_checks.py

-#!/usr/bin/env python2.7
+#!/usr/bin/env python3
 
 """A script to generate FileCheck statements for 'opt' regression tests.
 
 This script is a utility to update LLVM opt test cases with new
 FileCheck patterns. It can either update all of the tests in the file or
 a single test function.
 
 Example usage:

 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!
 """
 
 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
 
 ADVERT = '; NOTE: Assertions have been autogenerated by '
 
 # RegEx: this is where the magic happens.

 # spaces, commas, paren, or end of the string
 IR_VALUE_RE = re.compile(r'(\s+)%([\w\.]+?)([,\s\(\)]|\Z)')
 
 
 # Invoke the tool that is being tested.
 def invoke_tool(args, cmd_args, ir):
   with open(ir) as ir_file:
     stdout = subprocess.check_output(args.opt_binary + ' ' + cmd_args,
-                                     shell=True, stdin=ir_file)
+                                     shell=True, stdin=ir_file).decode()
   # Fix line endings to unix CR style.
   stdout = stdout.replace('\r\n', '\n')
   return stdout
 
 
 def scrub_body(body, opt_basename):
   # Scrub runs of whitespace out of the assembly, but leave the leading
   # whitespace in place.
   body = SCRUB_WHITESPACE_RE.sub(r' ', body)
   # Expand the tabs used for indentation.
-  body = string.expandtabs(body, 2)
+  body = str.expandtabs(body, 2)
   # Strip trailing whitespace.
   body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body)
   return body
 
 
 # Build up a dictionary of all the function bodies.
 def build_function_body_dictionary(raw_tool_output, prefixes, func_dict, verbose, opt_basename):
   func_regex = OPT_FUNCTION_RE
   for m in func_regex.finditer(raw_tool_output):
     if not m:
       continue
     func = m.group('func')
     scrubbed_body = scrub_body(m.group('body'), opt_basename)
     if func.startswith('stress'):
       # We only use the last line of the function body for stress tests.
       scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:])
     if verbose:
-      print >>sys.stderr, 'Processing function: ' + func
+      print('Processing function: ' + func, file=sys.stderr)
       for l in scrubbed_body.splitlines():
-        print >>sys.stderr, '  ' + l
+        print('  ' + l, file=sys.stderr)
     for prefix in prefixes:
       if func in func_dict[prefix] and func_dict[prefix][func] != scrubbed_body:
         if prefix == prefixes[-1]:
-          print >>sys.stderr, ('WARNING: Found conflicting asm under the '
-                               'same prefix: %r!' % (prefix,))
+          print(('WARNING: Found conflicting asm under the '
+                               'same prefix: %r!' % (prefix,)), file=sys.stderr)
         else:
           func_dict[prefix][func] = None
           continue
 
       func_dict[prefix][func] = scrubbed_body
 
 
 # Create a FileCheck variable name based on an IR name.
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 [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 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 = invoke_tool(args, opt_args, test)
       build_function_body_dictionary(raw_tool_output, prefixes, func_dict, args.verbose, opt_basename)
 
     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
       name = m.group(1)
       if args.function is not None and 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:
+    with open(test, 'w') as f:
       f.writelines([l + '\n' for l in output_lines])
 
 
 if __name__ == '__main__':
   main()
-