[update_llc_test_checks] Use FileCheck captures for MCInst/MCReg output

[arichardson]

Summary

To avoid test churn when backends add/rename new instructions/registers,
it makes sense to use FileCheck captures for the exact MCInst/Reg number.
This is motivated by D125307, where I use --asm-show-inst to differentiate
the output for multiple instructions with the same mnemonic.

This does not quite fix the churn issue yet: While files with the generated
checks will be immune to the numbers changing, the update script test
still suffers from this problem since the number is encoded in the
FileCheck variable name. I plan to address this in a follow-up patch.

[MaskRay]

This makes sense. There is one functionality loss: the check lines no line assert that two register numbers are identical and therefore cannot detect some bugs.

[arichardson]

Use FileCheck captures instead to ensure registers are matched

[MaskRay]

LGTM.

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/asm-show-inst.ll.expected

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ;; Check that we remove the exact MCInst number from --asm-verbose output
 ; RUN: llc < %s -mtriple=i686-unknown-unknown --asm-show-inst | FileCheck %s --check-prefix=VERBOSE
 ; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s --check-prefix=CHECK
 
 define i8 @add_i8(i8 %a) nounwind {
 ; VERBOSE-LABEL: add_i8:
 ; VERBOSE:       # %bb.0:
-; VERBOSE-NEXT:    movb {{[0-9]+}}(%esp), %al # <MCInst #1804 MOV8rm
-; VERBOSE-NEXT:    # <MCOperand Reg:2>
-; VERBOSE-NEXT:    # <MCOperand Reg:33>
+; VERBOSE-NEXT:    movb {{[0-9]+}}(%esp), %al # <MCInst #[[#MCINST1804:]] MOV8rm
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG2:]]>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG33:]]>
 ; VERBOSE-NEXT:    # <MCOperand Imm:1>
-; VERBOSE-NEXT:    # <MCOperand Reg:0>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG0:]]>
 ; VERBOSE-NEXT:    # <MCOperand Imm:4>
-; VERBOSE-NEXT:    # <MCOperand Reg:0>>
-; VERBOSE-NEXT:    addb $2, %al # <MCInst #400 ADD8i8
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG0]]>>
+; VERBOSE-NEXT:    addb $2, %al # <MCInst #[[#MCINST400:]] ADD8i8
 ; VERBOSE-NEXT:    # <MCOperand Imm:2>>
-; VERBOSE-NEXT:    retl # <MCInst #2560 RET32
-; VERBOSE-NEXT:    # <MCOperand Reg:2>>
+; VERBOSE-NEXT:    retl # <MCInst #[[#MCINST2560:]] RET32
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG2]]>>
 ;
 ; CHECK-LABEL: add_i8:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    movb {{[0-9]+}}(%esp), %al
 ; CHECK-NEXT:    addb $2, %al
 ; CHECK-NEXT:    retl
   %add = add i8 %a, 2
   ret i8 %add
 }
 
 define i32 @add_i32(i32 %a) nounwind {
 ; VERBOSE-LABEL: add_i32:
 ; VERBOSE:       # %bb.0:
-; VERBOSE-NEXT:    movl {{[0-9]+}}(%esp), %eax # <MCInst #1768 MOV32rm
-; VERBOSE-NEXT:    # <MCOperand Reg:22>
-; VERBOSE-NEXT:    # <MCOperand Reg:33>
+; VERBOSE-NEXT:    movl {{[0-9]+}}(%esp), %eax # <MCInst #[[#MCINST1768:]] MOV32rm
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG22:]]>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG33]]>
 ; VERBOSE-NEXT:    # <MCOperand Imm:1>
-; VERBOSE-NEXT:    # <MCOperand Reg:0>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG0]]>
 ; VERBOSE-NEXT:    # <MCOperand Imm:4>
-; VERBOSE-NEXT:    # <MCOperand Reg:0>>
-; VERBOSE-NEXT:    addl $2, %eax # <MCInst #387 ADD32ri8
-; VERBOSE-NEXT:    # <MCOperand Reg:22>
-; VERBOSE-NEXT:    # <MCOperand Reg:22>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG0]]>>
+; VERBOSE-NEXT:    addl $2, %eax # <MCInst #[[#MCINST387:]] ADD32ri8
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG22]]>
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG22]]>
 ; VERBOSE-NEXT:    # <MCOperand Imm:2>>
-; VERBOSE-NEXT:    retl # <MCInst #2560 RET32
-; VERBOSE-NEXT:    # <MCOperand Reg:22>>
+; VERBOSE-NEXT:    retl # <MCInst #[[#MCINST2560]] RET32
+; VERBOSE-NEXT:    # <MCOperand Reg:[[#MCREG22]]>>
 ;
 ; CHECK-LABEL: add_i32:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-NEXT:    addl $2, %eax
 ; CHECK-NEXT:    retl
   %add = add i32 %a, 2
   ret i32 %add
 }

llvm/utils/UpdateTestChecks/asm.py

def scrub_asm_nvptx(asm, args):
   # whitespace in place.
   asm = common.SCRUB_WHITESPACE_RE.sub(r' ', asm)
   # Expand the tabs used for indentation.
   asm = string.expandtabs(asm, 2)
   # Strip trailing whitespace.
   asm = common.SCRUB_TRAILING_WHITESPACE_RE.sub(r'', asm)
   return asm
 
-
 # Returns a tuple of a scrub function and a function regex. Scrub function is
-# used to alter function body in some way, for example, remove traling spaces.
+# used to alter function body in some way, for example, remove trailing spaces.
 # Function regex is used to match function name, body, etc. in raw llc output.
 def get_run_handler(triple):
   target_handlers = {
       'i686': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'x86': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'i386': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'arm64_32-apple-ios': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
       'aarch64': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_RE),
def get_run_handler(triple):
   if handler is None:
     raise KeyError('Triple %r is not supported' % (triple))
 
   return handler
 
 ##### Generator of assembly CHECK lines
 
 def add_checks(output_lines, comment_marker, prefix_list, func_dict,
-                   func_name, is_filtered):
+               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)
-  global_vars_seen_dict = {}
   common.add_checks(output_lines, comment_marker, prefix_list, func_dict,
                     func_name, check_label_format, True, False,
-                    global_vars_seen_dict, is_filtered = is_filtered)
+                    global_vars_seen_dict, is_filtered=is_filtered)

llvm/utils/UpdateTestChecks/common.py

 from __future__ import print_function
 
 import argparse
 import copy
 import glob
+import itertools
 import os
 import re
 import subprocess
 import sys
 import shlex
 
 ##### Common utilities for update_*test_checks.py
 

 ##### Generator of LLVM IR CHECK lines
 
 SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*')
 
 # TODO: We should also derive check lines for global, debug, loop declarations, etc..
 
 class NamelessValue:
   def __init__(self, check_prefix, check_key, ir_prefix, global_ir_prefix, global_ir_prefix_regexp,
-               ir_regexp, global_ir_rhs_regexp, is_before_functions):
+               ir_regexp, global_ir_rhs_regexp, is_before_functions, is_number=False):
     self.check_prefix = check_prefix
     self.check_key = check_key
     self.ir_prefix = ir_prefix
     self.global_ir_prefix = global_ir_prefix
     self.global_ir_prefix_regexp = global_ir_prefix_regexp
     self.ir_regexp = ir_regexp
     self.global_ir_rhs_regexp = global_ir_rhs_regexp
     self.is_before_functions = is_before_functions
+    self.is_number = is_number
 
   # Return true if this kind of IR value is "local", basically if it matches '%{{.*}}'.
   def is_local_def_ir_value_match(self, match):
     return self.ir_prefix == '%'
 
   # Return true if this kind of IR value is "global", basically if it matches '#{{.*}}'.
   def is_global_scope_ir_value_match(self, match):
     return self.global_ir_prefix is not None
if self.ir_prefix and match.group(0).strip().startswith(self.ir_prefix):
       return self.ir_regexp
     return self.global_ir_prefix_regexp
 
   # Create a FileCheck variable from regex.
   def get_value_definition(self, var, match):
     # for backwards compatibility we check locals with '.*'
     varname = get_value_name(var, self.check_prefix)
     prefix = self.get_ir_prefix_from_ir_value_match(match)[0]
+    if self.is_number:
+      regex = ''  # always capture a number in the default format
+      capture_start = '[[#'
+    else:
       regex = self.get_ir_regex_from_ir_value_re_match(match)
+      capture_start = '[['
     if self.is_local_def_ir_value_match(match):
-      return '[[' + varname + ':' + prefix + regex + ']]'
-    return prefix + '[[' + varname + ':' + regex + ']]'
+      return capture_start + varname + ':' + prefix + regex + ']]'
+    return prefix + capture_start + varname + ':' + regex + ']]'
 
   # Use a FileCheck variable.
   def get_value_use(self, var, match, var_prefix=None):
     if var_prefix is None:
       var_prefix = self.check_prefix
+    capture_start = '[[#' if self.is_number else '[['
     if self.is_local_def_ir_value_match(match):
-      return '[[' + get_value_name(var, var_prefix) + ']]'
+      return capture_start + get_value_name(var, var_prefix) + ']]'
     prefix = self.get_ir_prefix_from_ir_value_match(match)[0]
-    return prefix + '[[' + get_value_name(var, var_prefix) + ']]'
+    return prefix + capture_start + get_value_name(var, var_prefix) + ']]'
 
 # Description of the different "unnamed" values we match in the IR, e.g.,
 # (local) ssa values, (debug) metadata, etc.
-nameless_values = [
+ir_nameless_values = [
     NamelessValue(r'TMP'  , '%' , r'%'           , None            , None                   , r'[\w$.-]+?' , None                 , False) ,
     NamelessValue(r'ATTR' , '#' , r'#'           , None            , None                   , r'[0-9]+'    , None                 , False) ,
     NamelessValue(r'ATTR' , '#' , None           , r'attributes #' , r'[0-9]+'              , None         , r'{[^}]*}'           , False) ,
     NamelessValue(r'GLOB' , '@' , r'@'           , None            , None                   , r'[0-9]+'    , None                 , False) ,
     NamelessValue(r'GLOB' , '@' , None           , r'@'            , r'[a-zA-Z0-9_$"\\.-]+' , None         , r'.+'                , True)  ,
     NamelessValue(r'DBG'  , '!' , r'!dbg '       , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'PROF' , '!' , r'!prof '      , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'TBAA' , '!' , r'!tbaa '      , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'RNG'  , '!' , r'!range '     , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'LOOP' , '!' , r'!llvm.loop ' , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'META' , '!' , r'metadata '   , None            , None                   , r'![0-9]+'   , None                 , False) ,
     NamelessValue(r'META' , '!' , None           , r''             , r'![0-9]+'             , None         , r'(?:distinct |)!.*' , False) ,
 ]
 
+asm_nameless_values = [
+ NamelessValue(r'MCINST', 'Inst#', None, '<MCInst #', r'\d+', None, r'.+', False, True),
+ NamelessValue(r'MCREG',  'Reg:', None, '<MCOperand Reg:', r'\d+', None, r'.+', False, True),
+]
+
 def createOrRegexp(old, new):
   if not old:
     return new
   if not new:
     return old
   return old + '|' + new
 
 def createPrefixMatch(prefix_str, prefix_re):
   if prefix_str is None or prefix_re is None:
     return ''
   return '(?:' + prefix_str + '(' + prefix_re + '))'
 
 # Build the regexp that matches an "IR value". This can be a local variable,
 # argument, global, or metadata, anything that is "named". It is important that
 # the PREFIX and SUFFIX below only contain a single group, if that changes
 # other locations will need adjustment as well.
 IR_VALUE_REGEXP_PREFIX = r'(\s*)'
 IR_VALUE_REGEXP_STRING = r''
-for nameless_value in nameless_values:
+for nameless_value in ir_nameless_values:
   lcl_match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
   glb_match = createPrefixMatch(nameless_value.global_ir_prefix, nameless_value.global_ir_prefix_regexp)
   assert((lcl_match or glb_match) and not (lcl_match and glb_match))
   if lcl_match:
     IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, lcl_match)
   elif glb_match:
     IR_VALUE_REGEXP_STRING = createOrRegexp(IR_VALUE_REGEXP_STRING, '^' + glb_match)
 IR_VALUE_REGEXP_SUFFIX = r'([,\s\(\)]|\Z)'
 IR_VALUE_RE = re.compile(IR_VALUE_REGEXP_PREFIX + r'(' + IR_VALUE_REGEXP_STRING + r')' + IR_VALUE_REGEXP_SUFFIX)
 
+# Build the regexp that matches an "ASM value" (currently only for --asm-show-inst comments).
+ASM_VALUE_REGEXP_STRING = ''
+for nameless_value in asm_nameless_values:
+  glb_match = createPrefixMatch(nameless_value.global_ir_prefix, nameless_value.global_ir_prefix_regexp)
+  assert not nameless_value.ir_prefix and not nameless_value.ir_regexp
+  ASM_VALUE_REGEXP_STRING = createOrRegexp(ASM_VALUE_REGEXP_STRING, glb_match)
+ASM_VALUE_REGEXP_SUFFIX = r'([>\s]|\Z)'
+ASM_VALUE_RE = re.compile(r'((?:#|//)\s*)' + '(' + ASM_VALUE_REGEXP_STRING + ')' + ASM_VALUE_REGEXP_SUFFIX)
+
 # The entire match is group 0, the prefix has one group (=1), the entire
 # IR_VALUE_REGEXP_STRING is one group (=2), and then the nameless values start.
 first_nameless_group_in_ir_value_match = 3
 
 # constants for the group id of special matches
 variable_group_in_ir_value_match = 3
 attribute_group_in_ir_value_match = 4
 
else:
     # This is a named value that clashes with the check_prefix, prepend with _prefix_filecheck_ir_name,
     # if it has been defined.
     if may_clash_with_default_check_prefix_name(check_prefix, var) and _prefix_filecheck_ir_name:
       var = _prefix_filecheck_ir_name + var
   var = var.replace('.', '_')
   var = var.replace('-', '_')
   return var.upper()
 
-def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
+def generalize_check_lines_common(lines, is_analyze, vars_seen,
+                                  global_vars_seen, nameless_values,
+                                  nameless_value_regex, is_asm):
   # This gets called for each match that occurs in
   # a line. We transform variables we haven't seen
   # into defs, and variables we have seen into uses.
   def transform_line_vars(match):
     var = get_name_from_ir_value_match(match)
     nameless_value = get_nameless_value_from_match(match, nameless_values)
     if may_clash_with_default_check_prefix_name(nameless_value.check_prefix, var):
       warn("Change IR value name '%s' or use --prefix-filecheck-ir-name to prevent possible conflict"
def transform_line_vars(match):
     # with whatever you return, so we have
     # to make sure to hand it back everything
     # including the commas and spaces.
     return match.group(1) + rv + match.group(match.lastindex)
 
   lines_with_def = []
 
   for i, line in enumerate(lines):
+    if not is_asm:
       # An IR variable named '%.' matches the FileCheck regex string.
       line = line.replace('%.', '%dot')
       for regex in _global_hex_value_regex:
         if re.match('^@' + regex + ' = ', line):
           line = re.sub(r'\bi([0-9]+) ([0-9]+)',
               lambda m : 'i' + m.group(1) + ' [[#' + hex(int(m.group(2))) + ']]',
               line)
           break
       # Ignore any comments, since the check lines will too.
       scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line)
       lines[i] = scrubbed_line
-    if not is_analyze:
+    if is_asm or not is_analyze:
       # It can happen that two matches are back-to-back and for some reason sub
       # will not replace both of them. For now we work around this by
       # substituting until there is no more match.
       changed = True
       while changed:
-        (lines[i], changed) = IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1)
+        (lines[i], changed) = nameless_value_regex.subn(transform_line_vars,
+                                                        lines[i], count=1)
   return lines
 
+# Replace IR value defs and uses with FileCheck variables.
+def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
+  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):
   # 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
for checkprefix in checkprefixes:
 
       vars_seen = set()
       printed_prefixes.append(checkprefix)
       attrs = str(func_dict[checkprefix][func_name].attrs)
       attrs = '' if attrs == 'None' else attrs
       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('%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))
       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
         if is_filtered:
           # For filtered output we don't add "-NEXT" so don't add extra spaces
           # before the first line.
           body_start = 0
         else:
           output_lines.append('%s %s:       %s' % (comment_marker, checkprefix, func_body[0]))
-        for func_line in func_body[body_start:]:
+        func_lines = generalize_asm_check_lines(func_body[body_start:],
+                                                vars_seen, global_vars_seen)
+        for func_line in func_lines:
           if func_line.strip() == '':
             output_lines.append('%s %s-EMPTY:' % (comment_marker, checkprefix))
           else:
             check_suffix = '-NEXT' if not is_filtered else ''
             output_lines.append('%s %s%s:  %s' % (comment_marker, checkprefix,
                                                   check_suffix, func_line))
+        # 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
 
       # For IR output, change all defs to FileCheck variables, so we're immune
       # to variable naming fashions.
       func_body = generalize_check_lines(func_body, is_analyze, vars_seen, global_vars_seen)
 
       # This could be selectively enabled with an optional invocation argument.
       # Disabled for now: better to check everything. Be safe rather than sorry.
for checkprefix in checkprefixes:
           output_lines.append('{} {}{}:  {}'.format(
               comment_marker, checkprefix, check_suffix, func_line))
         is_blank_line = False
 
       # Add space between different check prefixes and also before the first
       # line of code in the test function.
       output_lines.append(comment_marker)
 
-      # Remembe new global variables we have not seen before
+      # 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
 
 def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
                   func_name, preserve_names, function_sig,
                   global_vars_seen_dict, is_filtered):
   # Label format is based on IR string.
   function_def_regex = 'define {{[^@]+}}' if function_sig else ''
   check_label_format = '{} %s-LABEL: {}@%s%s%s'.format(comment_marker, function_def_regex)
   add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
              check_label_format, False, preserve_names, 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)
   global_vars_seen_dict = {}
   add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
              check_label_format, False, True, global_vars_seen_dict,
              is_filtered)
 
 def build_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes):
-  for nameless_value in nameless_values:
+  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
     rhs_re_str = nameless_value.global_ir_rhs_regexp
 
     global_ir_value_re_str = r'^' + lhs_re_str + r'\s=\s' + rhs_re_str + r'$'
     global_ir_value_re = re.compile(global_ir_value_re_str, flags=(re.M))
for prefix in prefixes:
           warn('Found conflicting asm under the same prefix: %r!' % (prefix,))
         else:
           glob_val_dict[prefix][nameless_value.check_prefix] = None
           continue
       glob_val_dict[prefix][nameless_value.check_prefix] = lines
 
 def add_global_checks(glob_val_dict, comment_marker, prefix_list, output_lines, global_vars_seen_dict, is_analyze, is_before_functions):
   printed_prefixes = set()
-  for nameless_value in nameless_values:
+  for nameless_value in ir_nameless_values:
     if nameless_value.global_ir_prefix is None:
       continue
     if nameless_value.is_before_functions != is_before_functions:
       continue
     for p in prefix_list:
       global_vars_seen = {}
       checkprefixes = p[0]
       if checkprefixes is None:

llvm/utils/UpdateTestChecks/isel.py

def get_run_handler(triple):
   if handler is None:
     common.debug('Using default handler.')
     handler = (scrub_isel_default, ISEL_FUNCTION_DEFAULT_RE)
 
   return handler
 
 ##### Generator of iSel CHECK lines
 
-def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, is_filtered):
+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)
-  global_vars_seen_dict = {}
   common.add_checks(output_lines, comment_marker, prefix_list, func_dict,
                     func_name, check_label_format, True, False,
                     global_vars_seen_dict, is_filtered = is_filtered)

llvm/utils/update_cc_test_checks.py

if include_generated_funcs:
                                prefixes,
                                func_dict, func, False,
                                ti.args.function_signature,
                                global_vars_seen_dict,
                                is_filtered=builder.is_filtered())
         else:
           asm.add_checks(my_output_lines, '//',
                              prefixes,
-                             func_dict, func,
+                             func_dict, func, global_vars_seen_dict,
                              is_filtered=builder.is_filtered())
 
       if ti.args.check_globals:
         common.add_global_checks(builder.global_var_dict(), '//', run_list,
                                  output_lines, global_vars_seen_dict, True,
                                  True)
       common.add_checks_at_end(output_lines, filecheck_run_list, builder.func_order(),
                                '//', lambda my_output_lines, prefixes, func:

llvm/utils/update_llc_test_checks.py

for prefixes, llc_tool, llc_args, preprocess_cmd, triple_in_cmd, march_in_cmd in run_list:
       triple = triple_in_cmd or triple_in_ir
       if not triple:
         triple = common.get_triple_from_march(march_in_cmd)
 
       scrubber, function_re = output_type.get_run_handler(triple)
       builder.process_run_line(function_re, scrubber, raw_tool_output, prefixes, True)
 
     func_dict = builder.finish_and_get_func_dict()
+    global_vars_seen_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 = []
 
if include_generated_funcs:
 
       # Now generate all the checks.
       common.add_checks_at_end(output_lines, run_list, builder.func_order(),
                                check_indent + ';',
                                lambda my_output_lines, prefixes, func:
                                output_type.add_checks(my_output_lines,
                                                   check_indent + ';',
                                                   prefixes, func_dict, func,
+                                                  global_vars_seen_dict,
                                                   is_filtered=builder.is_filtered()))
     else:
       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.
           output_type.add_checks(output_lines, check_indent + ';', run_list,
-                             func_dict, func_name,
+                                 func_dict, func_name, global_vars_seen_dict,
                                  is_filtered=builder.is_filtered())
           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