[UTC] Add --version argument

[nikic]

Summary

We have a number of pending changes to update_test_checks.py (and friends) that are essentially blocked on test churn: If the output of UTC for an existing flag combination changes, then the next time a test is regenerated, it will contain many spurious changes. This makes changes to UTC default behavior essentially impossible.

Examples of such changes are:

• D133943/D142373 want --function-signature to also check the return type/attributes.
• D139006/D140212 want to make --function-signature the default behavior.
• D142452 wants to add wildcards for block labels.

This patch tries to resolve this issue by adding a --version argument, which works as follows:

• When regenerating an old test, the default version is 1.
• When generating a new test, the default version is the newest.
• When an explicit version is specified, that of course wins.

This means that any currently existing tests will keep using --version 1 format, while any new tests will automatically embed --version 2 (or whatever the latest is), and then keep using that test format from then on.

[nikic]

Add missing test file.

[asb]

My initial reaction is that this is a nice solution to the problem - thank you! The main practical challenge I see is the the one you suggest in the summary - that it might not be easy to decide when it's "worth" introducing a new version, and there might be pressure in practice to group together multiple changes at once.

I'm interested to hear what others think.

[nhaehnle]

A couple of thoughts, not really having a fully-formed opinion on this yet:

• This is a nice trick to avoid the problem of test churn.
• I worry about the complexity of maintaining the different versions.
• In the past, I have on occasion made commits that only re-run UTC on existing tests, without making any other changes, and without posting them for review.
  • I added update_any_test_checks.py in part to make that sort of change easier (though the primary motivation was to just update tests after code changes)
  • I wonder if / to what extent normalizing and perhaps automating this process is an alternative solution.

[jsilvanus]

I would not be so worried about the complexity of having to maintain multiple version formats -- we can think of the version flag as setting defaults for command-line options that alter the test format.
We already have such options (e.g. mentioned --function-signature), so this is not new in principle, it just provides a convenient means to set these.

On the implementation side, I'm wondering whether it would be better to avoid directly checking version in the implementation, and instead derive some options (similar to args, or even args itself?) from the version and then only use that?
For example, if some old version introduced several changes (to avoid "version churn"), it is later probably easier to later remove support for one of them is there is a dedicated internal flag for each change.

[asb]

In D142473#4077336, @nhaehnle wrote:

• In the past, I have on occasion made commits that only re-run UTC on existing tests, without making any other changes, and without posting them for review.
  • I added update_any_test_checks.py in part to make that sort of change easier (though the primary motivation was to just update tests after code changes)
  • I wonder if / to what extent normalizing and perhaps automating this process is an alternative solution.

This is a good point, and worrying less about churn to existing tests is I think not a bad option. It's natural to want to compare such changes to other automated changes like code reformatting, but I think in practice it's very different - as the only changes are to tool-generated lines, it doesn't really cause the same issues with merge conflicts.

[nikic]

In D142473#4077309, @asb wrote:

My initial reaction is that this is a nice solution to the problem - thank you! The main practical challenge I see is the the one you suggest in the summary - that it might not be easy to decide when it's "worth" introducing a new version, and there might be pressure in practice to group together multiple changes at once.

I think from a maintenance perspective, it actually makes little difference whether these are in one version or in three. I believe the implementation of each change is essentially orthogonal, and would not become substantially simpler (or simpler at all?) when combined in one version. So this would mostly be a cosmetic question for me.

Maybe worth mentioning that I don't think every change to UTC output needs a version bump: Only those that could cause significant churn. For example, I don't think we should bump the version every time we add support for recognizing some new metadata, or other changes that don't affect many tests.

In D142473#4077336, @nhaehnle wrote:

• In the past, I have on occasion made commits that only re-run UTC on existing tests, without making any other changes, and without posting them for review.

Yes, this isn't an unusual thing to do. Generally if you either hit a test that hasn't been converted yet, or there have been some substantial changes to instruction names. It's mostly a question of scale. At this point, with most tests (that I care about) using UTC, this is something that one has to do only occasionally. With changes like "enable --function-signature by default" you have to do that for literally every single test you touch.

Marginally increased maintenance costs in UTC are something that affects only few people and few changes, while test churn affects everyone. The "regenerate test checks, see that some need a regenerated baseline, checkout main, rebuild, regenerate baseline, push the change, rebase, find out that somebody 'improved' an ADT header in the meantime, wait 15 minutes for the build to finish, go back to your actual work" cycle adds non-trivial overhead to development, and test management is already a big time-sink as it is.

[arichardson]

I like this approach, it's a lot less hacky than my attempt to default function signatures to on. I'll rebase that to check for version>1 instead.

I'm not sure if this should include the change to match full lines though, I think that should be a separate commit (but the implementation looks fine to me).

[nikic]

Only add the --version flag, don't implement any behavior change in this revision. As such, the default version stays at 1 and this is a no-op for now.

Future changes should bump the DEFAULT_VERSION constant and add a changelog entry.

[jsilvanus]

llvm/utils/UpdateTestChecks/common.py

24

Maybe mention that this is equivalent to no version specified.

141

default=DEFAULT_VERSION?

[nikic]

Additional comments

[nikic]

llvm/utils/UpdateTestChecks/common.py

141

This one should always stay at 1, added a comment to explain.

[jsilvanus]

llvm/utils/UpdateTestChecks/common.py

141

Makes sense, thanks.

[bogner]

Multiple people had concerns with the added complexity of having to maintain historical versions of behaviour here (a concern which I share), and absolutely none of them accepted the revision or commented after the comment that you don’t think it’ll be too bad in practice (with little explanation as to why).

I really don’t think it was appropriate to commit this without further discussion here.

[nikic]

Sorry, I did not interpret those comments as blocking concerns. Happy to revert this if they were intended as such -- this is effectively an NFC patch until DEFAULT_VERSION gets bumped, so we can still backtrack to a different approach (though I'm not aware of any that would have less maintenance burden).

clang/test/utils/update_cc_test_checks/lit.local.cfg

else:
 
     config.test_format = lit.formats.ShTest(execute_external=False)
     config.suffixes = ['.test']
 
     clang_path = os.path.join(config.clang_tools_dir, 'clang')
     extra_args = '--clang ' + shell_quote(clang_path)
     opt_path = os.path.join(config.llvm_tools_dir, 'opt')
     extra_args += ' --opt ' + shell_quote(opt_path)
+    # Specify an explicit default version in UTC tests, so that the --version
+    # embedded in UTC_ARGS does not change in all test expectations every time
+    # the default is bumped.
+    extra_args += ' --version=1'
     script_path = os.path.join(config.llvm_src_root, 'utils',
                                'update_cc_test_checks.py')
     assert os.path.isfile(script_path)
     # Windows: llvm-lit.py, Linux: llvm-lit
     if config.llvm_external_lit:
         lit = config.llvm_external_lit
     else:
         lit = shell_quote(glob.glob(os.path.join(config.llvm_tools_dir, 'llvm-lit*'))[0])

clang/test/utils/update_cc_test_checks/mangled_names.test

 ## 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.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
+## Also try --version 2
+# RUN: %update_cc_test_checks %t.c --function-signature --version 2
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.funcsig.v2.expected

llvm/test/tools/UpdateTestChecks/lit.local.cfg

except ImportError:
     from pipes import quote as shell_quote
 
 
 def add_update_script_substition(name, python_exe=config.python_executable,
                                  extra_args=''):
     assert name.startswith('%')
     script_path = os.path.join(config.llvm_src_root, 'utils', name[1:] + '.py')
     assert os.path.isfile(script_path)
+    # Specify an explicit default version in UTC tests, so that the --version
+    # embedded in UTC_ARGS does not change in all test expectations every time
+    # the default is bumped.
+    extra_args += ' --version=1'
     config.substitutions.append(
         (name, "'%s' %s %s" % (python_exe, script_path, extra_args)))
 
 
 config.test_format = lit.formats.ShTest(execute_external=False)
 config.suffixes = ['.test']
 
 llc_path = os.path.join(config.llvm_tools_dir, 'llc')

llvm/utils/UpdateTestChecks/asm.py

def get_run_handler(triple):
 
   return handler
 
 ##### Generator of assembly CHECK lines
 
 def add_checks(output_lines, comment_marker, prefix_list, func_dict,
                func_name, global_vars_seen_dict, is_filtered):
   # Label format is based on ASM string.
-  check_label_format = '{} %s-LABEL: %s%s%s'.format(comment_marker)
+  check_label_format = '{} %s-LABEL: %s%s%s%s'.format(comment_marker)
   return common.add_checks(output_lines, comment_marker, prefix_list, func_dict,
-                           func_name, check_label_format, True, False,
+                           func_name, check_label_format, True, False, 1,
                            global_vars_seen_dict, is_filtered=is_filtered)

llvm/utils/UpdateTestChecks/common.py

 
 
 _verbose = False
 _prefix_filecheck_ir_name = ''
 
 class Regex(object):
   """Wrap a compiled regular expression object to allow deep copy of a regexp.
   This is required for the deep copy done in do_scrub.
 
   """
   def __init__(self, regex):
     self.regex = regex
 
   def __deepcopy__(self, memo):
     result = copy.copy(self)
     result.regex = self.regex
     return result
parser.add_argument('--global-hex-value-regex', nargs='+', default=[],
                       help='List of regular expressions such that, for matching global value declarations, literal integer values should be encoded in hex in the associated FileCheck directives')
   # FIXME: in 3.9, we can use argparse.BooleanOptionalAction. At that point,
   # we need to rename the flag to just -generate-body-for-unused-prefixes.
   parser.add_argument('--no-generate-body-for-unused-prefixes',
                       action='store_false',
                       dest='gen_unused_prefix_body',
                       default=True,
                       help='Generate a function body that always matches for unused prefixes. This is useful when unused prefixes are desired, and it avoids needing to annotate each FileCheck as allowing them.')
+  parser.add_argument('--version', type=int, default=1,
+                      help='The version of output format')
   args = parser.parse_args()
   global _verbose, _global_value_regex, _global_hex_value_regex
   _verbose = args.verbose
   _global_value_regex = args.global_value_regex
   _global_hex_value_regex = args.global_hex_value_regex
   return args
 
 
for pattern in test_patterns:
     # On Windows we must expand the patterns ourselves.
     tests_list = glob.glob(pattern)
     if not tests_list:
       warn("Test file pattern '%s' was not found. Ignoring it." % (pattern,))
       continue
     for test in tests_list:
       with open(test) as f:
         input_lines = [l.rstrip() for l in f]
-      args = parser.parse_args()
+      first_line = input_lines[0] if input_lines else ""
+      is_regenerate = UTC_ADVERT in first_line
+
+      # If we're generating a new test, set the default version to the latest.
+      argv = sys.argv[:]
+      if not is_regenerate:
+        argv.insert(1, '--version=2')
+
+      args = parser.parse_args(argv[1:])
       if argparse_callback is not None:
         argparse_callback(args)
-      argv = sys.argv[:]
-      first_line = input_lines[0] if input_lines else ""
-      if UTC_ADVERT in first_line:
+      if is_regenerate:
         if script_name not in first_line and not args.force_update:
           warn("Skipping test which wasn't autogenerated by " + script_name, test)
           continue
         args, argv = check_for_command(first_line, parser, args, argv, argparse_callback)
       elif args.update_only:
         assert UTC_ADVERT not in first_line
         warn("Skipping test which isn't autogenerated: " + test)
         continue

 CHECK_RE = re.compile(r'^\s*(?://|[;#])\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL|-SAME|-EMPTY)?:')
 
 UTC_ARGS_KEY = 'UTC_ARGS:'
 UTC_ARGS_CMD = re.compile(r'.*' + UTC_ARGS_KEY + '\s*(?P<cmd>.*)\s*$')
 UTC_ADVERT = 'NOTE: Assertions have been autogenerated by '
 UNUSED_NOTE = 'NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:'
 
 OPT_FUNCTION_RE = re.compile(
-    r'^(\s*;\s*Function\sAttrs:\s(?P<attrs>[\w\s():,]+?))?\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w.$-]+?)\s*'
+    r'^(\s*;\s*Function\sAttrs:\s(?P<attrs>[\w\s():,]+?))?\s*define\s+(?P<funcdef_attrs_and_ret>[^@]*)@(?P<func>[\w.$-]+?)\s*'
     r'(?P<args_and_sig>\((\)|(.*?[\w.-]+?)\))[^{]*\{)\n(?P<body>.*?)^\}$',
     flags=(re.M | re.S))
 
 ANALYZE_FUNCTION_RE = re.compile(
     r'^\s*\'(?P<analysis>[\w\s-]+?)\'\s+for\s+function\s+\'(?P<func>[\w.$-]+?)\':'
     r'\s*\n(?P<body>.*)$',
     flags=(re.X | re.S))
 
def do_scrub(body, scrubber, scrubber_args, extra):
   if scrubber_args:
     local_args = copy.deepcopy(scrubber_args)
     local_args[0].extra_scrub = extra
     return scrubber(body, *local_args)
   return scrubber(body, *scrubber_args)
 
 # Build up a dictionary of all the function bodies.
 class function_body(object):
-  def __init__(self, string, extra, args_and_sig, attrs, func_name_separator):
+  def __init__(self, string, extra, funcdef_attrs_and_ret, args_and_sig, attrs, func_name_separator):
     self.scrub = string
     self.extrascrub = extra
+    self.funcdef_attrs_and_ret = funcdef_attrs_and_ret
     self.args_and_sig = args_and_sig
     self.attrs = attrs
     self.func_name_separator = func_name_separator
-  def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs, is_backend):
+  def is_same_except_arg_names(self, extrascrub, funcdef_attrs_and_ret, args_and_sig, attrs, is_backend):
     arg_names = set()
     def drop_arg_names(match):
       arg_names.add(match.group(variable_group_in_ir_value_match))
       if match.group(attribute_group_in_ir_value_match):
         attr = match.group(attribute_group_in_ir_value_match)
       else:
         attr = ''
       return match.group(1) + attr + match.group(match.lastindex)
     def repl_arg_names(match):
       if match.group(variable_group_in_ir_value_match) is not None and match.group(variable_group_in_ir_value_match) in arg_names:
         return match.group(1) + match.group(match.lastindex)
       return match.group(1) + match.group(2) + match.group(match.lastindex)
+    if self.funcdef_attrs_and_ret != funcdef_attrs_and_ret:
+      return False
     if self.attrs != attrs:
       return False
     ans0 = IR_VALUE_RE.sub(drop_arg_names, self.args_and_sig)
     ans1 = IR_VALUE_RE.sub(drop_arg_names, args_and_sig)
     if ans0 != ans1:
       return False
     if is_backend:
       # Check without replacements, the replacements are not applied to the
for m in function_re.finditer(raw_tool_output):
       # colon: `foo:`. But, for example, in nvptx it is a brace: `foo(`. If is_backend is
       # False, just assume that separator is an empty string.
       if is_backend:
         # Use ':' as default separator.
         func_name_separator = m.group('func_name_separator') if 'func_name_separator' in m.groupdict() else ':'
       else:
         func_name_separator = ''
       attrs = m.group('attrs') if self._check_attributes else ''
+      funcdef_attrs_and_ret = m.group('funcdef_attrs_and_ret') if self._record_args else ''
       # Determine if we print arguments, the opening brace, or nothing after the
       # function name
       if self._record_args and 'args_and_sig' in m.groupdict():
         args_and_sig = scrub_body(m.group('args_and_sig').strip())
       elif 'args_and_sig' in m.groupdict():
         args_and_sig = '('
       else:
         args_and_sig = ''
for m in function_re.finditer(raw_tool_output):
             # capture groups set.
             scrubbed_body = re.sub(func_repl, '{{' + func_repl + '}}',
                                    scrubbed_body)
 
         if func in self._func_dict[prefix]:
           if (self._func_dict[prefix][func] is not None and
               (str(self._func_dict[prefix][func]) != scrubbed_body or
                self._func_dict[prefix][func].args_and_sig != args_and_sig or
-               self._func_dict[prefix][func].attrs != attrs)):
+               self._func_dict[prefix][func].attrs != attrs or
+               self._func_dict[prefix][func].funcdef_attrs_and_ret != funcdef_attrs_and_ret)):
             if self._func_dict[prefix][func].is_same_except_arg_names(
                 scrubbed_extra,
+                funcdef_attrs_and_ret,
                 args_and_sig,
                 attrs,
                 is_backend):
               self._func_dict[prefix][func].scrub = scrubbed_extra
               self._func_dict[prefix][func].args_and_sig = args_and_sig
             else:
               # This means a previous RUN line produced a body for this function
               # that is different from the one produced by this current RUN line,
               # so the body can't be common across RUN lines. We use None to
               # indicate that.
               self._func_dict[prefix][func] = None
         else:
           if prefix not in self._processed_prefixes:
             self._func_dict[prefix][func] = function_body(
-                scrubbed_body, scrubbed_extra, args_and_sig, attrs,
-                func_name_separator)
+                scrubbed_body, scrubbed_extra, funcdef_attrs_and_ret,
+                args_and_sig, attrs, func_name_separator)
             self._func_order[prefix].append(func)
           else:
             # An earlier RUN line used this check prefixes but didn't produce
             # a body for this function. This happens in Clang tests that use
             # preprocesser directives to exclude individual functions from some
             # RUN lines.
             self._func_dict[prefix][func] = None
 
return generalize_check_lines_common(lines, is_analyze, vars_seen,
                                        global_vars_seen, ir_nameless_values,
                                        IR_VALUE_RE, False)
 
 def generalize_asm_check_lines(lines, vars_seen, global_vars_seen):
   return generalize_check_lines_common(lines, False, vars_seen,
                                        global_vars_seen, asm_nameless_values,
                                        ASM_VALUE_RE, True)
 
-def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_backend, is_analyze, global_vars_seen_dict, is_filtered):
+def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_backend, is_analyze, version, global_vars_seen_dict, is_filtered):
   # prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well.
   prefix_exclusions = set()
   printed_prefixes = []
   for p in prefix_list:
     checkprefixes = p[0]
     # If not all checkprefixes of this run line produced the function we cannot check for it as it does not
     # exist for this run line. A subset of the check prefixes might know about the function but only because
     # other run lines created it.
for checkprefix in checkprefixes:
         global_vars_seen_dict[checkprefix] = {}
 
       global_vars_seen_before = [key for key in global_vars_seen.keys()]
 
       vars_seen = set()
       printed_prefixes.append(checkprefix)
       attrs = str(func_dict[checkprefix][func_name].attrs)
       attrs = '' if attrs == 'None' else attrs
+      if version > 1:
+        funcdef_attrs_and_ret = func_dict[checkprefix][func_name].funcdef_attrs_and_ret
+      else:
+        funcdef_attrs_and_ret = ''
+
       if attrs:
         output_lines.append('%s %s: Function Attrs: %s' % (comment_marker, checkprefix, attrs))
       args_and_sig = str(func_dict[checkprefix][func_name].args_and_sig)
       if args_and_sig:
         args_and_sig = generalize_check_lines([args_and_sig], is_analyze, vars_seen, global_vars_seen)[0]
       func_name_separator = func_dict[checkprefix][func_name].func_name_separator
       if '[[' in args_and_sig:
-        output_lines.append(check_label_format % (checkprefix, func_name, '', func_name_separator))
+        output_lines.append(check_label_format % (checkprefix, funcdef_attrs_and_ret, func_name, '', func_name_separator))
         output_lines.append('%s %s-SAME: %s' % (comment_marker, checkprefix, args_and_sig))
       else:
-        output_lines.append(check_label_format % (checkprefix, func_name, args_and_sig, func_name_separator))
+        output_lines.append(check_label_format % (checkprefix, funcdef_attrs_and_ret, func_name, args_and_sig, func_name_separator))
       func_body = str(func_dict[checkprefix][func_name]).splitlines()
       if not func_body:
         # We have filtered everything.
         continue
 
       # For ASM output, just emit the check lines.
       if is_backend:
         body_start = 1
for checkprefix in checkprefixes:
       # Remember new global variables we have not seen before
       for key in global_vars_seen:
         if key not in global_vars_seen_before:
           global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
       break
   return printed_prefixes
 
 def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
-                  func_name, preserve_names, function_sig,
+                  func_name, preserve_names, function_sig, version,
                   global_vars_seen_dict, is_filtered):
   # Label format is based on IR string.
-  function_def_regex = 'define {{[^@]+}}' if function_sig else ''
+  if function_sig and version > 1:
+    function_def_regex = 'define %s'
+  elif function_sig:
+    function_def_regex = 'define {{[^@]+}}%s'
+  else:
+    function_def_regex = '%s'
   check_label_format = '{} %s-LABEL: {}@%s%s%s'.format(comment_marker, function_def_regex)
   return add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
-                    check_label_format, False, preserve_names, global_vars_seen_dict,
+                    check_label_format, False, preserve_names, version,
+                    global_vars_seen_dict,
                     is_filtered)
 
 def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, is_filtered):
-  check_label_format = '{} %s-LABEL: \'%s%s%s\''.format(comment_marker)
+  check_label_format = '{} %s-LABEL: \'%s%s%s%s\''.format(comment_marker)
   global_vars_seen_dict = {}
   return add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
-                    check_label_format, False, True, global_vars_seen_dict,
+                    check_label_format, False, True, 1, global_vars_seen_dict,
                     is_filtered)
 
 def build_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes):
   for nameless_value in itertools.chain(ir_nameless_values, asm_nameless_values):
     if nameless_value.global_ir_prefix is None:
       continue
 
     lhs_re_str = nameless_value.global_ir_prefix + nameless_value.global_ir_prefix_regexp

llvm/utils/UpdateTestChecks/isel.py

def get_run_handler(triple):
 
   return handler
 
 ##### Generator of iSel CHECK lines
 
 def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
                global_vars_seen_dict, is_filtered):
   # Label format is based on iSel string.
-  check_label_format = '{} %s-LABEL: %s%s%s'.format(comment_marker)
+  check_label_format = '{} %s-LABEL: %s%s%s%s'.format(comment_marker)
   return common.add_checks(output_lines, comment_marker, prefix_list, func_dict,
-                           func_name, check_label_format, True, False,
+                           func_name, check_label_format, True, False, 1,
                            global_vars_seen_dict, is_filtered=is_filtered)

llvm/utils/update_cc_test_checks.py

if include_generated_funcs:
 
       # Now generate all the checks.
       def check_generator(my_output_lines, prefixes, func):
         if '-emit-llvm' in clang_args:
           return common.add_ir_checks(my_output_lines, '//',
                                       prefixes,
                                       func_dict, func, False,
                                       ti.args.function_signature,
+                                      ti.args.version,
                                       global_vars_seen_dict,
                                       is_filtered=builder.is_filtered())
         else:
           return asm.add_checks(my_output_lines, '//',
                                 prefixes,
                                 func_dict, func, global_vars_seen_dict,
                                 is_filtered=builder.is_filtered())
 
else:
                   common.add_ir_checks(
                       output_lines,
                       '//',
                       filecheck_run_list,
                       func_dict,
                       mangled,
                       False,
                       args.function_signature,
+                      args.version,
                       global_vars_seen_dict,
                       is_filtered=builder.is_filtered()))
               if line.rstrip('\n') == '//':
                 include_line = False
 
         if include_line:
           output_lines.append(line.rstrip('\n'))
 

llvm/utils/update_test_checks.py

if include_generated_funcs:
               lambda my_output_lines, prefixes, func: common.add_ir_checks(
                   my_output_lines,
                   ';',
                   prefixes,
                   func_dict,
                   func,
                   False,
                   args.function_signature,
+                  args.version,
                   global_vars_seen_dict,
                   is_filtered=builder.is_filtered())))
     else:
       # "Normal" mode.
       for input_line_info in ti.iterlines(output_lines):
         input_line = input_line_info.line
         args = input_line_info.args
         if is_in_function_start:
else:
               common.add_ir_checks(
                   output_lines,
                   ';',
                   prefix_list,
                   func_dict,
                   func_name,
                   args.preserve_names,
                   args.function_signature,
+                  args.version,
                   global_vars_seen_dict,
                   is_filtered=builder.is_filtered()))
           is_in_function_start = False
 
         m = common.IR_FUNCTION_RE.match(input_line)
         if m and not has_checked_pre_function_globals:
           if args.check_globals:
             generated_prefixes.extend(