#!/usr/bin/env python3
"""A test case update script.
This script is a utility to update LLVM 'llvm-mca' based test cases with new
FileCheck patterns.
"""
import argparse
from collections import defaultdict
import glob
import os
import sys
import warnings
from UpdateTestChecks import common
COMMENT_CHAR = "#"
ADVERT_PREFIX = "{} NOTE: Assertions have been autogenerated by ".format(COMMENT_CHAR)
ADVERT = "{}utils/{}".format(ADVERT_PREFIX, os.path.basename(__file__))
class Error(Exception):
"""Generic Error that can be raised without printing a traceback."""
pass
def _warn(msg):
"""Log a user warning to stderr."""
warnings.warn(msg, Warning, stacklevel=2)
def _configure_warnings(args):
warnings.resetwarnings()
if args.w:
warnings.simplefilter("ignore")
if args.Werror:
warnings.simplefilter("error")
def _showwarning(message, category, filename, lineno, file=None, line=None):
"""Version of warnings.showwarning that won't attempt to print out the
line at the location of the warning if the line text is not explicitly
specified.
"""
if file is None:
file = sys.stderr
if line is None:
line = ""
file.write(warnings.formatwarning(message, category, filename, lineno, line))
def _get_parser():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-w", action="store_true", help="suppress warnings")
parser.add_argument(
"-Werror", action="store_true", help="promote warnings to errors"
)
parser.add_argument(
"--llvm-mca-binary",
metavar="<path>",
default="llvm-mca",
help="the binary to use to generate the test case " "(default: llvm-mca)",
)
parser.add_argument("tests", metavar="<test-path>", nargs="+")
return parser
def _get_run_infos(run_lines, args):
run_infos = []
for run_line in run_lines:
try:
(tool_cmd, filecheck_cmd) = tuple(
[cmd.strip() for cmd in run_line.split("|", 1)]
)
except ValueError:
_warn("could not split tool and filecheck commands: {}".format(run_line))
continue
common.verify_filecheck_prefixes(filecheck_cmd)
tool_basename = os.path.splitext(os.path.basename(args.llvm_mca_binary))[0]
if not tool_cmd.startswith(tool_basename + " "):
_warn("skipping non-{} RUN line: {}".format(tool_basename, run_line))
continue
if not filecheck_cmd.startswith("FileCheck "):
_warn("skipping non-FileCheck RUN line: {}".format(run_line))
continue
tool_cmd_args = tool_cmd[len(tool_basename) :].strip()
tool_cmd_args = tool_cmd_args.replace("< %s", "").replace("%s", "").strip()
check_prefixes = common.get_check_prefixes(filecheck_cmd)
run_infos.append((check_prefixes, tool_cmd_args))
return run_infos
def _break_down_block(block_info, common_prefix):
"""Given a block_info, see if we can analyze it further to let us break it
down by prefix per-line rather than per-block.
"""
texts = block_info.keys()
prefixes = list(block_info.values())
# Split the lines from each of the incoming block_texts and zip them so that
# each element contains the corresponding lines from each text. E.g.
#
# block_text_1: A # line 1
# B # line 2
#
# block_text_2: A # line 1
# C # line 2
#
# would become:
#
# [(A, A), # line 1
# (B, C)] # line 2
#
line_tuples = list(zip(*list((text.splitlines() for text in texts))))
# To simplify output, we'll only proceed if the very first line of the block
# texts is common to each of them.
if len(set(line_tuples[0])) != 1:
return []
result = []
lresult = defaultdict(list)
for i, line in enumerate(line_tuples):
if len(set(line)) == 1:
# We're about to output a line with the common prefix. This is a sync
# point so flush any batched-up lines one prefix at a time to the output
# first.
for prefix in sorted(lresult):
result.extend(lresult[prefix])
lresult = defaultdict(list)
# The line is common to each block so output with the common prefix.
result.append((common_prefix, line[0]))
else:
# The line is not common to each block, or we don't have a common prefix.
# If there are no prefixes available, warn and bail out.
if not prefixes[0]:
_warn(
"multiple lines not disambiguated by prefixes:\n{}\n"
"Some blocks may be skipped entirely as a result.".format(
"\n".join(" - {}".format(l) for l in line)
)
)
return []
# Iterate through the line from each of the blocks and add the line with
# the corresponding prefix to the current batch of results so that we can
# later output them per-prefix.
for i, l in enumerate(line):
for prefix in prefixes[i]:
lresult[prefix].append((prefix, l))
# Flush any remaining batched-up lines one prefix at a time to the output.
for prefix in sorted(lresult):
result.extend(lresult[prefix])
return result
def _get_useful_prefix_info(run_infos):
"""Given the run_infos, calculate any prefixes that are common to every one,
and the length of the longest prefix string.
"""
try:
all_sets = [set(s) for s in list(zip(*run_infos))[0]]
common_to_all = set.intersection(*all_sets)
longest_prefix_len = max(len(p) for p in set.union(*all_sets))
except IndexError:
common_to_all = []
longest_prefix_len = 0
else:
if len(common_to_all) > 1:
_warn("Multiple prefixes common to all RUN lines: {}".format(common_to_all))
if common_to_all:
common_to_all = sorted(common_to_all)[0]
return common_to_all, longest_prefix_len
def _align_matching_blocks(all_blocks, farthest_indexes):
"""Some sub-sequences of blocks may be common to multiple lists of blocks,
but at different indexes in each one.
For example, in the following case, A,B,E,F, and H are common to both
sets, but only A and B would be identified as such due to the indexes
matching:
index | 0 1 2 3 4 5 6
------+--------------
setA | A B C D E F H
setB | A B E F G H
This function attempts to align the indexes of matching blocks by
inserting empty blocks into the block list. With this approach, A, B, E,
F, and H would now be able to be identified as matching blocks:
index | 0 1 2 3 4 5 6 7
------+----------------
setA | A B C D E F H
setB | A B E F G H
"""
# "Farthest block analysis": essentially, iterate over all blocks and find
# the highest index into a block list for the first instance of each block.
# This is relatively expensive, but we're dealing with small numbers of
# blocks so it doesn't make a perceivable difference to user time.
for blocks in all_blocks.values():
for block in blocks:
if not block:
continue
index = blocks.index(block)
if index > farthest_indexes[block]:
farthest_indexes[block] = index
# Use the results of the above analysis to identify any blocks that can be
# shunted along to match the farthest index value.
for blocks in all_blocks.values():
for index, block in enumerate(blocks):
if not block:
continue
changed = False
# If the block has not already been subject to alignment (i.e. if the
# previous block is not empty) then insert empty blocks until the index
# matches the farthest index identified for that block.
if (index > 0) and blocks[index - 1]:
while index < farthest_indexes[block]:
blocks.insert(index, "")
index += 1
changed = True
if changed:
# Bail out. We'll need to re-do the farthest block analysis now that
# we've inserted some blocks.
return True
return False
def _get_block_infos(run_infos, test_path, args, common_prefix): # noqa
"""For each run line, run the tool with the specified args and collect the
output. We use the concept of 'blocks' for uniquing, where a block is
a series of lines of text with no more than one newline character between
each one. For example:
This
is
one
block
This is
another block
This is yet another block
We then build up a 'block_infos' structure containing a dict where the
text of each block is the key and a list of the sets of prefixes that may
generate that particular block. This then goes through a series of
transformations to minimise the amount of CHECK lines that need to be
written by taking advantage of common prefixes.
"""
def _block_key(tool_args, prefixes):
"""Get a hashable key based on the current tool_args and prefixes."""
return " ".join([tool_args] + prefixes)
all_blocks = {}
max_block_len = 0
# A cache of the furthest-back position in any block list of the first
# instance of each block, indexed by the block itself.
farthest_indexes = defaultdict(int)
# Run the tool for each run line to generate all of the blocks.
for prefixes, tool_args in run_infos:
key = _block_key(tool_args, prefixes)
raw_tool_output = common.invoke_tool(args.llvm_mca_binary, tool_args, test_path)
# Replace any lines consisting of purely whitespace with empty lines.
raw_tool_output = "\n".join(
line if line.strip() else "" for line in raw_tool_output.splitlines()
)
# Split blocks, stripping all trailing whitespace, but keeping preceding
# whitespace except for newlines so that columns will line up visually.
all_blocks[key] = [
b.lstrip("\n").rstrip() for b in raw_tool_output.split("\n\n")
]
max_block_len = max(max_block_len, len(all_blocks[key]))
# Attempt to align matching blocks until no more changes can be made.
made_changes = True
while made_changes:
made_changes = _align_matching_blocks(all_blocks, farthest_indexes)
# If necessary, pad the lists of blocks with empty blocks so that they are
# all the same length.
for key in all_blocks:
len_to_pad = max_block_len - len(all_blocks[key])
all_blocks[key] += [""] * len_to_pad
# Create the block_infos structure where it is a nested dict in the form of:
# block number -> block text -> list of prefix sets
block_infos = defaultdict(lambda: defaultdict(list))
for prefixes, tool_args in run_infos:
key = _block_key(tool_args, prefixes)
for block_num, block_text in enumerate(all_blocks[key]):
block_infos[block_num][block_text].append(set(prefixes))
# Now go through the block_infos structure and attempt to smartly prune the
# number of prefixes per block to the minimal set possible to output.
for block_num in range(len(block_infos)):
# When there are multiple block texts for a block num, remove any
# prefixes that are common to more than one of them.
# E.g. [ [{ALL,FOO}] , [{ALL,BAR}] ] -> [ [{FOO}] , [{BAR}] ]
all_sets = [s for s in block_infos[block_num].values()]
pruned_sets = []
for i, setlist in enumerate(all_sets):
other_set_values = set(
[
elem
for j, setlist2 in enumerate(all_sets)
for set_ in setlist2
for elem in set_
if i != j
]
)
pruned_sets.append([s - other_set_values for s in setlist])
for i, block_text in enumerate(block_infos[block_num]):
# When a block text matches multiple sets of prefixes, try removing any
# prefixes that aren't common to all of them.
# E.g. [ {ALL,FOO} , {ALL,BAR} ] -> [{ALL}]
common_values = set.intersection(*pruned_sets[i])
if common_values:
pruned_sets[i] = [common_values]
# Everything should be uniqued as much as possible by now. Apply the
# newly pruned sets to the block_infos structure.
# If there are any blocks of text that still match multiple prefixes,
# output a warning.
current_set = set()
for s in pruned_sets[i]:
s = sorted(list(s))
if s:
current_set.add(s[0])
if len(s) > 1:
_warn(
"Multiple prefixes generating same output: {} "
"(discarding {})".format(",".join(s), ",".join(s[1:]))
)
if block_text and not current_set:
raise Error(
"block not captured by existing prefixes:\n\n{}".format(block_text)
)
block_infos[block_num][block_text] = sorted(list(current_set))
# If we have multiple block_texts, try to break them down further to avoid
# the case where we have very similar block_texts repeated after each
# other.
if common_prefix and len(block_infos[block_num]) > 1:
# We'll only attempt this if each of the block_texts have the same number
# of lines as each other.
same_num_Lines = (
len(set(len(k.splitlines()) for k in block_infos[block_num].keys()))
== 1
)
if same_num_Lines:
breakdown = _break_down_block(block_infos[block_num], common_prefix)
if breakdown:
block_infos[block_num] = breakdown
return block_infos
def _write_block(output, block, not_prefix_set, common_prefix, prefix_pad):
"""Write an individual block, with correct padding on the prefixes.
Returns a set of all of the prefixes that it has written.
"""
end_prefix = ": "
previous_prefix = None
num_lines_of_prefix = 0
written_prefixes = set()
for prefix, line in block:
if prefix in not_prefix_set:
_warn(
'not writing for prefix {0} due to presence of "{0}-NOT:" '
"in input file.".format(prefix)
)
continue
# If the previous line isn't already blank and we're writing more than one
# line for the current prefix output a blank line first, unless either the
# current of previous prefix is common to all.
num_lines_of_prefix += 1
if prefix != previous_prefix:
if output and output[-1]:
if num_lines_of_prefix > 1 or any(
p == common_prefix for p in (prefix, previous_prefix)
):
output.append("")
num_lines_of_prefix = 0
previous_prefix = prefix
written_prefixes.add(prefix)
output.append(
"{} {}{}{} {}".format(
COMMENT_CHAR, prefix, end_prefix, " " * (prefix_pad - len(prefix)), line
).rstrip()
)
end_prefix = "-NEXT:"
output.append("")
return written_prefixes
def _write_output(
test_path,
input_lines,
prefix_list,
block_infos, # noqa
args,
common_prefix,
prefix_pad,
):
prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
not_prefix_set = set()
output_lines = []
for input_line in input_lines:
if input_line.startswith(ADVERT_PREFIX):
continue
if input_line.startswith(COMMENT_CHAR):
m = common.CHECK_RE.match(input_line)
try:
prefix = m.group(1)
except AttributeError:
prefix = None
if "{}-NOT:".format(prefix) in input_line:
not_prefix_set.add(prefix)
if prefix not in prefix_set or prefix in not_prefix_set:
output_lines.append(input_line)
continue
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)
# Skip empty lines if the previous output line is also empty.
if input_line or output_lines[-1]:
output_lines.append(input_line)
else:
continue
# Add a blank line before the new checks if required.
if len(output_lines) > 0 and output_lines[-1]:
output_lines.append("")
output_check_lines = []
used_prefixes = set()
for block_num in range(len(block_infos)):
if type(block_infos[block_num]) is list:
# The block is of the type output from _break_down_block().
used_prefixes |= _write_block(
output_check_lines,
block_infos[block_num],
not_prefix_set,
common_prefix,
prefix_pad,
)
else:
# _break_down_block() was unable to do do anything so output the block
# as-is.
# Rather than writing out each block as soon we encounter it, save it
# indexed by prefix so that we can write all of the blocks out sorted by
# prefix at the end.
output_blocks = defaultdict(list)
for block_text in sorted(block_infos[block_num]):
if not block_text:
continue
lines = block_text.split("\n")
for prefix in block_infos[block_num][block_text]:
assert prefix not in output_blocks
used_prefixes |= _write_block(
output_blocks[prefix],
[(prefix, line) for line in lines],
not_prefix_set,
common_prefix,
prefix_pad,
)
for prefix in sorted(output_blocks):
output_check_lines.extend(output_blocks[prefix])
unused_prefixes = (prefix_set - not_prefix_set) - used_prefixes
if unused_prefixes:
raise Error("unused prefixes: {}".format(sorted(unused_prefixes)))
if output_check_lines:
output_lines.insert(0, ADVERT)
output_lines.extend(output_check_lines)
# The file should not end with two newlines. It creates unnecessary churn.
while len(output_lines) > 0 and output_lines[-1] == "":
output_lines.pop()
if input_lines == output_lines:
sys.stderr.write(" [unchanged]\n")
return
sys.stderr.write(" [{} lines total]\n".format(len(output_lines)))
common.debug("Writing", len(output_lines), "lines to", test_path, "..\n\n")
with open(test_path, "wb") as f:
f.writelines(["{}\n".format(l).encode("utf-8") for l in output_lines])
def update_test_file(args, test_path, autogenerated_note):
sys.stderr.write("Test: {}\n".format(test_path))
# Call this per test. By default each warning will only be written once
# per source location. Reset the warning filter so that now each warning
# will be written once per source location per test.
_configure_warnings(args)
with open(test_path) as f:
input_lines = [l.rstrip() for l in f]
run_lines = common.find_run_lines(test_path, input_lines)
run_infos = _get_run_infos(run_lines, args)
common_prefix, prefix_pad = _get_useful_prefix_info(run_infos)
block_infos = _get_block_infos(run_infos, test_path, args, common_prefix)
_write_output(
test_path,
input_lines,
run_infos,
block_infos,
args,
common_prefix,
prefix_pad,
)
def main():
script_name = "utils/" + os.path.basename(__file__)
parser = _get_parser()
args = common.parse_commandline_args(parser)
if not args.llvm_mca_binary:
raise Error("--llvm-mca-binary value cannot be empty string")
if "llvm-mca" not in os.path.basename(args.llvm_mca_binary):
_warn("unexpected binary name: {}".format(args.llvm_mca_binary))
for ti in common.itertests(args.tests, parser, script_name=script_name):
try:
update_test_file(ti.args, ti.path, ti.test_autogenerated_note)
except Exception:
common.warn("Error processing file", test_file=ti.path)
raise
return 0
if __name__ == "__main__":
try:
warnings.showwarning = _showwarning
sys.exit(main())
except Error as e:
sys.stdout.write("error: {}\n".format(e))
sys.exit(1)
Codebase Browser
llvm