mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-25 05:06:06 +00:00
6f973fd4ab
update_mc_test_check script handle the "error case testline" wrong in three cases: 1. when user select "--llvm-mc-binary" with a path, the script does not add "not" on top of the "--llvm-mc-binary" and thus getting non-zero exit code and failed. 2. When "not" is presented in runline while not all testlines are expected to fail, the script need to check if the "not" is needed when it execute llvm-mc line by line. Otherwise the script will fail on testline which is passing. 3. When there are multiple runlines, the error checkline need to use correct line offset for "[[LINE-X]]" This patch solve these three issues
439 lines
14 KiB
Python
Executable File
439 lines
14 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
A test update script. This script is a utility to update LLVM 'llvm-mc' based test cases with new FileCheck patterns.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import argparse
|
|
import functools
|
|
import os # Used to advertise this file's name ("autogenerated_note").
|
|
|
|
from UpdateTestChecks import common
|
|
|
|
import subprocess
|
|
import re
|
|
|
|
mc_LIKE_TOOLS = [
|
|
"llvm-mc",
|
|
]
|
|
ERROR_RE = re.compile(r":\d+: (warning|error): .*")
|
|
ERROR_CHECK_RE = re.compile(r"# COM: .*")
|
|
OUTPUT_SKIPPED_RE = re.compile(r"(.text)")
|
|
COMMENT = {"asm": "//", "dasm": "#"}
|
|
|
|
|
|
def invoke_tool(exe, check_rc, cmd_args, testline, verbose=False):
|
|
if isinstance(cmd_args, list):
|
|
args = [applySubstitutions(a, substitutions) for a in cmd_args]
|
|
else:
|
|
args = cmd_args
|
|
|
|
cmd = 'echo "' + testline + '" | ' + exe + " " + args
|
|
if verbose:
|
|
print("Command: ", cmd)
|
|
|
|
out = subprocess.run(
|
|
cmd,
|
|
shell=True,
|
|
check=check_rc,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL,
|
|
).stdout
|
|
|
|
# Fix line endings to unix CR style.
|
|
return out.decode().replace("\r\n", "\n")
|
|
|
|
|
|
# create tests line-by-line, here we just filter out the check lines and comments
|
|
# and treat all others as tests
|
|
def isTestLine(input_line, mc_mode):
|
|
line = input_line.strip()
|
|
# Skip empty and comment lines
|
|
if not line or line.startswith(COMMENT[mc_mode]):
|
|
return False
|
|
# skip any CHECK lines.
|
|
elif common.CHECK_RE.match(input_line):
|
|
return False
|
|
return True
|
|
|
|
|
|
def isRunLine(l):
|
|
return common.RUN_LINE_RE.match(l)
|
|
|
|
|
|
def hasErr(err):
|
|
return err and ERROR_RE.search(err) is not None
|
|
|
|
|
|
def getErrString(err):
|
|
if not err:
|
|
return ""
|
|
|
|
# take the first match
|
|
for line in err.splitlines():
|
|
s = ERROR_RE.search(line)
|
|
if s:
|
|
return s.group(0)
|
|
return ""
|
|
|
|
|
|
def getOutputString(out):
|
|
if not out:
|
|
return ""
|
|
output = ""
|
|
|
|
for line in out.splitlines():
|
|
if OUTPUT_SKIPPED_RE.search(line):
|
|
continue
|
|
if line.strip("\t ") == "":
|
|
continue
|
|
output += line.lstrip("\t ")
|
|
return output
|
|
|
|
|
|
def should_add_line_to_output(input_line, prefix_set, mc_mode):
|
|
# special check line
|
|
if mc_mode == "dasm" and ERROR_CHECK_RE.search(input_line):
|
|
return False
|
|
else:
|
|
return common.should_add_line_to_output(
|
|
input_line, prefix_set, comment_marker=COMMENT[mc_mode]
|
|
)
|
|
|
|
|
|
def getStdCheckLine(prefix, output, mc_mode):
|
|
o = ""
|
|
for line in output.splitlines():
|
|
o += COMMENT[mc_mode] + " " + prefix + ": " + line + "\n"
|
|
return o
|
|
|
|
|
|
def getErrCheckLine(prefix, output, mc_mode, line_offset=1):
|
|
return (
|
|
COMMENT[mc_mode]
|
|
+ " "
|
|
+ prefix
|
|
+ ": "
|
|
+ ":[[@LINE-{}]]".format(line_offset)
|
|
+ output
|
|
+ "\n"
|
|
)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument(
|
|
"--llvm-mc-binary",
|
|
default=None,
|
|
help='The "mc" binary to use to generate the test case',
|
|
)
|
|
parser.add_argument(
|
|
"--tool",
|
|
default=None,
|
|
help="Treat the given tool name as an mc-like tool for which check lines should be generated",
|
|
)
|
|
parser.add_argument(
|
|
"--default-march",
|
|
default=None,
|
|
help="Set a default -march for when neither triple nor arch are found in a RUN line",
|
|
)
|
|
parser.add_argument(
|
|
"--unique",
|
|
action="store_true",
|
|
default=False,
|
|
help="remove duplicated test line if found",
|
|
)
|
|
parser.add_argument(
|
|
"--sort",
|
|
action="store_true",
|
|
default=False,
|
|
help="sort testline in alphabetic order (keep run-lines on top), this option could be dangerous as it"
|
|
"could change the order of lines that are not expected",
|
|
)
|
|
parser.add_argument("tests", nargs="+")
|
|
initial_args = common.parse_commandline_args(parser)
|
|
|
|
script_name = os.path.basename(__file__)
|
|
|
|
for ti in common.itertests(
|
|
initial_args.tests, parser, script_name="utils/" + script_name
|
|
):
|
|
if ti.path.endswith(".s"):
|
|
mc_mode = "asm"
|
|
elif ti.path.endswith(".txt"):
|
|
mc_mode = "dasm"
|
|
|
|
if ti.args.sort:
|
|
print("sorting with dasm(.txt) file is not supported!")
|
|
return -1
|
|
|
|
else:
|
|
common.warn("Expected .s and .txt, Skipping file : ", ti.path)
|
|
continue
|
|
|
|
triple_in_ir = None
|
|
for l in ti.input_lines:
|
|
m = common.TRIPLE_IR_RE.match(l)
|
|
if m:
|
|
triple_in_ir = m.groups()[0]
|
|
break
|
|
|
|
run_list = []
|
|
for l in ti.run_lines:
|
|
if "|" not in l:
|
|
common.warn("Skipping unparsable RUN line: " + l)
|
|
continue
|
|
|
|
commands = [cmd.strip() for cmd in l.split("|")]
|
|
assert len(commands) >= 2
|
|
mc_cmd = " | ".join(commands[:-1])
|
|
filecheck_cmd = commands[-1]
|
|
|
|
# special handling for negating exit status
|
|
# if not is used in runline, disable rc check, since
|
|
# the command might or might not
|
|
# return non-zero code on a single line run
|
|
check_rc = True
|
|
mc_cmd_args = mc_cmd.strip().split()
|
|
if mc_cmd_args[0] == "not":
|
|
check_rc = False
|
|
mc_tool = mc_cmd_args[1]
|
|
mc_cmd = mc_cmd[len(mc_cmd_args[0]) :].strip()
|
|
else:
|
|
mc_tool = mc_cmd_args[0]
|
|
|
|
triple_in_cmd = None
|
|
m = common.TRIPLE_ARG_RE.search(mc_cmd)
|
|
if m:
|
|
triple_in_cmd = m.groups()[0]
|
|
|
|
march_in_cmd = ti.args.default_march
|
|
m = common.MARCH_ARG_RE.search(mc_cmd)
|
|
if m:
|
|
march_in_cmd = m.groups()[0]
|
|
|
|
common.verify_filecheck_prefixes(filecheck_cmd)
|
|
|
|
mc_like_tools = mc_LIKE_TOOLS[:]
|
|
if ti.args.tool:
|
|
mc_like_tools.append(ti.args.tool)
|
|
if mc_tool not in mc_like_tools:
|
|
common.warn("Skipping non-mc RUN line: " + l)
|
|
continue
|
|
|
|
if not filecheck_cmd.startswith("FileCheck "):
|
|
common.warn("Skipping non-FileChecked RUN line: " + l)
|
|
continue
|
|
|
|
mc_cmd_args = mc_cmd[len(mc_tool) :].strip()
|
|
mc_cmd_args = mc_cmd_args.replace("< %s", "").replace("%s", "").strip()
|
|
check_prefixes = common.get_check_prefixes(filecheck_cmd)
|
|
|
|
run_list.append(
|
|
(
|
|
check_prefixes,
|
|
mc_tool,
|
|
check_rc,
|
|
mc_cmd_args,
|
|
triple_in_cmd,
|
|
march_in_cmd,
|
|
)
|
|
)
|
|
|
|
# find all test line from input
|
|
testlines = [l for l in ti.input_lines if isTestLine(l, mc_mode)]
|
|
# remove duplicated lines to save running time
|
|
testlines = list(dict.fromkeys(testlines))
|
|
common.debug("Valid test line found: ", len(testlines))
|
|
|
|
run_list_size = len(run_list)
|
|
testnum = len(testlines)
|
|
|
|
raw_output = []
|
|
raw_prefixes = []
|
|
for (
|
|
prefixes,
|
|
mc_tool,
|
|
check_rc,
|
|
mc_args,
|
|
triple_in_cmd,
|
|
march_in_cmd,
|
|
) in run_list:
|
|
common.debug("Extracted mc cmd:", mc_tool, mc_args)
|
|
common.debug("Extracted FileCheck prefixes:", str(prefixes))
|
|
common.debug("Extracted triple :", str(triple_in_cmd))
|
|
common.debug("Extracted march:", str(march_in_cmd))
|
|
|
|
triple = triple_in_cmd or triple_in_ir
|
|
if not triple:
|
|
triple = common.get_triple_from_march(march_in_cmd)
|
|
|
|
raw_output.append([])
|
|
for line in testlines:
|
|
# get output for each testline
|
|
out = invoke_tool(
|
|
ti.args.llvm_mc_binary or mc_tool,
|
|
check_rc,
|
|
mc_args,
|
|
line,
|
|
verbose=ti.args.verbose,
|
|
)
|
|
raw_output[-1].append(out)
|
|
|
|
common.debug("Collect raw tool lines:", str(len(raw_output[-1])))
|
|
|
|
raw_prefixes.append(prefixes)
|
|
|
|
output_lines = []
|
|
generated_prefixes = {}
|
|
used_prefixes = set()
|
|
prefix_set = set([prefix for p in run_list for prefix in p[0]])
|
|
common.debug("Rewriting FileCheck prefixes:", str(prefix_set))
|
|
|
|
for test_id in range(testnum):
|
|
input_line = testlines[test_id]
|
|
|
|
# a {prefix : output, [runid] } dict
|
|
# insert output to a prefix-key dict, and do a max sorting
|
|
# to select the most-used prefix which share the same output string
|
|
p_dict = {}
|
|
for run_id in range(run_list_size):
|
|
out = raw_output[run_id][test_id]
|
|
|
|
if hasErr(out):
|
|
o = getErrString(out)
|
|
else:
|
|
o = getOutputString(out)
|
|
|
|
prefixes = raw_prefixes[run_id]
|
|
|
|
for p in prefixes:
|
|
if p not in p_dict:
|
|
p_dict[p] = o, [run_id]
|
|
else:
|
|
if p_dict[p] == (None, []):
|
|
continue
|
|
|
|
prev_o, run_ids = p_dict[p]
|
|
if o == prev_o:
|
|
run_ids.append(run_id)
|
|
p_dict[p] = o, run_ids
|
|
else:
|
|
# conflict, discard
|
|
p_dict[p] = None, []
|
|
|
|
p_dict_sorted = dict(
|
|
sorted(p_dict.items(), key=lambda item: -len(item[1][1]))
|
|
)
|
|
|
|
# prefix is selected and generated with most shared output lines
|
|
# each run_id can only be used once
|
|
gen_prefix = ""
|
|
used_runid = set()
|
|
|
|
# line number diff between generated prefix and testline
|
|
line_offset = 1
|
|
for prefix, tup in p_dict_sorted.items():
|
|
o, run_ids = tup
|
|
|
|
if len(run_ids) == 0:
|
|
continue
|
|
|
|
skip = False
|
|
for i in run_ids:
|
|
if i in used_runid:
|
|
skip = True
|
|
else:
|
|
used_runid.add(i)
|
|
if not skip:
|
|
used_prefixes.add(prefix)
|
|
|
|
if hasErr(o):
|
|
newline = getErrCheckLine(prefix, o, mc_mode, line_offset)
|
|
else:
|
|
newline = getStdCheckLine(prefix, o, mc_mode)
|
|
|
|
if newline:
|
|
gen_prefix += newline
|
|
line_offset += 1
|
|
|
|
generated_prefixes[input_line] = gen_prefix.rstrip("\n")
|
|
|
|
# write output
|
|
for input_info in ti.iterlines(output_lines):
|
|
input_line = input_info.line
|
|
if input_line in testlines:
|
|
output_lines.append(input_line)
|
|
output_lines.append(generated_prefixes[input_line])
|
|
|
|
elif should_add_line_to_output(input_line, prefix_set, mc_mode):
|
|
output_lines.append(input_line)
|
|
|
|
if ti.args.unique or ti.args.sort:
|
|
# split with double newlines
|
|
test_units = "\n".join(output_lines).split("\n\n")
|
|
|
|
# select the key line for each test unit
|
|
test_dic = {}
|
|
for unit in test_units:
|
|
lines = unit.split("\n")
|
|
for l in lines:
|
|
# if contains multiple lines, use
|
|
# the first testline or runline as key
|
|
if isTestLine(l, mc_mode):
|
|
test_dic[unit] = l
|
|
break
|
|
if isRunLine(l):
|
|
test_dic[unit] = l
|
|
break
|
|
|
|
# unique
|
|
if ti.args.unique:
|
|
new_test_units = []
|
|
written_lines = set()
|
|
for unit in test_units:
|
|
# if not testline/runline, we just add it
|
|
if unit not in test_dic:
|
|
new_test_units.append(unit)
|
|
else:
|
|
if test_dic[unit] in written_lines:
|
|
common.debug("Duplicated test skipped: ", unit)
|
|
continue
|
|
|
|
written_lines.add(test_dic[unit])
|
|
new_test_units.append(unit)
|
|
test_units = new_test_units
|
|
|
|
# sort
|
|
if ti.args.sort:
|
|
|
|
def getkey(l):
|
|
# find key of test unit, otherwise use first line
|
|
if l in test_dic:
|
|
line = test_dic[l]
|
|
else:
|
|
line = l.split("\n")[0]
|
|
|
|
# runline placed on the top
|
|
return (not isRunLine(line), line)
|
|
|
|
test_units = sorted(test_units, key=getkey)
|
|
|
|
# join back to be output string
|
|
output_lines = "\n\n".join(test_units).split("\n")
|
|
|
|
# output
|
|
if ti.args.gen_unused_prefix_body:
|
|
output_lines.extend(
|
|
ti.get_checks_for_unused_prefixes(run_list, used_prefixes)
|
|
)
|
|
|
|
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()
|