[UpdateTestChecks] Add UTC_ARGS support for update_{llc,cc}_test_checks.py

[arichardson]

Summary

https://reviews.llvm.org/D69701 added support for on-the-fly argument
changes for update scripts. I recently wanted to keep some manual check
lines in a test generated by update_cc_test_checks.py in our CHERI fork, so
this commit adds support for UTC_ARGS in update_cc_test_checks.py. And since
I was refactoring the code to be in common.py, I also added it for
update_llc_test_checks.py.

[jdoerfert]

I feel there is a lot of good stuff here but it seems to mix two things. A rewrite of the script infrastructure and the UTC_ARGS stuff. If so, do you think we could split them? I feel there are also minor NFC changes that could go in on their own without review, I marked on of them below.

(Partially related: Does this handle the mismatch between enabled configuration status and the flag names enable/disable or will it still add --enabled to the UTC_ARGS?)

llvm/utils/update_cc_test_checks.py

122

I guess these 7 lines can be committed on their own as NFC cleanup.

[arichardson]

In D78478#1994923, @jdoerfert wrote:

I feel there is a lot of good stuff here but it seems to mix two things. A rewrite of the script infrastructure and the UTC_ARGS stuff. If so, do you think we could split them? I feel there are also minor NFC changes that could go in on their own without review, I marked on of them below.

(Partially related: Does this handle the mismatch between enabled configuration status and the flag names enable/disable or will it still add --enabled to the UTC_ARGS?)

It will now read the command line flag that was specified when calling parser.add_argument() and should do the right thing.

I'll split out the unrelated changes to separate reviews.

[arichardson]

Split into multiple reviews

[arichardson]

rebase

[jdoerfert]

Nice cleanup again!

I think eventually we need to teach the common logic to recognize top-level entities, e.g., functions, and with these changes it will be accessible w/o duplication in all update scripts, YaY!

[MaskRay]

The idea look good to me, but I want some opinions on the name UTC_ARGS (I can't help associating it with Coordinated Universal Time). Adding some folks who may have opinions: @greened @lebedev.ri @RKSimon @spatel @xbolva00

[xbolva00]

UTC_ARGS (I can't help associating it with Coordinated Universal Time).

Me too. Any suggestions for new name? TCU_ARGS?

[arichardson]

In D78478#2128604, @MaskRay wrote:

The idea look good to me, but I want some opinions on the name UTC_ARGS (I can't help associating it with Coordinated Universal Time). Adding some folks who may have opinions: @greened @lebedev.ri @RKSimon @spatel @xbolva00

I agree that UTC_ARGS could be a bit confusing. However, there are currently 145 UTC_ARGS uses in tests/Transforms and I'd rather not update them as part of this change.

I feel that changing the name should be a separate change that can be committed after this patch.

[jdoerfert]

In D78478#2128926, @arichardson wrote:

In D78478#2128604, @MaskRay wrote:

The idea look good to me, but I want some opinions on the name UTC_ARGS (I can't help associating it with Coordinated Universal Time). Adding some folks who may have opinions: @greened @lebedev.ri @RKSimon @spatel @xbolva00

I agree that UTC_ARGS could be a bit confusing. However, there are currently 145 UTC_ARGS uses in tests/Transforms and I'd rather not update them as part of this change.

I feel that changing the name should be a separate change that can be committed after this patch.

Yes, please. The name is my fault, but naming things is hard :(

@MaskRay If you have an alternative name, I propose a sed -e/UTC_ARGS/.../ patch, maybe with a check in here warning if UTC_ARGS is used.

[spatel]

In D78478#2128631, @xbolva00 wrote:

UTC_ARGS (I can't help associating it with Coordinated Universal Time).

Me too. Any suggestions for new name? TCU_ARGS?

I also reflexively think of universal time when reading "UTC". I think we always print this with the script name advertisement line, so "SCRIPT_ARGS" seems non-ambiguous.

[arichardson]

@MaskRay are you okay with me committing this change and delaying the global search-replace?

[MaskRay]

LGTM.

clang/test/utils/update_cc_test_checks/Inputs/mangled_names.c.funcsig.expected

-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature
 // Example input for update_cc_test_checks
 // RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
 // CHECK-LABEL: define {{[^@]+}}@test
 // CHECK-SAME: (i64 [[A:%.*]], i32 [[B:%.*]]) #0
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4

clang/test/utils/update_cc_test_checks/Inputs/on_the_fly_arg_change.c

+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+int checks_please() {
+  return 1;
+}
+
+// UTC_ARGS: --disable
+
+int no_checks_please() {
+  // Manual CHECK line should be retained:
+  // CHECK: manual check line
+  return -1;
+}
+
+// UTC_ARGS: --enable
+
+
+int checks_again() {
+  return 2;
+}

clang/test/utils/update_cc_test_checks/Inputs/on_the_fly_arg_change.c.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+// CHECK-LABEL: @checks_please(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret i32 1
+//
+int checks_please() {
+  return 1;
+}
+
+// UTC_ARGS: --disable
+
+int no_checks_please() {
+  // Manual CHECK line should be retained:
+  // CHECK: manual check line
+  return -1;
+}
+
+// UTC_ARGS: --enable
+
+
+// CHECK-LABEL: @checks_again(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret i32 2
+//
+int checks_again() {
+  return 2;
+}

clang/test/utils/update_cc_test_checks/mangled_names.test

 ## Basic test checking that update_cc_test_checks.py works as expected for
 ## functions with mangled names
 # RUN: cp -f %S/Inputs/mangled_names.c %t.c && %update_cc_test_checks -v %t.c
 # RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected
 ## Check that running the script again does not change the result:
 # RUN: %update_cc_test_checks -v %t.c
 # RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected
 ## Also try the --function-signature flag
 # RUN: %update_cc_test_checks %t.c --function-signature
 # RUN: diff -u %t.c %S/Inputs/mangled_names.c.funcsig.expected
-## Verify that running without the --function-signature flag removes the -SAME: lines:
+## Running it again should implicitly add the function-signature flag due to UTC_ARGS:
 # RUN: %update_cc_test_checks %t.c
-# RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.funcsig.expected
+## Verify that running without the --function-signature flag removes the -SAME: lines:
+## We have to remove the UTC_ARGS comment first:
+# RUN: grep -v UTC_ARGS %t.c > %t-no-args.c
+# RUN: %update_cc_test_checks %t-no-args.c
+# RUN: diff -u %t-no-args.c %S/Inputs/mangled_names.c.expected

clang/test/utils/update_cc_test_checks/on_the_fly_arg_change.test

+# RUN: cp -f %S/Inputs/on_the_fly_arg_change.c %t.c
+# RUN: %update_cc_test_checks %t.c
+# RUN: diff -u %t.c %S/Inputs/on_the_fly_arg_change.c.expected
+## Check that running the script again does not change the result:
+# RUN: %update_cc_test_checks %t.c
+# RUN: diff -u %t.c %S/Inputs/on_the_fly_arg_change.c.expected

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/basic.ll.expected

-; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; Example input for update_llc_test_checks (taken from CodeGen/X86/iabs.ll)
 ; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s --check-prefix=X86 --check-prefix=X86-NO-CMOV
 ; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+cmov | FileCheck %s --check-prefix=X86 --check-prefix=X86-CMOV
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s --check-prefix=X64
 
 define i8 @test_i8(i8 %a) nounwind {
 ; X86-LABEL: test_i8:
 ; X86:       # %bb.0:

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/on_the_fly_arg_change.ll

+; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s
+
+declare void @foo()
+
+define i64 @check_lines_1() {
+  ret i64 1
+}
+
+; UTC_ARGS: --disable
+
+define i64 @no_check_lines() {
+; A check line that would not be auto-generated (should not be removed!).
+; CHECK: manual check line
+  ret i64 2
+}
+
+; UTC_ARGS: --enable --no_x86_scrub_rip
+
+define i64 @check_lines_2() {
+  %result = call i64 @no_check_lines()
+  ret i64 %result
+}

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/on_the_fly_arg_change.ll.expected

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s
+
+declare void @foo()
+
+define i64 @check_lines_1() {
+; CHECK-LABEL: check_lines_1:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    movl $1, %eax
+; CHECK-NEXT:    xorl %edx, %edx
+; CHECK-NEXT:    retl
+  ret i64 1
+}
+
+; UTC_ARGS: --disable
+
+define i64 @no_check_lines() {
+; A check line that would not be auto-generated (should not be removed!).
+; CHECK: manual check line
+  ret i64 2
+}
+
+; UTC_ARGS: --enable --no_x86_scrub_rip
+
+define i64 @check_lines_2() {
+; CHECK-LABEL: check_lines_2:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    calll no_check_lines
+; CHECK-NEXT:    retl
+  %result = call i64 @no_check_lines()
+  ret i64 %result
+}

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/basic.test

 # REQUIRES: x86-registered-target
 ## Basic test checking that update_llc_test_checks.py can update a file with multiple check prefixes
 
 # RUN: cp -f %S/Inputs/basic.ll %t.ll && %update_llc_test_checks %t.ll
-# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
-## The flags --x86_scrub_rip and --extra_scrub should have any effect for this
+# RUN: echo '; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py' > %t.expected.ll
+# RUN: cat %S/Inputs/basic.ll.expected >> %t.expected.ll
+# RUN: diff -u %t.expected.ll %t.ll
+
+## The flags --x86_scrub_rip and --extra_scrub should not have any effect on this
 ## test. Check the output is identical.
-# RUN: cp -f %S/Inputs/basic.ll %t.ll &&  %update_llc_test_checks --extra_scrub %t.ll
-# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
-# RUN: cp -f %S/Inputs/basic.ll %t.ll &&  %update_llc_test_checks --x86_scrub_rip %t.ll
-# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
+# RUN: cp -f %S/Inputs/basic.ll %t.ll && %update_llc_test_checks --extra_scrub %t.ll
+# RUN: echo '; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --extra_scrub' > %t.expected.ll
+# RUN: cat %S/Inputs/basic.ll.expected >> %t.expected.ll
+# RUN: diff -u %t.expected.ll %t.ll
+# RUN: cp -f %S/Inputs/basic.ll %t.ll && %update_llc_test_checks --no_x86_scrub_rip %t.ll
+# RUN: echo '; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --no_x86_scrub_rip' > %t.expected.ll
+# RUN: cat %S/Inputs/basic.ll.expected >> %t.expected.ll
+# RUN: diff -u %t.expected.ll %t.ll
+
 ## Finally, run the script on an already updated file and verify that all previous
 ## CHECK lines are removed.
 # RUN: %update_llc_test_checks %t.ll
-# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
+# RUN: echo '; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --no_x86_scrub_rip' > %t.expected.ll
+# RUN: cat %S/Inputs/basic.ll.expected >> %t.expected.ll
+# RUN: diff -u %t.expected.ll %t.ll

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/on_the_fly_arg_change.test

+# RUN: cp -f %S/Inputs/on_the_fly_arg_change.ll %t.ll
+# RUN: %update_llc_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/on_the_fly_arg_change.ll.expected
+## Check that running the script again does not change the result:
+# RUN: %update_llc_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/on_the_fly_arg_change.ll.expected

llvm/utils/update_cc_test_checks.py

 
 from __future__ import print_function
 
 import argparse
 import collections
 import distutils.spawn
 import json
 import os
+import re
 import shlex
-import string
 import subprocess
 import sys
-import re
 import tempfile
 
-from UpdateTestChecks import asm, common
-
-ADVERT = '// NOTE: Assertions have been autogenerated by '
+from UpdateTestChecks import common
 
 SUBST = {
     '%clang': [],
     '%clang_cc1': ['-cc1'],
     '%clangxx': ['--driver-mode=g++'],
 }
 
 def get_line2spell_and_mangled(args, clang_args):
def get_line2spell_and_mangled(args, clang_args):
 
   for line, func_name in sorted(ret.items()):
     common.debug('line {}: found function {}'.format(line+1, func_name), file=sys.stderr)
   if not ret:
     common.warn('Did not find any functions using', ' '.join(json_dump_args))
   return ret
 
 
+def str_to_commandline(value):
+  if not value:
+    return []
+  return shlex.split(value)
+
 def config():
   parser = argparse.ArgumentParser(
       description=__doc__,
       formatter_class=argparse.RawTextHelpFormatter)
   parser.add_argument('--llvm-bin', help='llvm $prefix/bin path')
   parser.add_argument('--clang',
                       help='"clang" executable, defaults to $llvm_bin/clang')
-  parser.add_argument('--clang-args',
+  parser.add_argument('--clang-args', default=[], type=str_to_commandline,
                       help='Space-separated extra args to clang, e.g. --clang-args=-v')
   parser.add_argument('--opt',
                       help='"opt" executable, defaults to $llvm_bin/opt')
   parser.add_argument(
       '--functions', nargs='+', help='A list of function name regexes. '
       'If specified, update CHECK lines for functions matching at least one regex')
   parser.add_argument(
       '--x86_extra_scrub', action='store_true',
       help='Use more regex for x86 matching to reduce diffs between various subtargets')
   parser.add_argument('--function-signature', action='store_true',
                       help='Keep function signature information around for the check line')
   parser.add_argument('tests', nargs='+')
   args = common.parse_commandline_args(parser)
-  args.clang_args = shlex.split(args.clang_args or '')
 
   if args.clang is None:
     if args.llvm_bin is None:
       args.clang = 'clang'
     else:
       args.clang = os.path.join(args.llvm_bin, 'clang')
   if not distutils.spawn.find_executable(args.clang):
     print('Please specify --llvm-bin or --clang', file=sys.stderr)
if args.opt is None:
     else:
       args.opt = os.path.join(args.llvm_bin, 'opt')
   if not distutils.spawn.find_executable(args.opt):
     # Many uses of this tool will not need an opt binary, because it's only
     # needed for updating a test that runs clang | opt | FileCheck. So we
     # defer this error message until we find that opt is actually needed.
     args.opt = None
 
-  return args
+  return args, parser
 
 
 def get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict):
   # TODO Clean up duplication of asm/common build_function_body_dictionary
   # Invoke external tool and extract function bodies.
   raw_tool_output = common.invoke_tool(args.clang, clang_args, filename)
   for extra_command in extra_commands:
     extra_args = shlex.split(extra_command)
common.build_function_body_dictionary(
             raw_tool_output, prefixes, func_dict, args.verbose, args.function_signature)
   else:
     print('The clang command line should include -emit-llvm as asm tests '
           'are discouraged in Clang testsuite.', file=sys.stderr)
     sys.exit(1)
 
 
 def main():
-  args = config()
+  initial_args, parser = config()
   script_name = os.path.basename(__file__)
-  autogenerated_note = (ADVERT + 'utils/' + script_name)
-
-  for filename in args.tests:
-    with open(filename) as f:
-      input_lines = [l.rstrip() for l in f]
-
-    first_line = input_lines[0] if input_lines else ""
-    if 'autogenerated' in first_line and script_name not in first_line:
-      common.warn("Skipping test which wasn't autogenerated by " + script_name, filename)
-      continue
-
-    if args.update_only:
-      if not first_line or 'autogenerated' not in first_line:
-        common.warn("Skipping test which isn't autogenerated: " + filename)
-        continue
-
-    # Extract RUN lines.
-    run_lines = common.find_run_lines(filename, input_lines)
 
+  for ti in common.itertests(initial_args.tests, parser, 'utils/' + script_name,
+                             comment_prefix='//'):
     # Build a list of clang command lines and check prefixes from RUN lines.
     run_list = []
     line2spell_and_mangled_list = collections.defaultdict(list)
-    for l in run_lines:
+    for l in ti.run_lines:
       commands = [cmd.strip() for cmd in l.split('|')]
 
       triple_in_cmd = None
       m = common.TRIPLE_ARG_RE.search(commands[0])
       if m:
         triple_in_cmd = m.groups()[0]
 
       # Apply %clang substitution rule, replace %s by `filename`, and append args.clang_args
       clang_args = shlex.split(commands[0])
       if clang_args[0] not in SUBST:
         print('WARNING: Skipping non-clang RUN line: ' + l, file=sys.stderr)
         continue
       clang_args[0:1] = SUBST[clang_args[0]]
-      clang_args = [filename if i == '%s' else i for i in clang_args] + args.clang_args
+      clang_args = [ti.path if i == '%s' else i for i in clang_args] + ti.args.clang_args
 
       # Permit piping the output through opt
       if not (len(commands) == 2 or
               (len(commands) == 3 and commands[1].startswith('opt'))):
         print('WARNING: Skipping non-clang RUN line: ' + l, file=sys.stderr)
 
       # Extract -check-prefix in FileCheck args
       filecheck_cmd = commands[-1]
       common.verify_filecheck_prefixes(filecheck_cmd)
       if not filecheck_cmd.startswith('FileCheck '):
         print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
         continue
       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']
       run_list.append((check_prefixes, clang_args, commands[1:-1], triple_in_cmd))
 
-    # Strip CHECK lines which are in `prefix_set`, update test file.
-    prefix_set = set([prefix for p in run_list for prefix in p[0]])
-    input_lines = []
-    with open(filename, 'r+') as f:
-      for line in f:
-        m = common.CHECK_RE.match(line)
-        if not (m and m.group(1) in prefix_set) and line != '//\n':
-          input_lines.append(line)
-      f.seek(0)
-      f.writelines(input_lines)
-      f.truncate()
-
     # Execute clang, generate LLVM IR, and extract functions.
     func_dict = {}
     for p in run_list:
       prefixes = p[0]
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
     for prefixes, clang_args, extra_commands, triple_in_cmd in run_list:
       common.debug('Extracted clang cmd: clang {}'.format(clang_args))
       common.debug('Extracted FileCheck prefixes: {}'.format(prefixes))
 
-      get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict)
+      get_function_body(ti.args, ti.path, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict)
 
       # Invoke clang -Xclang -ast-dump=json to get mapping from start lines to
       # mangled names. Forward all clang args for now.
-      for k, v in get_line2spell_and_mangled(args, clang_args).items():
+      for k, v in get_line2spell_and_mangled(ti.args, clang_args).items():
         line2spell_and_mangled_list[k].append(v)
 
-    output_lines = [autogenerated_note]
-    for idx, line in enumerate(input_lines):
-      # Discard any previous script advertising.
-      if line.startswith(ADVERT):
-        continue
+    prefix_set = set([prefix for p in run_list for prefix in p[0]])
+    output_lines = []
+    for line_info in ti.iterlines(output_lines):
+      idx = line_info.line_number
+      line = line_info.line
+      args = line_info.args
+      include_line = True
+      m = common.CHECK_RE.match(line)
+      if m and m.group(1) in prefix_set:
+        continue  # Don't append the existing CHECK lines
       if idx in line2spell_and_mangled_list:
         added = set()
         for spell, mangled in line2spell_and_mangled_list[idx]:
           # One line may contain multiple function declarations.
           # Skip if the mangled name has been added before.
           # The line number may come from an included file,
           # we simply require the spelling name to appear on the line
           # to exclude functions from other files.
           if mangled in added or spell not in line:
             continue
           if args.functions is None or any(re.search(regex, spell) for regex in args.functions):
+            last_line = output_lines[-1].strip()
+            while last_line == '//':
+              # Remove the comment line since we will generate a new  comment
+              # line as part of common.add_ir_checks()
+              output_lines.pop()
+              last_line = output_lines[-1].strip()
             if added:
               output_lines.append('//')
             added.add(mangled)
             common.add_ir_checks(output_lines, '//', run_list, func_dict, mangled,
                                  False, args.function_signature)
-      output_lines.append(line.rstrip('\n'))
+            if line.rstrip('\n') == '//':
+              include_line = False
 
+      if include_line:
+        output_lines.append(line.rstrip('\n'))
 
-    common.debug('Writing %d lines to %s...' % (len(output_lines), filename))
-    with open(filename, 'wb') as f:
+    common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
+    with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())

llvm/utils/update_llc_test_checks.py

 #!/usr/bin/env python3
 
 """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 glob
-import os         # Used to advertise this file's name ("autogenerated_note").
-import string
-import subprocess
-import sys
-import re
+import os  # Used to advertise this file's name ("autogenerated_note").
 
 from UpdateTestChecks import asm, common
 
-ADVERT = ' NOTE: Assertions have been autogenerated by '
 # llc is the only llc-like in the LLVM tree but downstream forks can add
 # additional ones here if they have them.
-LLC_LIKE_TOOLS = ('llc',) 
+LLC_LIKE_TOOLS = ('llc',)
 
 def main():
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('--llc-binary', default=None,
                       help='The "llc" binary to use to generate the test case')
   parser.add_argument(
       '--function', help='The function in the test file to update')
   parser.add_argument(
       '--extra_scrub', action='store_true',
       help='Always use additional regex to further reduce diffs between various subtargets')
   parser.add_argument(
       '--x86_scrub_rip', action='store_true', default=True,
       help='Use more regex for x86 matching to reduce diffs between various subtargets')
   parser.add_argument(
       '--no_x86_scrub_rip', action='store_false', dest='x86_scrub_rip')
   parser.add_argument(
       '--no_x86_scrub_mem_shuffle', action='store_true', default=False,
       help='Reduce scrubbing shuffles with memory operands')
   parser.add_argument('tests', nargs='+')
-  args = common.parse_commandline_args(parser)
+  initial_args = common.parse_commandline_args(parser)
 
   script_name = os.path.basename(__file__)
 
-  test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
-  for test in test_paths:
-    with open(test) as f:
-      input_lines = [l.rstrip() for l in f]
-
-    first_line = input_lines[0] if input_lines else ""
-    if 'autogenerated' in first_line and script_name not in first_line:
-      common.warn("Skipping test which wasn't autogenerated by " + script_name, test)
-      continue
-
-    if args.update_only:
-      if not first_line or 'autogenerated' not in first_line:
-        common.warn("Skipping test which isn't autogenerated: " + test)
-        continue
-
+  for ti in common.itertests(initial_args.tests, parser,
+                             script_name='utils/' + script_name):
     triple_in_ir = None
-    for l in input_lines:
+    for l in ti.input_lines:
       m = common.TRIPLE_IR_RE.match(l)
       if m:
         triple_in_ir = m.groups()[0]
         break
 
-    run_lines = common.find_run_lines(test, input_lines)
     run_list = []
-    for l in run_lines:
+    for l in ti.run_lines:
       if '|' not in l:
         common.warn('Skipping unparseable RUN line: ' + l)
         continue
 
       commands = [cmd.strip() for cmd in l.split('|', 1)]
       llc_cmd = commands[0]
       llc_tool = llc_cmd.split(' ')[0]
 
for l in ti.run_lines:
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
         common.warn('Skipping non-FileChecked RUN line: ' + l)
         continue
 
       llc_cmd_args = llc_cmd[len(llc_tool):].strip()
       llc_cmd_args = llc_cmd_args.replace('< %s', '').replace('%s', '').strip()
-      if test.endswith('.mir'):
+      if ti.path.endswith('.mir'):
         llc_cmd_args += ' -x mir'
       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, march_in_cmd))
 
-    if test.endswith('.mir'):
-      comment_sym = '#'
+    if ti.path.endswith('.mir'):
       check_indent = '  '
     else:
-      comment_sym = ';'
       check_indent = ''
-    autogenerated_note = (comment_sym + ADVERT + 'utils/' + script_name)
 
     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, march_in_cmd in run_list:
       common.debug('Extracted LLC cmd:', llc_tool, llc_args)
       common.debug('Extracted FileCheck prefixes:', str(prefixes))
 
-      raw_tool_output = common.invoke_tool(args.llc_binary or llc_tool,
-                                           llc_args, test)
+      raw_tool_output = common.invoke_tool(ti.args.llc_binary or llc_tool, llc_args, ti.path)
       triple = triple_in_cmd or triple_in_ir
       if not triple:
         triple = asm.get_triple_from_march(march_in_cmd)
 
-      asm.build_function_body_dictionary_for_triple(args, raw_tool_output,
+      asm.build_function_body_dictionary_for_triple(ti.args, raw_tool_output,
           triple, 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]])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
-    output_lines.append(autogenerated_note)
-
-    for input_line in input_lines:
+    for input_info in ti.iterlines(output_lines):
+      input_line = input_info.line
+      args = input_info.args
       if is_in_function_start:
         if input_line == '':
           continue
         if input_line.lstrip().startswith(';'):
           m = common.CHECK_RE.match(input_line)
           if not m or m.group(1) not in prefix_set:
             output_lines.append(input_line)
             continue
 
         # Print out the various check lines here.
         asm.add_asm_checks(output_lines, check_indent + ';', run_list, func_dict, func_name)
         is_in_function_start = False
 
       if is_in_function:
         if common.should_add_line_to_output(input_line, prefix_set):
           # This input line of the function body will go as-is into the output.
           output_lines.append(input_line)
         else:
           continue
         if input_line.strip() == '}':
           is_in_function = False
         continue
 
-      # Discard any previous script advertising.
-      if input_line.startswith(comment_sym + ADVERT):
-        continue
-
       # If it's outside a function, it just gets copied to the output.
       output_lines.append(input_line)
 
       m = common.IR_FUNCTION_RE.match(input_line)
       if not m:
         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
 
-    common.debug('Writing %d lines to %s...' % (len(output_lines), test))
+    common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
 
-    with open(test, 'wb') as f:
+    with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
 
 if __name__ == '__main__':
   main()