[llvm] 3846019 - update_test_checks: keep meta variables stable by default
Nicolai Hähnle via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 7 19:34:34 PST 2024
Author: Nicolai Hähnle
Date: 2024-03-08T04:33:38+01:00
New Revision: 3846019d8f6379ea1a8bf3a0fdfb0202de8e2f2a
URL: https://github.com/llvm/llvm-project/commit/3846019d8f6379ea1a8bf3a0fdfb0202de8e2f2a
DIFF: https://github.com/llvm/llvm-project/commit/3846019d8f6379ea1a8bf3a0fdfb0202de8e2f2a.diff
LOG: update_test_checks: keep meta variables stable by default
Resubmitting this after previous revert with the following changes:
- Split table into table_rhs_idx and table_candidate_idx so that
bisect.bisect_left can be used without the `key` argument, which
was introduced in Python 3.10
- Remove a re.Pattern type annotation
Original commit message:
Prior to this change, running UTC on larger tests, especially tests
with unnamed IR values, often resulted in a spuriously large diff
because e.g. TMPnn variables in the CHECK lines were renumbered. This
change attempts to reduce the diff by keeping those variable names the
same.
There are cases in which this "drift" of variable names can end up being
more confusing. The old behavior can be re-enabled with the
--reset-variable-names command line argument.
The improvement may not be immediately apparent in the diff of this change.
The point is that the diff of stable_ir_values.ll against
stable_ir_values.ll.expected after this change is smaller.
Ideally, we'd also keep meta variables for "global" objects stable, e.g.
for attributes (#nn) and metadata (!nn). However, that would require a
much more substantial refactoring of how we generate check lines, so I
left it for future work.
Added:
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected.reset
Modified:
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values2.ll.expected
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll.expected
llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values4.ll.expected
llvm/test/tools/UpdateTestChecks/update_test_checks/stable_ir_values.test
llvm/utils/UpdateTestChecks/common.py
llvm/utils/update_test_checks.py
Removed:
################################################################################
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected
index 5142e3ed32ba45..3549a4d76aa762 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected
@@ -9,11 +9,11 @@
define i32 @func({i32, i32} %x, i32 %y) {
; CHECK-LABEL: define i32 @func(
; CHECK-SAME: { i32, i32 } [[X:%.*]], i32 [[Y:%.*]]) {
-; CHECK-NEXT: [[X_I34:%.*]] = extractvalue { i32, i32 } [[X]], 0
-; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[Y]], 1
-; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[X_I34]], [[TMP1]]
-; CHECK-NEXT: [[TMP3:%.*]] = mul i32 [[TMP2]], 3
-; CHECK-NEXT: ret i32 [[TMP3]]
+; CHECK-NEXT: [[X_I33:%.*]] = extractvalue { i32, i32 } [[X]], 0
+; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[Y]], 1
+; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[X_I33]], [[TMP3]]
+; CHECK-NEXT: [[TMP2:%.*]] = mul i32 [[TMP1]], 3
+; CHECK-NEXT: ret i32 [[TMP2]]
;
%x.i34 = extractvalue {i32, i32} %x, 0
%1 = add i32 %y, 1
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected.reset b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected.reset
new file mode 100644
index 00000000000000..5142e3ed32ba45
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values.ll.expected.reset
@@ -0,0 +1,23 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
+; RUN: opt < %s -S | FileCheck %s
+
+; The assumption underlying this test is that there are pre-existing check lines
+; but something has changed, and we would like to avoid needless changes of
+; meta variable names so that
diff s end up being easier to read, e.g. avoid
+; changing X_I33 into X_I34 or renumbering the various TMP variables.
+
+define i32 @func({i32, i32} %x, i32 %y) {
+; CHECK-LABEL: define i32 @func(
+; CHECK-SAME: { i32, i32 } [[X:%.*]], i32 [[Y:%.*]]) {
+; CHECK-NEXT: [[X_I34:%.*]] = extractvalue { i32, i32 } [[X]], 0
+; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[Y]], 1
+; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[X_I34]], [[TMP1]]
+; CHECK-NEXT: [[TMP3:%.*]] = mul i32 [[TMP2]], 3
+; CHECK-NEXT: ret i32 [[TMP3]]
+;
+ %x.i34 = extractvalue {i32, i32} %x, 0
+ %1 = add i32 %y, 1
+ %2 = add i32 %x.i34, %1
+ %3 = mul i32 %2, 3
+ ret i32 %3
+}
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values2.ll.expected b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values2.ll.expected
index 53f60bda8ee591..6311a55a1f9de1 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values2.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values2.ll.expected
@@ -5,12 +5,12 @@ define i32 @func(i32 %x) {
; CHECK-LABEL: define i32 @func(
; CHECK-SAME: i32 [[X:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32 [[X]], 0
-; CHECK-NEXT: [[TMP2:%.*]] = call i32 @foo(i1 [[TMP1]])
-; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[X]], 2
-; CHECK-NEXT: [[TMP4:%.*]] = call i32 @foo(i1 [[TMP3]])
-; CHECK-NEXT: [[TMP5:%.*]] = icmp ne i32 [[TMP4]], 0
-; CHECK-NEXT: [[TMP6:%.*]] = select i1 [[TMP5]], i32 [[TMP4]], i32 [[TMP2]]
-; CHECK-NEXT: ret i32 [[TMP6]]
+; CHECK-NEXT: [[TMP6:%.*]] = call i32 @foo(i1 [[TMP1]])
+; CHECK-NEXT: [[TMP7:%.*]] = icmp eq i32 [[X]], 2
+; CHECK-NEXT: [[TMP8:%.*]] = call i32 @foo(i1 [[TMP7]])
+; CHECK-NEXT: [[TMP9:%.*]] = icmp ne i32 [[TMP8]], 0
+; CHECK-NEXT: [[TMP10:%.*]] = select i1 [[TMP9]], i32 [[TMP8]], i32 [[TMP6]]
+; CHECK-NEXT: ret i32 [[TMP10]]
;
%1 = icmp eq i32 %x, 0
%2 = call i32 @foo(i1 %1)
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll
index 3b449291d0e7f8..a4f4fc67f78d3f 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll
@@ -1,9 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
; RUN: opt < %s -S | FileCheck %s
-; Test that we don't regress
diff quality by trying to keep variable names
-; stable (and messing up the matching).
-
define i32 @func(i32 %x) {
; CHECK-LABEL: define i32 @func(
; CHECK-SAME: i32 [[X:%.*]]) {
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll.expected b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll.expected
index 3d0f772505a659..08d3c22172ee3f 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values3.ll.expected
@@ -1,9 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3
; RUN: opt < %s -S | FileCheck %s
-; Test that we don't regress
diff quality by trying to keep variable names
-; stable (and messing up the matching).
-
define i32 @func(i32 %x) {
; CHECK-LABEL: define i32 @func(
; CHECK-SAME: i32 [[X:%.*]]) {
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values4.ll.expected b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values4.ll.expected
index 5962bdafd9ea0a..e3fa51598c48e3 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values4.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/stable_ir_values4.ll.expected
@@ -15,12 +15,12 @@ define i32 @func(i32 %x) {
; CHECK-NEXT: [[TMP6:%.*]] = call i32 @foo(i32 [[TMP5]])
; CHECK-NEXT: [[TMP7:%.*]] = call i32 @foo(i32 [[TMP6]])
; CHECK-NEXT: [[TMP8:%.*]] = xor i32 [[TMP7]], 1
-; CHECK-NEXT: [[TMP9:%.*]] = call i32 @foo(i32 [[TMP8]])
-; CHECK-NEXT: [[TMP10:%.*]] = add i32 [[TMP9]], 1
+; CHECK-NEXT: [[TMP13:%.*]] = call i32 @foo(i32 [[TMP8]])
+; CHECK-NEXT: [[TMP9:%.*]] = add i32 [[TMP13]], 1
+; CHECK-NEXT: [[TMP10:%.*]] = call i32 @foo(i32 [[TMP9]])
; CHECK-NEXT: [[TMP11:%.*]] = call i32 @foo(i32 [[TMP10]])
; CHECK-NEXT: [[TMP12:%.*]] = call i32 @foo(i32 [[TMP11]])
-; CHECK-NEXT: [[TMP13:%.*]] = call i32 @foo(i32 [[TMP12]])
-; CHECK-NEXT: ret i32 [[TMP13]]
+; CHECK-NEXT: ret i32 [[TMP12]]
;
%1 = mul i32 %x, 3
%2 = call i32 @foo(i32 %1)
diff --git a/llvm/test/tools/UpdateTestChecks/update_test_checks/stable_ir_values.test b/llvm/test/tools/UpdateTestChecks/update_test_checks/stable_ir_values.test
index c6287a6b29ca92..4dfaf5d25c8a69 100644
--- a/llvm/test/tools/UpdateTestChecks/update_test_checks/stable_ir_values.test
+++ b/llvm/test/tools/UpdateTestChecks/update_test_checks/stable_ir_values.test
@@ -1,2 +1,5 @@
# RUN: cp -f %S/Inputs/stable_ir_values.ll %t.ll && %update_test_checks %t.ll
# RUN:
diff -u %t.ll %S/Inputs/stable_ir_values.ll.expected
+# Now test that we can reset all the names
+# RUN: %update_test_checks %t.ll --reset-variable-names
+# RUN:
diff -u %t.ll %S/Inputs/stable_ir_values.ll.expected.reset
diff --git a/llvm/utils/UpdateTestChecks/common.py b/llvm/utils/UpdateTestChecks/common.py
index a3365fef5f6e7d..ecb19d233a8d1a 100644
--- a/llvm/utils/UpdateTestChecks/common.py
+++ b/llvm/utils/UpdateTestChecks/common.py
@@ -1,6 +1,8 @@
from __future__ import print_function
import argparse
+import bisect
+import collections
import copy
import glob
import itertools
@@ -10,7 +12,7 @@
import sys
import shlex
-from typing import List
+from typing import List, Mapping, Set
##### Common utilities for update_*test_checks.py
@@ -420,6 +422,48 @@ def should_add_line_to_output(
return True
+def collect_original_check_lines(ti: TestInfo, prefix_set: set):
+ """
+ Collect pre-existing check lines into a dictionary `result` which is
+ returned.
+
+ result[func_name][prefix] is filled with a list of right-hand-sides of check
+ lines.
+ """
+ result = {}
+
+ current_function = None
+ for input_line_info in ti.ro_iterlines():
+ input_line = input_line_info.line
+ if current_function is not None:
+ if input_line == "":
+ continue
+ if input_line.lstrip().startswith(";"):
+ m = CHECK_RE.match(input_line)
+ if (
+ m is not None
+ and m.group(1) in prefix_set
+ and m.group(2) not in ["LABEL", "SAME"]
+ ):
+ if m.group(1) not in current_function:
+ current_function[m.group(1)] = []
+ current_function[m.group(1)].append(input_line[m.end() :].strip())
+ continue
+ current_function = None
+
+ m = IR_FUNCTION_RE.match(input_line)
+ if m is not None:
+ func_name = m.group(1)
+ if ti.args.function is not None and func_name != ti.args.function:
+ # When filtering on a specific function, skip all others.
+ continue
+
+ assert func_name not in result
+ current_function = result[func_name] = {}
+
+ return result
+
+
# Perform lit-like substitutions
def getSubstitutions(sourcepath):
sourcedir = os.path.dirname(sourcepath)
@@ -491,7 +535,7 @@ def invoke_tool(exe, cmd_args, ir, preprocess_cmd=None, verbose=False):
CHECK_PREFIX_RE = re.compile(r"--?check-prefix(?:es)?[= ](\S+)")
PREFIX_RE = re.compile("^[a-zA-Z0-9_-]+$")
CHECK_RE = re.compile(
- r"^\s*(?://|[;#])\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL|-SAME|-EMPTY)?:"
+ r"^\s*(?://|[;#])\s*([^:]+?)(?:-(NEXT|NOT|DAG|LABEL|SAME|EMPTY))?:"
)
CHECK_SAME_RE = re.compile(r"^\s*(?://|[;#])\s*([^:]+?)(?:-SAME)?:")
@@ -1187,6 +1231,313 @@ def may_clash_with_default_check_prefix_name(check_prefix, var):
)
+def find_
diff _matching(lhs: List[str], rhs: List[str]) -> List[tuple]:
+ """
+ Find a large ordered matching between strings in lhs and rhs.
+
+ Think of this as finding the *unchanged* lines in a
diff , where the entries
+ of lhs and rhs are lines of the files being
diff ed.
+
+ Returns a list of matched (lhs_idx, rhs_idx) pairs.
+ """
+
+ if not lhs or not rhs:
+ return []
+
+ # Collect matches in reverse order.
+ matches = []
+
+ # First, collect a set of candidate matching edges. We limit this to a
+ # constant multiple of the input size to avoid quadratic runtime.
+ patterns = collections.defaultdict(lambda: ([], []))
+
+ for idx in range(len(lhs)):
+ patterns[lhs[idx]][0].append(idx)
+ for idx in range(len(rhs)):
+ patterns[rhs[idx]][1].append(idx)
+
+ multiple_patterns = []
+
+ candidates = []
+ for pattern in patterns.values():
+ if not pattern[0] or not pattern[1]:
+ continue
+
+ if len(pattern[0]) == len(pattern[1]) == 1:
+ candidates.append((pattern[0][0], pattern[1][0]))
+ else:
+ multiple_patterns.append(pattern)
+
+ multiple_patterns.sort(key=lambda pattern: len(pattern[0]) * len(pattern[1]))
+
+ for pattern in multiple_patterns:
+ if len(candidates) + len(pattern[0]) * len(pattern[1]) > 2 * (
+ len(lhs) + len(rhs)
+ ):
+ break
+ for lhs_idx in pattern[0]:
+ for rhs_idx in pattern[1]:
+ candidates.append((lhs_idx, rhs_idx))
+
+ if not candidates:
+ # The LHS and RHS either share nothing in common, or lines are just too
+ # identical. In that case, let's give up and not match anything.
+ return []
+
+ # Compute a maximal crossing-free matching via an algorithm that is
+ # inspired by a mixture of dynamic programming and line-sweeping in
+ # discrete geometry.
+ #
+ # I would be surprised if this algorithm didn't exist somewhere in the
+ # literature, but I found it without consciously recalling any
+ # references, so you'll have to make do with the explanation below.
+ # Sorry.
+ #
+ # The underlying graph is bipartite:
+ # - nodes on the LHS represent lines in the original check
+ # - nodes on the RHS represent lines in the new (updated) check
+ #
+ # Nodes are implicitly sorted by the corresponding line number.
+ # Edges (unique_matches) are sorted by the line number on the LHS.
+ #
+ # Here's the geometric intuition for the algorithm.
+ #
+ # * Plot the edges as points in the plane, with the original line
+ # number on the X axis and the updated line number on the Y axis.
+ # * The goal is to find a longest "chain" of points where each point
+ # is strictly above and to the right of the previous point.
+ # * The algorithm proceeds by sweeping a vertical line from left to
+ # right.
+ # * The algorithm maintains a table where `table[N]` answers the
+ # question "What is currently the 'best' way to build a chain of N+1
+ # points to the left of the vertical line". Here, 'best' means
+ # that the last point of the chain is a as low as possible (minimal
+ # Y coordinate).
+ # * `table[N]` is `(y, point_idx)` where `point_idx` is the index of
+ # the last point in the chain and `y` is its Y coordinate
+ # * A key invariant is that the Y values in the table are
+ # monotonically increasing
+ # * Thanks to these properties, the table can be used to answer the
+ # question "What is the longest chain that can be built to the left
+ # of the vertical line using only points below a certain Y value",
+ # using a binary search over the table.
+ # * The algorithm also builds a backlink structure in which every point
+ # links back to the previous point on a best (longest) chain ending
+ # at that point
+ #
+ # The core loop of the algorithm sweeps the line and updates the table
+ # and backlink structure for every point that we cross during the sweep.
+ # Therefore, the algorithm is trivially O(M log M) in the number of
+ # points.
+ candidates.sort(key=lambda candidate: (candidate[0], -candidate[1]))
+
+ backlinks = []
+ table_rhs_idx = []
+ table_candidate_idx = []
+ for _, rhs_idx in candidates:
+ candidate_idx = len(backlinks)
+ ti = bisect.bisect_left(table_rhs_idx, rhs_idx)
+
+ # Update the table to record a best chain ending in the current point.
+ # There always is one, and if any of the previously visited points had
+ # a higher Y coordinate, then there is always a previously recorded best
+ # chain that can be improved upon by using the current point.
+ #
+ # There is only one case where there is some ambiguity. If the
+ # pre-existing entry table[ti] has the same Y coordinate / rhs_idx as
+ # the current point (this can only happen if the same line appeared
+ # multiple times on the LHS), then we could choose to keep the
+ # previously recorded best chain instead. That would bias the algorithm
+ #
diff erently but should have no systematic impact on the quality of the
+ # result.
+ if ti < len(table_rhs_idx):
+ table_rhs_idx[ti] = rhs_idx
+ table_candidate_idx[ti] = candidate_idx
+ else:
+ table_rhs_idx.append(rhs_idx)
+ table_candidate_idx.append(candidate_idx)
+ if ti > 0:
+ backlinks.append(table_candidate_idx[ti - 1])
+ else:
+ backlinks.append(None)
+
+ # Commit to names in the matching by walking the backlinks. Recursively
+ # attempt to fill in more matches in-betweem.
+ match_idx = table_candidate_idx[-1]
+ while match_idx is not None:
+ current = candidates[match_idx]
+ matches.append(current)
+ match_idx = backlinks[match_idx]
+
+ matches.reverse()
+ return matches
+
+
+VARIABLE_TAG = "[[@@]]"
+METAVAR_RE = re.compile(r"\[\[([A-Z0-9_]+)(?::[^]]+)?\]\]")
+NUMERIC_SUFFIX_RE = re.compile(r"[0-9]*$")
+
+
+class CheckValueInfo:
+ def __init__(
+ self,
+ nameless_value: NamelessValue,
+ var: str,
+ prefix: str,
+ ):
+ self.nameless_value = nameless_value
+ self.var = var
+ self.prefix = prefix
+
+
+# Represent a check line in a way that allows us to compare check lines while
+# ignoring some or all of the FileCheck variable names.
+class CheckLineInfo:
+ def __init__(self, line, values):
+ # Line with all FileCheck variable name occurrences replaced by VARIABLE_TAG
+ self.line: str = line
+
+ # Information on each FileCheck variable name occurrences in the line
+ self.values: List[CheckValueInfo] = values
+
+ def __repr__(self):
+ return f"CheckLineInfo(line={self.line}, self.values={self.values})"
+
+
+def remap_metavar_names(
+ old_line_infos: List[CheckLineInfo],
+ new_line_infos: List[CheckLineInfo],
+ committed_names: Set[str],
+) -> Mapping[str, str]:
+ """
+ Map all FileCheck variable names that appear in new_line_infos to new
+ FileCheck variable names in an attempt to reduce the
diff from old_line_infos
+ to new_line_infos.
+
+ This is done by:
+ * Matching old check lines and new check lines using a
diff ing algorithm
+ applied after replacing names with wildcards.
+ * Committing to variable names such that the matched lines become equal
+ (without wildcards) if possible
+ * This is done recursively to handle cases where many lines are equal
+ after wildcard replacement
+ """
+ # Initialize uncommitted identity mappings
+ new_mapping = {}
+ for line in new_line_infos:
+ for value in line.values:
+ new_mapping[value.var] = value.var
+
+ # Recursively commit to the identity mapping or find a better one
+ def recurse(old_begin, old_end, new_begin, new_end):
+ if old_begin == old_end or new_begin == new_end:
+ return
+
+ # Find a matching of lines where uncommitted names are replaced
+ # with a placeholder.
+ def
diff ify_line(line, mapper):
+ values = []
+ for value in line.values:
+ mapped = mapper(value.var)
+ values.append(mapped if mapped in committed_names else "?")
+ return line.line.strip() + " @@@ " + " @ ".join(values)
+
+ lhs_lines = [
+
diff ify_line(line, lambda x: x)
+ for line in old_line_infos[old_begin:old_end]
+ ]
+ rhs_lines = [
+
diff ify_line(line, lambda x: new_mapping[x])
+ for line in new_line_infos[new_begin:new_end]
+ ]
+
+ candidate_matches = find_
diff _matching(lhs_lines, rhs_lines)
+
+ # Apply commits greedily on a match-by-match basis
+ matches = [(-1, -1)]
+ committed_anything = False
+ for lhs_idx, rhs_idx in candidate_matches:
+ lhs_line = old_line_infos[lhs_idx]
+ rhs_line = new_line_infos[rhs_idx]
+
+ local_commits = {}
+
+ for lhs_value, rhs_value in zip(lhs_line.values, rhs_line.values):
+ if new_mapping[rhs_value.var] in committed_names:
+ # The new value has already been committed. If it was mapped
+ # to the same name as the original value, we can consider
+ # committing other values from this line. Otherwise, we
+ # should ignore this line.
+ if new_mapping[rhs_value.var] == lhs_value.var:
+ continue
+ else:
+ break
+
+ if rhs_value.var in local_commits:
+ # Same, but for a possible commit happening on the same line
+ if local_commits[rhs_value.var] == lhs_value.var:
+ continue
+ else:
+ break
+
+ if lhs_value.var in committed_names:
+ # We can't map this value because the name we would map it to has already been
+ # committed for something else. Give up on this line.
+ break
+
+ local_commits[rhs_value.var] = lhs_value.var
+ else:
+ # No reason not to add any commitments for this line
+ for rhs_var, lhs_var in local_commits.items():
+ new_mapping[rhs_var] = lhs_var
+ committed_names.add(lhs_var)
+ committed_anything = True
+
+ if (
+ lhs_var != rhs_var
+ and lhs_var in new_mapping
+ and new_mapping[lhs_var] == lhs_var
+ ):
+ new_mapping[lhs_var] = "conflict_" + lhs_var
+
+ matches.append((lhs_idx, rhs_idx))
+
+ matches.append((old_end, new_end))
+
+ # Recursively handle sequences between matches
+ if committed_anything:
+ for (lhs_prev, rhs_prev), (lhs_next, rhs_next) in zip(matches, matches[1:]):
+ recurse(lhs_prev + 1, lhs_next, rhs_prev + 1, rhs_next)
+
+ recurse(0, len(old_line_infos), 0, len(new_line_infos))
+
+ # Commit to remaining names and resolve conflicts
+ for new_name, mapped_name in new_mapping.items():
+ if mapped_name in committed_names:
+ continue
+ if not mapped_name.startswith("conflict_"):
+ assert mapped_name == new_name
+ committed_names.add(mapped_name)
+
+ for new_name, mapped_name in new_mapping.items():
+ if mapped_name in committed_names:
+ continue
+ assert mapped_name.startswith("conflict_")
+
+ m = NUMERIC_SUFFIX_RE.search(new_name)
+ base_name = new_name[: m.start()]
+ suffix = int(new_name[m.start() :]) if m.start() != m.end() else 1
+ while True:
+ candidate = f"{base_name}{suffix}"
+ if candidate not in committed_names:
+ new_mapping[new_name] = candidate
+ committed_names.add(candidate)
+ break
+ suffix += 1
+
+ return new_mapping
+
+
def generalize_check_lines_common(
lines,
is_analyze,
@@ -1196,11 +1547,12 @@ def generalize_check_lines_common(
nameless_value_regex,
is_asm,
preserve_names,
+ original_check_lines=None,
):
# 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):
+ def transform_line_vars(match, transform_locals=True):
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):
@@ -1210,6 +1562,8 @@ def transform_line_vars(match):
)
key = (var, nameless_value.check_key)
is_local_def = nameless_value.is_local_def_ir_value()
+ if is_local_def and not transform_locals:
+ return None
if is_local_def and key in vars_seen:
rv = nameless_value.get_value_use(var, match)
elif not is_local_def and key in global_vars_seen:
@@ -1228,13 +1582,15 @@ def transform_line_vars(match):
# including the commas and spaces.
return match.group(1) + rv + match.group(match.lastindex)
- lines_with_def = []
+ def transform_non_local_line_vars(match):
+ return transform_line_vars(match, False)
+
multiple_braces_re = re.compile(r"({{+)|(}}+)")
def escape_braces(match_obj):
return '{{' + re.escape(match_obj.group(0)) + '}}'
- for i, line in enumerate(lines):
- if not is_asm and not is_analyze:
+ if not is_asm and not is_analyze:
+ for i, line in enumerate(lines):
# An IR variable named '%.' matches the FileCheck regex string.
line = line.replace("%.", "%dot")
for regex in _global_hex_value_regex:
@@ -1252,25 +1608,136 @@ def escape_braces(match_obj):
# Ignore any comments, since the check lines will too.
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r"", line)
lines[i] = scrubbed_line
- if not preserve_names:
- # 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) = nameless_value_regex.subn(
- transform_line_vars, lines[i], count=1
- )
- if is_analyze:
+
+ if not preserve_names:
+ if is_asm:
+ for i, _ in enumerate(lines):
+ # 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) = nameless_value_regex.subn(
+ transform_line_vars, lines[i], count=1
+ )
+ else:
+ # LLVM IR case. Start by handling global meta variables (global IR variables,
+ # metadata, attributes)
+ for i, _ in enumerate(lines):
+ start = 0
+ while True:
+ m = nameless_value_regex.search(lines[i][start:])
+ if m is None:
+ break
+ start += m.start()
+ sub = transform_non_local_line_vars(m)
+ if sub is not None:
+ lines[i] = (
+ lines[i][:start] + sub + lines[i][start + len(m.group(0)) :]
+ )
+ start += 1
+
+ # Collect information about new check lines and original check lines (if any)
+ new_line_infos = []
+ for line in lines:
+ filtered_line = ""
+ values = []
+ while True:
+ m = nameless_value_regex.search(line)
+ if m is None:
+ filtered_line += line
+ break
+
+ var = get_name_from_ir_value_match(m)
+ nameless_value = get_nameless_value_from_match(m, nameless_values)
+ var = nameless_value.get_value_name(
+ var, nameless_value.check_prefix
+ )
+
+ # Replace with a [[@@]] tag, but be sure to keep the spaces and commas.
+ filtered_line += (
+ line[: m.start()]
+ + m.group(1)
+ + VARIABLE_TAG
+ + m.group(m.lastindex)
+ )
+ line = line[m.end() :]
+ values.append(
+ CheckValueInfo(
+ nameless_value=nameless_value,
+ var=var,
+ prefix=nameless_value.get_ir_prefix_from_ir_value_match(m)[
+ 0
+ ],
+ )
+ )
+ new_line_infos.append(CheckLineInfo(filtered_line, values))
+
+ orig_line_infos = []
+ for line in original_check_lines or []:
+ filtered_line = ""
+ values = []
+ while True:
+ m = METAVAR_RE.search(line)
+ if m is None:
+ filtered_line += line
+ break
+
+ # Replace with a [[@@]] tag, but be sure to keep the spaces and commas.
+ filtered_line += line[: m.start()] + VARIABLE_TAG
+ line = line[m.end() :]
+ values.append(
+ CheckValueInfo(
+ nameless_value=None,
+ var=m.group(1),
+ prefix=None,
+ )
+ )
+ orig_line_infos.append(CheckLineInfo(filtered_line, values))
+
+ # Compute the variable name mapping
+ committed_names = set(vars_seen)
+
+ mapping = remap_metavar_names(
+ orig_line_infos, new_line_infos, committed_names
+ )
+
+ for i, line_info in enumerate(new_line_infos):
+ line_template = line_info.line
+ line = ""
+
+ for value in line_info.values:
+ idx = line_template.find(VARIABLE_TAG)
+ line += line_template[:idx]
+ line_template = line_template[idx + len(VARIABLE_TAG) :]
+
+ key = (mapping[value.var], nameless_value.check_key)
+ is_local_def = nameless_value.is_local_def_ir_value()
+ if is_local_def:
+ if mapping[value.var] in vars_seen:
+ line += f"[[{mapping[value.var]}]]"
+ else:
+ line += f"[[{mapping[value.var]}:{value.prefix}{value.nameless_value.get_ir_regex()}]]"
+ vars_seen.add(mapping[value.var])
+ else:
+ raise RuntimeError("not implemented")
+
+ line += line_template
+
+ lines[i] = line
+
+ if is_analyze:
+ for i, _ in enumerate(lines):
# Escape multiple {{ or }} as {{}} denotes a FileCheck regex.
scrubbed_line = multiple_braces_re.sub(escape_braces, lines[i])
lines[i] = scrubbed_line
+
return lines
# Replace IR value defs and uses with FileCheck variables.
def generalize_check_lines(
- lines, is_analyze, vars_seen, global_vars_seen, preserve_names
+ lines, is_analyze, vars_seen, global_vars_seen, preserve_names, original_check_lines
):
return generalize_check_lines_common(
lines,
@@ -1281,6 +1748,7 @@ def generalize_check_lines(
IR_VALUE_RE,
False,
preserve_names,
+ original_check_lines=original_check_lines,
)
@@ -1337,6 +1805,7 @@ def add_checks(
global_vars_seen_dict,
is_filtered,
preserve_names=False,
+ original_check_lines: Mapping[str, List[str]] = {},
):
# 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()
@@ -1409,6 +1878,7 @@ def add_checks(
vars_seen,
global_vars_seen,
preserve_names,
+ original_check_lines=[],
)[0]
func_name_separator = func_dict[checkprefix][func_name].func_name_separator
if "[[" in args_and_sig:
@@ -1516,7 +1986,12 @@ def add_checks(
# to variable naming fashions.
else:
func_body = generalize_check_lines(
- func_body, False, vars_seen, global_vars_seen, preserve_names
+ func_body,
+ False,
+ vars_seen,
+ global_vars_seen,
+ preserve_names,
+ original_check_lines=original_check_lines.get(checkprefix),
)
# This could be selectively enabled with an optional invocation argument.
@@ -1578,6 +2053,7 @@ def add_ir_checks(
version,
global_vars_seen_dict,
is_filtered,
+ original_check_lines={},
):
# Label format is based on IR string.
if function_sig and version > 1:
@@ -1602,6 +2078,7 @@ def add_ir_checks(
global_vars_seen_dict,
is_filtered,
preserve_names,
+ original_check_lines=original_check_lines,
)
@@ -1890,6 +2367,7 @@ def get_autogennote_suffix(parser, args):
"llvm_bin",
"verbose",
"force_update",
+ "reset_variable_names",
):
continue
value = getattr(args, action.dest)
diff --git a/llvm/utils/update_test_checks.py b/llvm/utils/update_test_checks.py
index b5077d79351378..04808ce6bb1c6f 100755
--- a/llvm/utils/update_test_checks.py
+++ b/llvm/utils/update_test_checks.py
@@ -85,6 +85,12 @@ def main():
choices=["none", "smart", "all"],
help="Check global entries (global variables, metadata, attribute sets, ...) for functions",
)
+ parser.add_argument(
+ "--reset-variable-names",
+ action="store_true",
+ help="Reset all variable names to correspond closely to the variable names in IR. "
+ "This tends to result in larger
diff s.",
+ )
parser.add_argument("tests", nargs="+")
initial_args = common.parse_commandline_args(parser)
@@ -170,13 +176,19 @@ def main():
)
builder.processed_prefixes(prefixes)
+ prefix_set = set(
+ [prefix for prefixes, _, _ in prefix_list for prefix in prefixes]
+ )
+
+ if not ti.args.reset_variable_names:
+ original_check_lines = common.collect_original_check_lines(ti, prefix_set)
+ else:
+ original_check_lines = {}
+
func_dict = builder.finish_and_get_func_dict()
is_in_function = False
is_in_function_start = False
has_checked_pre_function_globals = False
- prefix_set = set(
- [prefix for prefixes, _, _ in prefix_list for prefix in prefixes]
- )
common.debug("Rewriting FileCheck prefixes:", str(prefix_set))
output_lines = []
@@ -230,6 +242,7 @@ def main():
args.version,
global_vars_seen_dict,
is_filtered=builder.is_filtered(),
+ original_check_lines=original_check_lines.get(func, {}),
),
)
)
@@ -261,6 +274,9 @@ def main():
args.version,
global_vars_seen_dict,
is_filtered=builder.is_filtered(),
+ original_check_lines=original_check_lines.get(
+ func_name, {}
+ ),
)
)
is_in_function_start = False
More information about the llvm-commits
mailing list