[UpdateTestChecks] Match 'attributes #' at the end

[sstefan1]

Summary

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]

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

30

I need to work a little bit more on files that have multiple check lines, but the general approach should remain the same (if everyone agrees).

[sstefan1]

actually make it work when multiple check prefixes are provided

[jdoerfert]

Cool, some initial comments below :)

llvm/utils/UpdateTestChecks/common.py

328

Nit: Align the columns. Maybe reorder so we have prefix and then regexp, we can then also make those a pair: ('r'%', r'...'), (...)

557

do we need to ensure this is a full line match? r'^' + ... + '$' or something?

562

we can do this once further out.

575

Can you explain the above conditionals in a comment?

[xbolva00]

This is cool!

[sstefan1]

addressing comments

llvm/utils/UpdateTestChecks/common.py

328

I am not sure I see a place where those could be used separately. Am I missing something?

[jdoerfert]

llvm/utils/UpdateTestChecks/common.py

328

I mean, it's easier to read the thing if the "local" prefixes are in a pair and then the global ones are. But it's just an idea, unclear if it's really easier to read at the end of the day.

[jdoerfert]

LGTM

[sstefan1]

Sorry for the delay on this.

The reason I didn't commit this is that I changed the update_test_checks.py to
skip all the CHECK lines, not just the ones inside the function.
With this update, we only skip CHECK lines inside of functions and global ones
that are being added (currently 'CHECK: attributes #...')
Every new global check added should be automatically skiped with this.

[sstefan1]

Don't skip ;\n comments

[sstefan1]

Switched to D88096.

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

 
 ##### 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'GLOB',  r'@',            r'',           r'',     r'[0-9]+?',  r''),
+    NamelessValue(r'ATTR',  r'#',            r'attributes', r'\s\#', r'[0-9]+?',  r'{([\w\s])*(\"(.+?)\"=\"(.+?)\"\s)?}'),
+    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
 
 # Check a match for IR_VALUE_RE and inspect it to determine if it was a local
def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict,
   # Label format is based on IR string.
   function_def_regex = 'define {{[^@]+}}' if function_sig else ''
   check_label_format = '{} %s-LABEL: {}@%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)
 
 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_see_dict = {}
+  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
+    lhs_re = re.compile(lhs_re_str)
+    rhs_re = re.compile(rhs_re_str)
+
+    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 m in global_ir_value_re.finditer(raw_tool_output):
+      line = m.group(0)
+      for prefix in prefixes:
+        if glob_val_dict[prefix] is None:
+          continue
+        if nameless_value.check_prefix not in glob_val_dict[prefix]:
+          glob_val_dict[prefix][nameless_value.check_prefix] = []
+
+        found = False
+        for l in glob_val_dict[prefix][nameless_value.check_prefix]:
+          # If LHSs are different (eg. attributes #0 and attributes #1)
+          # then we are looking at different line.
+          if lhs_re.match(line).group(0) != lhs_re.match(l).group(0):
+            continue
+          # If LHSs are the same and RHSs are same as well (eg { nounwind } and { nounwind })
+          # then we are looking at the same line.
+          if rhs_re.search(line).group(0) == rhs_re.search(l).group(0):
+            found = True
+            break
+          # Found conflicting lines
+          if prefix == prefixes[-1]:
+            warn('Found conflicting asm under the same prefix: %r!' % (prefix,))
+          else:
+            found = True
+            glob_val_dict[prefix] = None
+            break
+        if not found:
+          glob_val_dict[prefix][nameless_value.check_prefix].append(line)
+
+def add_global_checks(glob_val_dict, comment_marker, prefix_list, output_lines, global_vars_seen_dict, is_analyze):
+  printed_prefixes = set()
+  for p in prefix_list:
+    checkprefixes = p[0]
+    for checkprefix in checkprefixes:
+      if checkprefix in printed_prefixes:
+        break
+
+      if glob_val_dict[checkprefix] is None:
+        continue
+
+      if checkprefix not in global_vars_seen_dict:
+          global_vars_seen_dict[checkprefix] = set()
+      global_vars_seen = global_vars_seen_dict[checkprefix]
+
+      for nameless_value in nameless_values:
+        if nameless_value.check_prefix not in glob_val_dict[checkprefix]:
+          continue
+        for line in glob_val_dict[checkprefix][nameless_value.check_prefix]:
+          # don't print identical lines
+          printed = False
+          for pp in printed_prefixes:
+            if pp != checkprefix and line in glob_val_dict[pp][nameless_value.check_prefix]:
+              printed = True
+              break
+
+          if printed:
+            continue
+          tmp = genericize_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)
 
 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()