[UpdateTestChecks] Update tests option

[xbolva00]

Summary

Port of new feature introduced https://reviews.llvm.org/D65610 to other update scripts.

• update_*_checks.py: add an alias -u for --update-only
• port --update-only to other update_*_test_checks.py scripts
• update script aborts if the test file was generated by another update_*_test_checks.py utility

[xbolva00]

Testing LLC updater now.. looks fine.

Use case: ./update_llc_test_checks.py -u ../test/CodeGen/X86/*.ll

[MaskRay]

utils/UpdateTestChecks/common.py

76 ↗

(On Diff #213547)

This file is indented by 2.

297 ↗

(On Diff #213547)

I don't know if a common function is useful, ideally an update*.py utility should abort if the test file was generated by another update*.py utility, e.g.

update_llc_test_checks.py should abort if the file was generated by update_test_checks.py.

utils/update_analyze_test_checks.py

102 ↗

(On Diff #213547)

Use + to concatenate two strings.

utils/update_cc_test_checks.py

139 ↗

(On Diff #213547)

Use + to concatenate two strings.

162 ↗

(On Diff #213547)

If it is clear that l in '... %s' % (l,) is a str, the pattern should be converted to

'... ' + l for clarity.

%s is not printf C string, it is str() applied on the expression... (So '%s' % ([1,2,3],) works)

utils/update_llc_test_checks.py

84 ↗

(On Diff #213547)

Use + to concatenate two strings.

utils/update_mir_test_checks.py

117 ↗

(On Diff #213547)

Use + to concatenate two strings.

[xbolva00]

Addressed review notes.

[xbolva00]

utils/UpdateTestChecks/common.py

297 ↗

(On Diff #213547)

Yes, such checker would be useful addition. I will do it.

[xbolva00]

utils/UpdateTestChecks/common.py

297 ↗

(On Diff #213547)

Done.

[MaskRay]

The patch does 3 things now:

• update_test_checks.py: add an alias -u for --update-only
• port --update-only to other update_*_test_checks.py scripts
• the script aborts if the test file was generated by another update_*_test_checks.py utility

The description should probably reflect the situation.

[xbolva00]

Thanks

[lkail]

llvm/trunk/utils/update_analyze_test_checks.py

107

Hi @xbolva00 , I don't understand why skipping lines without '|'. There are still many autogenerated test cases in backend written kinda like

; RUN: llc ... \
; RUN: | FileCheck ...

[lkail]

This comment was removed by lkail.

[lkail]

llvm/trunk/utils/update_analyze_test_checks.py

107

Sorry for disturbing you, https://reviews.llvm.org/D70941 should have solved my concern.

llvm/trunk/utils/UpdateTestChecks/common.py

 
 SCRUB_LEADING_WHITESPACE_RE = re.compile(r'^(\s+)')
 SCRUB_WHITESPACE_RE = re.compile(r'(?!^(|  \w))[ \t]+', flags=re.M)
 SCRUB_TRAILING_WHITESPACE_RE = re.compile(r'[ \t]+$', flags=re.M)
 SCRUB_KILL_COMMENT_RE = re.compile(r'^ *#+ +kill:.*\n')
 SCRUB_LOOP_COMMENT_RE = re.compile(
     r'# =>This Inner Loop Header:.*|# in Loop:.*', flags=re.M)
 
+
+def error(msg, test_file=None):
+  if test_file:
+    msg = '{}: {}'.format(msg, test_file)
+  print('ERROR: {}'.format(msg), file=sys.stderr)
+
+def warn(msg, test_file=None):
+  if test_file:
+    msg = '{}: {}'.format(msg, test_file)
+  print('WARNING: {}'.format(msg), file=sys.stderr)
+
 def scrub_body(body):
   # 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)
   # Strip trailing whitespace.
   body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body)
if not m:
       continue
     func = m.group('func')
     body = m.group('body')
     scrubbed_body = do_scrub(body, scrubber, scrubber_args, extra = False)
     scrubbed_extra = do_scrub(body, scrubber, scrubber_args, extra = True)
     if 'analysis' in m.groupdict():
       analysis = m.group('analysis')
       if analysis.lower() != 'cost model analysis':
-        print('WARNING: Unsupported analysis mode: %r!' % (analysis,), file=sys.stderr)
+        warn('Unsupported analysis mode: %r!' % (analysis,))
     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('Processing function: ' + func, file=sys.stderr)
       for l in scrubbed_body.splitlines():
         print('  ' + l, file=sys.stderr)
     for prefix in prefixes:
       if func in func_dict[prefix] and str(func_dict[prefix][func]) != scrubbed_body:
         if func_dict[prefix][func] and func_dict[prefix][func].extrascrub == scrubbed_extra:
           func_dict[prefix][func].scrub = scrubbed_extra
           continue
         else:
           if prefix == prefixes[-1]:
-            print('WARNING: Found conflicting asm under the '
-                                 'same prefix: %r!' % (prefix,), file=sys.stderr)
+            warn('Found conflicting asm under the same prefix: %r!' % (prefix,))
           else:
             func_dict[prefix][func] = None
             continue
 
       func_dict[prefix][func] = function_body(scrubbed_body, scrubbed_extra)
 
 ##### Generator of LLVM IR CHECK lines
 
def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
   add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, True)
 
 
 def check_prefix(prefix):
   if not PREFIX_RE.match(prefix):
         hint = ""
         if ',' in prefix:
           hint = " Did you mean '--check-prefixes=" + prefix + "'?"
-        print(("WARNING: Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %
-              (prefix), file=sys.stderr)
+        warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %
+             (prefix))
 
 
 def verify_filecheck_prefixes(fc_cmd):
   fc_cmd_parts = fc_cmd.split()
   for part in fc_cmd_parts:
     if "check-prefix=" in part:
       prefix = part.split('=', 1)[1]
       check_prefix(prefix)
     elif "check-prefixes=" in part:
       prefixes = part.split('=', 1)[1].split(',')
       for prefix in prefixes:
         check_prefix(prefix)
         if prefixes.count(prefix) > 1:
-          print("WARNING: Supplied prefix '%s' is not unique in the prefix list." %
-                (prefix,), file=sys.stderr)
+          warn("Supplied prefix '%s' is not unique in the prefix list." % (prefix,))

llvm/trunk/utils/update_analyze_test_checks.py

def main():
   from argparse import RawTextHelpFormatter
   parser = argparse.ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
   parser.add_argument('-v', '--verbose', action='store_true',
                       help='Show verbose output')
   parser.add_argument('--opt-binary', default='opt',
                       help='The opt binary used to generate the test case')
   parser.add_argument(
       '--function', help='The function in the test file to update')
+  parser.add_argument('-u', '--update-only', action='store_true',
+                      help='Only update test if it was already autogened')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
-  autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
+  script_name = os.path.basename(__file__)
+  autogenerated_note = (ADVERT + 'utils/' + script_name)
 
   opt_basename = os.path.basename(args.opt_binary)
   if (opt_basename != "opt"):
-    print('ERROR: Unexpected opt name: ' + opt_basename, file=sys.stderr)
+    common.error('Unexpected opt name: ' + opt_basename)
     sys.exit(1)
 
   test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
   for test in test_paths:
     if args.verbose:
       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]
 
+    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
+
     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('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
         print('  RUN: ' + l, file=sys.stderr)
 
     prefix_list = []
     for l in run_lines:
+      if '|' not in l:
+        common.warn('Skipping unparseable RUN line: ' + l)
+        continue
+
       (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
       common.verify_filecheck_prefixes(filecheck_cmd)
 
       if not tool_cmd.startswith(opt_basename + ' '):
-        print('WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l), file=sys.stderr)
+        common.warn('WSkipping non-%s RUN line: %s' % (opt_basename, l))
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
+        common.warn('Skipping non-FileChecked RUN line: ' + l)
         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:

llvm/trunk/utils/update_cc_test_checks.py

def config():
   parser.add_argument('--c-index-test',
                       help='"c-index-test" executable, defaults to $llvm_bin/c-index-test')
   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('-u', '--update-only', action='store_true',
+                      help='Only update test if it was already autogened')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
   args.clang_args = shlex.split(args.clang_args or '')
 
   if args.clang is None:
     if args.llvm_bin is None:
       args.clang = 'clang'
     else:
def get_function_body(args, filename, clang_args, prefixes, triple_in_cmd, func_dict):
   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()
-  autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
+  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.
     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:

llvm/trunk/utils/update_llc_test_checks.py

def main():
   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('-u', '--update-only', action='store_true',
+                      help='Only update test if it was already autogened')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
-  autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
+  script_name = os.path.basename(__file__)
+  autogenerated_note = (ADVERT + 'utils/' + script_name)
 
   test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
   for test in test_paths:
     if args.verbose:
       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]
     
+    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
+
     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('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
         print('  RUN: ' + l, file=sys.stderr)
 
     run_list = []
     for l in 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]
 
       triple_in_cmd = None
       m = common.TRIPLE_ARG_RE.search(llc_cmd)
       if m:
         triple_in_cmd = m.groups()[0]
 
       march_in_cmd = None
       m = common.MARCH_ARG_RE.search(llc_cmd)
       if m:
         march_in_cmd = m.groups()[0]
 
       filecheck_cmd = ''
       if len(commands) > 1:
         filecheck_cmd = commands[1]
       common.verify_filecheck_prefixes(filecheck_cmd)
       if not llc_cmd.startswith('llc '):
-        print('WARNING: Skipping non-llc RUN line: ' + l, file=sys.stderr)
+        common.warn('Skipping non-llc RUN line: ' + l)
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
+        common.warn('Skipping non-FileChecked RUN line: ' + l)
         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:

llvm/trunk/utils/update_mir_test_checks.py

def __getitem__(self, index):
         return [self.prefixes, self.cmd_args, self.triple][index]
 
 
 def log(msg, verbose=True):
     if verbose:
         print(msg, file=sys.stderr)
 
 
-def warn(msg, test_file=None):
-    if test_file:
-        msg = '{}: {}'.format(test_file, msg)
-    print('WARNING: {}'.format(msg), file=sys.stderr)
-
-
 def find_triple_in_ir(lines, verbose=False):
     for l in lines:
         m = common.TRIPLE_IR_RE.match(l)
         if m:
             return m.group(1)
     return None
 
 
if verbose:
             log('  RUN: {}'.format(l))
     return run_lines
 
 
 def build_run_list(test, run_lines, verbose=False):
     run_list = []
     all_prefixes = []
     for l in 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]
         filecheck_cmd = commands[1] if len(commands) > 1 else ''
         common.verify_filecheck_prefixes(filecheck_cmd)
 
         if not llc_cmd.startswith('llc '):
-            warn('Skipping non-llc RUN line: {}'.format(l), test_file=test)
+            common.warn('Skipping non-llc RUN line: {}'.format(l), test_file=test)
             continue
         if not filecheck_cmd.startswith('FileCheck '):
-            warn('Skipping non-FileChecked RUN line: {}'.format(l),
+            common.warn('Skipping non-FileChecked RUN line: {}'.format(l),
                  test_file=test)
             continue
 
         triple = None
         m = common.TRIPLE_ARG_RE.search(llc_cmd)
         if m:
             triple = m.group(1)
         # If we find -march but not -mtriple, use that.
for m in MIR_FUNC_RE.finditer(raw_tool_output):
         func = m.group('func')
         body = m.group('body')
         if verbose:
             log('Processing function: {}'.format(func))
             for l in body.splitlines():
                 log('  {}'.format(l))
         for prefix in prefixes:
             if func in func_dict[prefix] and func_dict[prefix][func] != body:
-                warn('Found conflicting asm for prefix: {}'.format(prefix),
+                common.warn('Found conflicting asm for prefix: {}'.format(prefix),
                      test_file=test)
             func_dict[prefix][func] = body
 
 
 def add_checks_for_function(test, output_lines, run_list, func_dict, func_name,
                             single_bb, verbose=False):
     printed_prefixes = set()
     for run in run_list:

 
 def add_check_lines(test, output_lines, prefix, func_name, single_bb,
                     func_body):
     if single_bb:
         # Don't bother checking the basic block label for a single BB
         func_body.pop(0)
 
     if not func_body:
-        warn('Function has no instructions to check: {}'.format(func_name),
+        common.warn('Function has no instructions to check: {}'.format(func_name),
              test_file=test)
         return
 
     first_line = func_body[0]
     indent = len(first_line) - len(first_line.lstrip(' '))
     # A check comment, indented the appropriate amount
     check = '{:>{}}; {}'.format('', indent, prefix)
 

 def should_add_line_to_output(input_line, prefix_set):
     # Skip any check lines that we're handling.
     m = common.CHECK_RE.match(input_line)
     if m and m.group(1) in prefix_set:
         return False
     return True
 
 
-def update_test_file(llc, test, remove_common_prefixes=False, verbose=False):
-    log('Scanning for RUN lines in test file: {}'.format(test), verbose)
+def update_test_file(args, test):
+    log('Scanning for RUN lines in test file: {}'.format(test), args.verbose)
     with open(test) as fd:
         input_lines = [l.rstrip() for l in fd]
 
-    triple_in_ir = find_triple_in_ir(input_lines, verbose)
-    run_lines = find_run_lines(test, input_lines, verbose)
-    run_list, common_prefixes = build_run_list(test, run_lines, verbose)
+    script_name = os.path.basename(__file__)
+    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)
+        return
+
+    if args.update_only:
+      if not first_line or 'autogenerated' not in first_line:
+        common.warn("Skipping test which isn't autogenerated: " + test)
+        return
+
+    triple_in_ir = find_triple_in_ir(input_lines, args.verbose)
+    run_lines = find_run_lines(test, input_lines, args.verbose)
+    run_list, common_prefixes = build_run_list(test, run_lines, args.verbose)
 
-    simple_functions = find_functions_with_one_bb(input_lines, verbose)
+    simple_functions = find_functions_with_one_bb(input_lines, args.verbose)
 
     func_dict = {}
     for run in run_list:
         for prefix in run.prefixes:
             func_dict.update({prefix: dict()})
     for prefixes, llc_args, triple_in_cmd in run_list:
-        log('Extracted LLC cmd: llc {}'.format(llc_args), verbose)
-        log('Extracted FileCheck prefixes: {}'.format(prefixes), verbose)
+        log('Extracted LLC cmd: llc {}'.format(llc_args), args.verbose)
+        log('Extracted FileCheck prefixes: {}'.format(prefixes), args.verbose)
 
-        raw_tool_output = llc(llc_args, test)
+        raw_tool_output = args.llc(llc_args, test)
         if not triple_in_cmd and not triple_in_ir:
-            warn('No triple found: skipping file', test_file=test)
+            common.warn('No triple found: skipping file', test_file=test)
             return
 
         build_function_body_dictionary(test, raw_tool_output,
                                        triple_in_cmd or triple_in_ir,
-                                       prefixes, func_dict, verbose)
+                                       prefixes, func_dict, args.verbose)
 
     state = 'toplevel'
     func_name = None
     prefix_set = set([prefix for run in run_list for prefix in run.prefixes])
-    log('Rewriting FileCheck prefixes: {}'.format(prefix_set), verbose)
+    log('Rewriting FileCheck prefixes: {}'.format(prefix_set), args.verbose)
 
-    if remove_common_prefixes:
+    if args.remove_common_prefixes:
         prefix_set.update(common_prefixes)
     elif common_prefixes:
-        warn('Ignoring common prefixes: {}'.format(common_prefixes),
+        common.warn('Ignoring common prefixes: {}'.format(common_prefixes),
              test_file=test)
 
     comment_char = '#' if test.endswith('.mir') else ';'
     autogenerated_note = ('{} NOTE: Assertions have been autogenerated by '
-                          'utils/{}'.format(comment_char,
-                                            os.path.basename(__file__)))
+                          'utils/{}'.format(comment_char, script_name))
     output_lines = []
     output_lines.append(autogenerated_note)
 
     for input_line in input_lines:
         if input_line == autogenerated_note:
             continue
 
         if state == 'toplevel':
for input_line in input_lines:
             if m:
                 if func_name in simple_functions:
                     # If there's only one block, put the checks inside it
                     state = 'mir function prefix'
                     continue
                 state = 'mir function body'
                 add_checks_for_function(test, output_lines, run_list,
                                         func_dict, func_name, single_bb=False,
-                                        verbose=verbose)
+                                        verbose=args.verbose)
         elif state == 'mir function prefix':
             m = MIR_PREFIX_DATA_RE.match(input_line)
             if not m:
                 state = 'mir function body'
                 add_checks_for_function(test, output_lines, run_list,
                                         func_dict, func_name, single_bb=True,
-                                        verbose=verbose)
+                                        verbose=args.verbose)
 
             if should_add_line_to_output(input_line, prefix_set):
                 output_lines.append(input_line)
         elif state == 'mir function body':
             if input_line.strip() == '...':
                 state = 'toplevel'
                 func_name = None
             if should_add_line_to_output(input_line, prefix_set):
                 output_lines.append(input_line)
         elif state == 'ir function prefix':
             m = IR_PREFIX_DATA_RE.match(input_line)
             if not m:
                 state = 'ir function body'
                 add_checks_for_function(test, output_lines, run_list,
                                         func_dict, func_name, single_bb=False,
-                                        verbose=verbose)
+                                        verbose=args.verbose)
 
             if should_add_line_to_output(input_line, prefix_set):
                 output_lines.append(input_line)
         elif state == 'ir function body':
             if input_line.strip() == '}':
                 state = 'toplevel'
                 func_name = None
             if should_add_line_to_output(input_line, prefix_set):
                 output_lines.append(input_line)
 
 
-    log('Writing {} lines to {}...'.format(len(output_lines), test), verbose)
+    log('Writing {} lines to {}...'.format(len(output_lines), test), args.verbose)
 
     with open(test, 'wb') as fd:
         fd.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
 
 def main():
     parser = argparse.ArgumentParser(
         description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
     parser.add_argument('-v', '--verbose', action='store_true',
                         help='Show verbose output')
     parser.add_argument('--llc-binary', dest='llc', default='llc', type=LLC,
                         help='The "llc" binary to generate the test case with')
     parser.add_argument('--remove-common-prefixes', action='store_true',
                         help='Remove existing check lines whose prefixes are '
                              'shared between multiple commands')
+    parser.add_argument('-u', '--update-only', action='store_true',
+                        help='Only update test if it was already autogened')
     parser.add_argument('tests', nargs='+')
     args = parser.parse_args()
 
     test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
     for test in test_paths:
         try:
-            update_test_file(args.llc, test, args.remove_common_prefixes,
-                             verbose=args.verbose)
+            update_test_file(args, test)
         except Exception:
-            warn('Error processing file', test_file=test)
+            common.warn('Error processing file', test_file=test)
             raise
 
 
 if __name__ == '__main__':
   main()

llvm/trunk/utils/update_test_checks.py

def main():
   from argparse import RawTextHelpFormatter
   parser = argparse.ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
   parser.add_argument('-v', '--verbose', action='store_true',
                       help='Show verbose output')
   parser.add_argument('--opt-binary', default='opt',
                       help='The opt binary used to generate the test case')
   parser.add_argument(
       '--function', help='The function in the test file to update')
-  parser.add_argument('--update-only', action='store_true',
+  parser.add_argument('-u', '--update-only', action='store_true',
                       help='Only update test if it was already autogened')
   parser.add_argument('tests', nargs='+')
   args = parser.parse_args()
 
-  autogenerated_note = (ADVERT + 'utils/' + os.path.basename(__file__))
+  script_name = os.path.basename(__file__)
+  autogenerated_note = (ADVERT + 'utils/' + script_name)
 
   opt_basename = os.path.basename(args.opt_binary)
   if not re.match(r'^opt(-\d+)?$', opt_basename):
-    print('ERROR: Unexpected opt name: ' + opt_basename, file=sys.stderr)
+    common.error('Unexpected opt name: ' + opt_basename)
     sys.exit(1)
   opt_basename = 'opt'
 
   test_paths = []
   for test in args.tests:
     if not glob.glob(test):
-      print("WARNING: Test file '%s' was not found. Ignoring it." % (test,), file=sys.stderr)
+      common.warn("Test file '%s' was not found. Ignoring it." % (test,))
       continue
     test_paths.append(test)
 
   for test in test_paths:
     if args.verbose:
       print('Scanning for RUN lines in test file: ' + test, file=sys.stderr)
     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 len(input_lines) == 0 or 'autogenerated' not in input_lines[0]:
-        print("Skipping test which isn't autogenerated: " + test, file=sys.stderr)
+      if not first_line or 'autogenerated' not in first_line:
+        common.warn("Skipping test which isn't autogenerated: " + test)
         continue
 
     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('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
       for l in run_lines:
         print('  RUN: ' + l, file=sys.stderr)
 
     prefix_list = []
     for l in run_lines:
       if '|' not in l:
-        print('WARNING: Skipping unparseable RUN line: ' + l, file=sys.stderr)
+        common.warn('Skipping unparseable RUN line: ' + l)
         continue
 
       (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
       common.verify_filecheck_prefixes(filecheck_cmd)
       if not tool_cmd.startswith(opt_basename + ' '):
-        print('WARNING: Skipping non-%s RUN line: %s' % (opt_basename, l), file=sys.stderr)
+        common.warn('Skipping non-%s RUN line: %s' % (opt_basename, l))
         continue
 
       if not filecheck_cmd.startswith('FileCheck '):
-        print('WARNING: Skipping non-FileChecked RUN line: ' + l, file=sys.stderr)
+        common.warn('Skipping non-FileChecked RUN line: ' + l)
         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: