[WIP][Utils] Fix conflicting checkline generation.

[kuter]

Summary

Example:
We have 3 run lines.

; RUN: opt ..... | FileChek --check-prefixes=A,D
; RUN: opt ..... | FileChek --check-prefixes=B,C
; RUN: opt ..... | FileChek --check-prefixes=A,B

For a function, three run lines generates the same output
but this is just a coincidence so check lines are correct.

Before this patch generated output is.
; A-LABEL: define .....
; A ......

; B-LABEL: define .....
; B ......

The third run line is going to fail since it can't match the "B-LABEL"
check since the "A-LABEL" line have consumed the function signature

This patch corrects this issue by excluding all checkprefixes
that exist in the same run line as the choosen prefix.

For "-LABEL" generation this is shouldn't affect existing checks.
There is no way that tests that are affected by this change are
valid.

[WIP] Are other users of common.py effected by this change ?

[kuter]

A real example that doesn't work.

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S < %s | FileCheck --check-prefixes=A,B,C
; RUN: opt -S < %s | FileCheck --check-prefixes=A,E
; RUN: opt -S < %s | FileCheck --check-prefixes=B,D

define i32 @negated_operand(i32 %x) {
; A-LABEL: @negated_operand(
; A-NEXT:    [[NEGX:%.*]] = sub i32 0, [[X:%.*]]
; A-NEXT:    [[R:%.*]] = add i32 [[NEGX]], [[X]]
; A-NEXT:    ret i32 [[R]]
;
; B-LABEL: @negated_operand(
; B-NEXT:    [[NEGX:%.*]] = sub i32 0, [[X:%.*]]
; B-NEXT:    [[R:%.*]] = add i32 [[NEGX]], [[X]]
; B-NEXT:    ret i32 [[R]]
;
  %negx = sub i32 0, %x
  %r = add i32 %negx, %x
  ret i32 %r
}

[kuter]

The fix here only works if the run lines are ordered in a specific way.
I don't think there are any trivial solutions to this problem.

Abandoning the revision.

llvm/utils/UpdateTestChecks/common.py

if not is_analyze:
           (lines[i], changed) = IR_VALUE_RE.subn(transform_line_vars, lines[i], count=1)
   return lines
 
 
 def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze, global_vars_seen_dict):
   # 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 = []
+  # A mapping of prefixes to the run lines they exist in.
+  prefix_to_lines = {}
+
   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.
     if any(map(lambda checkprefix: func_name not in func_dict[checkprefix], checkprefixes)):
         prefix_exclusions |= set(checkprefixes)
         continue
+    for prefix in checkprefixes:
+        if prefix not in prefix_to_lines:
+            prefix_to_lines[prefix] = []
+        prefix_to_lines[prefix].append(p)
+
 
   # prefix_exclusions is constructed, we can now emit the output
   for p in prefix_list:
     checkprefixes = p[0]
     for checkprefix in checkprefixes:
       if checkprefix in printed_prefixes:
         break
 
for checkprefix in checkprefixes:
           output_lines.append(comment_marker)
 
       if checkprefix not in global_vars_seen_dict:
           global_vars_seen_dict[checkprefix] = set()
       global_vars_seen = global_vars_seen_dict[checkprefix]
 
       vars_seen = set()
       printed_prefixes.append(checkprefix)
+      # For this function we can't use any of the other prefixes that exists in the run lines
+      # that this prefix is in.
+      prefix_exclusions |= { prefix for prefix in p[0] for p in prefix_to_lines[prefix] }
       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)
       args_and_sig = generalize_check_lines([args_and_sig], is_analyze, vars_seen, global_vars_seen)[0]
       if '[[' in args_and_sig:
         output_lines.append(check_label_format % (checkprefix, func_name, ''))