[UpdateTestChecks] Match 'attributes #' at the end

[jdoerfert]

Summary

Based on D85932, modified slightly, works with the Attributor tests.

With this patch we can now add check lines outside of the function.
For now we match only attributes at the end of the module, but other
values can be added later as well.

Haven't actually tried it yet, but adding checks for other values
should be as easy as adding appropriate regexps in nameless_values list.

[sstefan1]

Now I see where the problem was. Thanks for taking a look.

LGTM!

llvm/utils/UpdateTestChecks/common.py

569

Indentation seems off here and in few other places below.

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.funcattrs.expected

 ; IS__CGSCC____-NEXT:  entry:
 ; IS__CGSCC____-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; IS__CGSCC____-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }
+; IS__TUNIT____: attributes [[ATTR0]] = { nofree nosync nounwind optsize readnone ssp uwtable willreturn }
+; IS__CGSCC____: attributes [[ATTR0]] = { nofree norecurse nosync nounwind optsize readnone ssp uwtable willreturn }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/check_attrs.ll.plain.expected

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
 ; CHECK-NEXT:    ret i32* [[ARRAYIDX]]
 ;
 entry:
   %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
   ret i32* %arrayidx
 }
+; IS__TUNIT____: attributes [[ATTR0]] = { nofree nosync nounwind optsize readnone ssp uwtable willreturn }
+; IS__CGSCC____: attributes [[ATTR0]] = { nofree norecurse nosync nounwind optsize readnone ssp uwtable willreturn }

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

 
 define i32 @signature(i32 %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@signature
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
 ; CHECK-NEXT:    ret i32 [[ARG]]
 ;
   ret i32 %arg
 }
+; CHECK: attributes [[ATTR0:#.*]] = { readnone }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/on_the_fly_arg_change.ll.initially_disabled.expected

 
 define i32 @signature(i32 %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@signature
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {
 ; CHECK-NEXT:    ret i32 [[ARG]]
 ;
   ret i32 %arg
 }
+; CHECK: attributes [[ATTR0:#.*]] = { readnone }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/scrub_attrs.ll.plain.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S < %s | FileCheck %s
 
 declare void @foo()
 
 define internal void @bar() {
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:    call void @foo() [[ATTR0:#.*]]
 ; CHECK-NEXT:    ret void
 ;
   call void @foo() readnone
   ret void
 }
+; CHECK: attributes [[ATTR0]] = { readnone }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/scrub_attrs.ll.scrub.expected

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes
 ; RUN: opt -S < %s | FileCheck %s
 
 declare void @foo()
 
 define internal void @bar() {
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    ret void
 ;
   call void @foo() readnone
   ret void
 }
+; CHECK: attributes [[ATTR0:#.*]] = { readnone }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/various_ir_values.ll.expected

 !53 = !DILocation(line: 9, column: 3, scope: !48)
 !54 = !DILocation(line: 10, column: 5, scope: !48)
 !55 = !DILocation(line: 10, column: 7, scope: !48)
 !56 = !DILocation(line: 10, column: 10, scope: !48)
 !57 = !DILocation(line: 9, column: 27, scope: !48)
 !58 = distinct !{!58, !52, !59}
 !59 = !DILocation(line: 10, column: 12, scope: !43)
 !60 = !DILocation(line: 11, column: 1, scope: !39)
+; CHECK: attributes [[ATTR0:#.*]] = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+; CHECK: attributes [[ATTR1:#.*]] = { nounwind readnone speculatable willreturn }
+; CHECK: attributes [[ATTR2:#.*]] = { argmemonly nounwind willreturn }
+; CHECK: attributes [[ATTR3]] = { nounwind }

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/various_ir_values.ll.funcsig.expected

 !53 = !DILocation(line: 9, column: 3, scope: !48)
 !54 = !DILocation(line: 10, column: 5, scope: !48)
 !55 = !DILocation(line: 10, column: 7, scope: !48)
 !56 = !DILocation(line: 10, column: 10, scope: !48)
 !57 = !DILocation(line: 9, column: 27, scope: !48)
 !58 = distinct !{!58, !52, !59}
 !59 = !DILocation(line: 10, column: 12, scope: !43)
 !60 = !DILocation(line: 11, column: 1, scope: !39)
+; CHECK: attributes [[ATTR0]] = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+; CHECK: attributes [[ATTR1:#.*]] = { nounwind readnone speculatable willreturn }
+; CHECK: attributes [[ATTR2:#.*]] = { argmemonly nounwind willreturn }
+; CHECK: attributes [[ATTR3]] = { nounwind }

llvm/utils/UpdateTestChecks/common.py

for test in tests_list:
       elif args.update_only:
         assert UTC_ADVERT not in first_line
         warn("Skipping test which isn't autogenerated: " + test)
         continue
       yield TestInfo(test, parser, script_name, input_lines, args, argv,
                      comment_prefix, argparse_callback)
 
 
-def should_add_line_to_output(input_line, prefix_set):
+def should_add_line_to_output(input_line, prefix_set, skip_global_checks = False):
   # Skip any blank comment lines in the IR.
-  if input_line.strip() == ';':
+  if not skip_global_checks and input_line.strip() == ';':
     return False
   # Skip any blank lines in the IR.
   #if input_line.strip() == '':
   #  return False
   # And skip any CHECK lines. We're building our own.
   m = CHECK_RE.match(input_line)
   if m and m.group(1) in prefix_set:
+    if(skip_global_checks):
+      for nameless_value in nameless_values:
+        if not nameless_value.global_ir_prefix:
+          continue
+        if re.compile(nameless_value.global_ir_prefix).search(input_line):
+          return False
+      return True
     return False
 
   return True
 
 # Invoke the tool that is being tested.
 def invoke_tool(exe, cmd_args, ir):
   with open(ir) as ir_file:
     # TODO Remove the str form which is used by update_test_checks.py and
class function_body(object):
   def __init__(self, string, extra, args_and_sig, attrs):
     self.scrub = string
     self.extrascrub = extra
     self.args_and_sig = args_and_sig
     self.attrs = attrs
   def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs):
     arg_names = set()
     def drop_arg_names(match):
-        arg_names.add(match.group(3))
-        return match.group(1) + match.group(match.lastindex)
+        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(3) is not None and match.group(3) in arg_names:
+        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.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 verbose:
       for l in scrubbed_body.splitlines():
         print('  ' + l, file=sys.stderr)
     for prefix in prefixes:
       if func in func_dict[prefix]:
         if str(func_dict[prefix][func]) != scrubbed_body or (func_dict[prefix][func] and (func_dict[prefix][func].args_and_sig != args_and_sig or func_dict[prefix][func].attrs != attrs)):
           if func_dict[prefix][func] and func_dict[prefix][func].is_same_except_arg_names(scrubbed_extra, args_and_sig, attrs):
             func_dict[prefix][func].scrub = scrubbed_extra
             func_dict[prefix][func].args_and_sig = args_and_sig
+            func_dict[prefix][func].attrs = attrs
             continue
           else:
             if prefix == prefixes[-1]:
               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, args_and_sig, attrs)
 
 ##### 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, ir_prefix, ir_regexp):
+    def __init__(self, check_prefix, ir_prefix, global_ir_prefix, global_ir_prefix_regexp, ir_regexp, global_ir_regexp):
         self.check_prefix = check_prefix
         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_regexp = global_ir_regexp
 
 # Description of the different "unnamed" values we match in the IR, e.g.,
 # (local) ssa values, (debug) metadata, etc.
 nameless_values = [
-    NamelessValue(r'TMP',   r'%',            r'[\w.-]+?'),
-    NamelessValue(r'GLOB',  r'@',            r'[0-9]+?'),
-    NamelessValue(r'ATTR',  r'#',            r'[0-9]+?'),
-    NamelessValue(r'DBG',   r'!dbg !',       r'[0-9]+?'),
-    NamelessValue(r'TBAA',  r'!tbaa !',      r'[0-9]+?'),
-    NamelessValue(r'RNG',   r'!range !',     r'[0-9]+?'),
-    NamelessValue(r'LOOP',  r'!llvm.loop !', r'[0-9]+?'),
-    NamelessValue(r'META',  r'metadata !',   r'[0-9]+?'),
+    NamelessValue(r'TMP',   r'%',            r'',           r'',     r'[\w.-]+?', r''),
+    NamelessValue(r'ATTR',  r'#',            r'attributes', r'\s\#', r'[0-9]+?',  r'{[^}]*}'),
+    NamelessValue(r'GLOB',  r'@',            r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'DBG',   r'!dbg !',       r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'TBAA',  r'!tbaa !',      r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'RNG',   r'!range !',     r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'LOOP',  r'!llvm.loop !', r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'META',  r'metadata !',   r'',           r'',     r'[0-9]+?',  r''),
 ]
 
 # 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:
     if IR_VALUE_REGEXP_STRING:
         IR_VALUE_REGEXP_STRING += '|'
-    IR_VALUE_REGEXP_STRING += nameless_value.ir_prefix + r'(' + nameless_value.ir_regexp + r')'
+    IR_VALUE_REGEXP_STRING += nameless_value.ir_prefix + r'(' + nameless_value.ir_regexp + '|' + nameless_value.global_ir_prefix_regexp + r')'
 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)
 
 # 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
+
 # Check a match for IR_VALUE_RE and inspect it to determine if it was a local
 # value, %..., global @..., debug number !dbg !..., etc. See the PREFIXES above.
 def get_idx_from_ir_value_match(match):
     for i in range(first_nameless_group_in_ir_value_match, match.lastindex):
         if match.group(i) is not None:
             return i - first_nameless_group_in_ir_value_match
     error("Unable to identify the kind of IR value from the match!")
     return 0;
add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name,
              check_label_format, False, preserve_names, global_vars_seen_dict)
 
 def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
   check_label_format = '{} %s-LABEL: \'%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)
 
+def build_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes):
+  for nameless_value in nameless_values:
+    if not nameless_value.global_ir_prefix:
+      continue
+
+    lhs_re_str = nameless_value.global_ir_prefix + nameless_value.global_ir_prefix_regexp + nameless_value.ir_regexp
+    rhs_re_str = nameless_value.global_ir_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))
+    lines = []
+    for m in global_ir_value_re.finditer(raw_tool_output):
+        lines.append(m.group(0))
+
+    for prefix in prefixes:
+      if glob_val_dict[prefix] is None:
+        continue
+      if nameless_value.check_prefix in glob_val_dict[prefix]:
+        if lines == glob_val_dict[prefix][nameless_value.check_prefix]:
+          continue
+        if prefix == prefixes[-1]:
+          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):
+  for nameless_value in nameless_values:
+    printed_prefixes = set()
+    for p in prefix_list:
+      global_vars_seen = set()
+      checkprefixes = p[0]
+      for checkprefix in checkprefixes:
+        if checkprefix in global_vars_seen_dict:
+            global_vars_seen = global_vars_seen.union(global_vars_seen_dict[checkprefix])
+        if checkprefix in printed_prefixes:
+          break
+        if not glob_val_dict[checkprefix]:
+          continue
+        if nameless_value.check_prefix not in glob_val_dict[checkprefix]:
+          continue
+        if not glob_val_dict[checkprefix][nameless_value.check_prefix]:
+            continue
+
+        for line in glob_val_dict[checkprefix][nameless_value.check_prefix]:
+          tmp = generalize_check_lines([line], is_analyze, set(), global_vars_seen)
+          check_line = '%s %s: %s' % (comment_marker, checkprefix, tmp[0])
+          output_lines.append(check_line)
+        printed_prefixes.add(checkprefix)
+        break
+
 
 def check_prefix(prefix):
   if not PREFIX_RE.match(prefix):
         hint = ""
         if ',' in prefix:
           hint = " Did you mean '--check-prefixes=" + prefix + "'?"
         warn(("Supplied prefix '%s' is invalid. Prefix must contain only alphanumeric characters, hyphens and underscores." + hint) %
              (prefix))

llvm/utils/update_test_checks.py

for l in ti.run_lines:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       prefix_list.append((check_prefixes, tool_cmd_args))
 
     global_vars_seen_dict = {}
     func_dict = {}
+    glob_val_dict = {}
     for prefixes, _ in prefix_list:
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
+        glob_val_dict.update({prefix: dict()})
     for prefixes, opt_args in prefix_list:
       common.debug('Extracted opt cmd: ' + opt_basename + ' ' + opt_args)
       common.debug('Extracted FileCheck prefixes: ' + str(prefixes))
 
       raw_tool_output = common.invoke_tool(ti.args.opt_binary, opt_args, ti.path)
       common.build_function_body_dictionary(
               common.OPT_FUNCTION_RE, common.scrub_body, [],
               raw_tool_output, prefixes, func_dict, ti.args.verbose,
               ti.args.function_signature, ti.args.check_attributes)
 
+      common.build_global_values_dictionary(glob_val_dict, raw_tool_output, prefixes)
+
     is_in_function = False
     is_in_function_start = False
     prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
     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:
         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.
         common.add_ir_checks(output_lines, ';', prefix_list, func_dict,
                              func_name, args.preserve_names, args.function_signature,
                              global_vars_seen_dict)
         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.
-          # Except make leading whitespace uniform: 2 spaces.
-          input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub(r'  ', input_line)
-          output_lines.append(input_line)
-        else:
-          continue
+      # Skip all CHECK lines.
+      if common.should_add_line_to_output(input_line, prefix_set, not is_in_function):
+      if is_in_function:
         if input_line.strip() == '}':
           is_in_function = False
         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.add_global_checks(glob_val_dict, ';', prefix_list, output_lines, global_vars_seen_dict, args.preserve_names)
     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])
 
 
 if __name__ == '__main__':
   main()