mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-04-04 16:54:12 +00:00
2196dd6cfa
This patch replaces the --x86_extra_scrub command line argument to automatically support a second level of regex-scrubbing if it improves the matching of nearly-identical code patterns. The argument '--extra_scrub' is there now to force extra matching if required.
This is mostly useful to help us share 32-bit/64-bit x86 vector tests which only differs by retl/retq instructions, but any scrubber can now technically support this, meaning test checks don't have to be needlessly obfuscated.
I've updated some of the existing checks that had been manually run with --x86_extra_scrub, to demonstrate the extra "ret{{[l|q]}}" scrub now only happens when useful, and re-run the sse42-intrinsics file to show extra matches - most sse/avx intrinsics files should be able to now share 32/64 checks.
Tested with the opt/analysis scripts as well which share common code - AFAICT the other update scripts use their own versions.
Differential Revision: https://reviews.llvm.org/D47485
llvm-svn: 333749
267 lines
9.7 KiB
Python
267 lines
9.7 KiB
Python
from __future__ import print_function
|
|
import re
|
|
import string
|
|
import subprocess
|
|
import sys
|
|
import copy
|
|
|
|
if sys.version_info[0] > 2:
|
|
class string:
|
|
expandtabs = str.expandtabs
|
|
else:
|
|
import string
|
|
|
|
##### Common utilities for update_*test_checks.py
|
|
|
|
def should_add_line_to_output(input_line, prefix_set):
|
|
# Skip any blank comment lines in the IR.
|
|
if 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:
|
|
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
|
|
# update_llc_test_checks.py
|
|
# The safer list form is used by update_cc_test_checks.py
|
|
if isinstance(cmd_args, list):
|
|
stdout = subprocess.check_output([exe] + cmd_args, stdin=ir_file)
|
|
else:
|
|
stdout = subprocess.check_output(exe + ' ' + cmd_args,
|
|
shell=True, stdin=ir_file)
|
|
if sys.version_info[0] > 2:
|
|
stdout = stdout.decode()
|
|
# Fix line endings to unix CR style.
|
|
return stdout.replace('\r\n', '\n')
|
|
|
|
##### LLVM IR parser
|
|
|
|
RUN_LINE_RE = re.compile('^\s*[;#]\s*RUN:\s*(.*)$')
|
|
CHECK_PREFIX_RE = re.compile('--?check-prefix(?:es)?[= ](\S+)')
|
|
CHECK_RE = re.compile(r'^\s*[;#]\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:')
|
|
|
|
OPT_FUNCTION_RE = re.compile(
|
|
r'^\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w-]+?)\s*\('
|
|
r'(\s+)?[^)]*[^{]*\{\n(?P<body>.*?)^\}$',
|
|
flags=(re.M | re.S))
|
|
|
|
ANALYZE_FUNCTION_RE = re.compile(
|
|
r'^\s*\'(?P<analysis>[\w\s-]+?)\'\s+for\s+function\s+\'(?P<func>[\w-]+?)\':'
|
|
r'\s*\n(?P<body>.*)$',
|
|
flags=(re.X | re.S))
|
|
|
|
IR_FUNCTION_RE = re.compile('^\s*define\s+(?:internal\s+)?[^@]*@(\w+)\s*\(')
|
|
TRIPLE_IR_RE = re.compile(r'^\s*target\s+triple\s*=\s*"([^"]+)"$')
|
|
TRIPLE_ARG_RE = re.compile(r'-mtriple[= ]([^ ]+)')
|
|
MARCH_ARG_RE = re.compile(r'-march[= ]([^ ]+)')
|
|
|
|
SCRUB_LEADING_WHITESPACE_RE = re.compile(r'^(\s+)')
|
|
SCRUB_WHITESPACE_RE = re.compile(r'(?!^(| \w))[ \t]+', flags=re.M)
|
|
SCRUB_TRAILING_WHITESPACE_RE = re.compile(r'[ \t]+$', flags=re.M)
|
|
SCRUB_KILL_COMMENT_RE = re.compile(r'^ *#+ +kill:.*\n')
|
|
SCRUB_LOOP_COMMENT_RE = re.compile(
|
|
r'# =>This Inner Loop Header:.*|# in Loop:.*', flags=re.M)
|
|
|
|
def scrub_body(body):
|
|
# Scrub runs of whitespace out of the assembly, but leave the leading
|
|
# whitespace in place.
|
|
body = SCRUB_WHITESPACE_RE.sub(r' ', body)
|
|
# Expand the tabs used for indentation.
|
|
body = string.expandtabs(body, 2)
|
|
# Strip trailing whitespace.
|
|
body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body)
|
|
return body
|
|
|
|
def do_scrub(body, scrubber, scrubber_args, extra):
|
|
if scrubber_args:
|
|
local_args = copy.deepcopy(scrubber_args)
|
|
local_args[0].extra_scrub = extra
|
|
return scrubber(body, *local_args)
|
|
return scrubber(body, *scrubber_args)
|
|
|
|
# Build up a dictionary of all the function bodies.
|
|
class function_body(object):
|
|
def __init__(self, string, extra):
|
|
self.scrub = string
|
|
self.extrascrub = extra
|
|
def __str__(self):
|
|
return self.scrub
|
|
|
|
def build_function_body_dictionary(function_re, scrubber, scrubber_args, raw_tool_output, prefixes, func_dict, verbose):
|
|
for m in function_re.finditer(raw_tool_output):
|
|
if not m:
|
|
continue
|
|
func = m.group('func')
|
|
body = m.group('body')
|
|
scrubbed_body = do_scrub(body, scrubber, scrubber_args, extra = False)
|
|
scrubbed_extra = do_scrub(body, scrubber, scrubber_args, extra = True)
|
|
if m.groupdict().has_key('analysis'):
|
|
analysis = m.group('analysis')
|
|
if analysis.lower() != 'cost model analysis':
|
|
print('WARNING: Unsupported analysis mode: %r!' % (analysis,), file=sys.stderr)
|
|
if func.startswith('stress'):
|
|
# We only use the last line of the function body for stress tests.
|
|
scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:])
|
|
if verbose:
|
|
print('Processing function: ' + func, file=sys.stderr)
|
|
for l in scrubbed_body.splitlines():
|
|
print(' ' + l, file=sys.stderr)
|
|
for prefix in prefixes:
|
|
if func in func_dict[prefix] and str(func_dict[prefix][func]) != scrubbed_body:
|
|
if func_dict[prefix][func] and func_dict[prefix][func].extrascrub == scrubbed_extra:
|
|
func_dict[prefix][func].scrub = scrubbed_extra
|
|
continue
|
|
else:
|
|
if prefix == prefixes[-1]:
|
|
print('WARNING: Found conflicting asm under the '
|
|
'same prefix: %r!' % (prefix,), file=sys.stderr)
|
|
else:
|
|
func_dict[prefix][func] = None
|
|
continue
|
|
|
|
func_dict[prefix][func] = function_body(scrubbed_body, scrubbed_extra)
|
|
|
|
##### Generator of LLVM IR CHECK lines
|
|
|
|
SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*')
|
|
|
|
# Match things that look at identifiers, but only if they are followed by
|
|
# spaces, commas, paren, or end of the string
|
|
IR_VALUE_RE = re.compile(r'(\s+)%([\w\.\-]+?)([,\s\(\)]|\Z)')
|
|
|
|
# Create a FileCheck variable name based on an IR name.
|
|
def get_value_name(var):
|
|
if var.isdigit():
|
|
var = 'TMP' + var
|
|
var = var.replace('.', '_')
|
|
var = var.replace('-', '_')
|
|
return var.upper()
|
|
|
|
|
|
# Create a FileCheck variable from regex.
|
|
def get_value_definition(var):
|
|
return '[[' + get_value_name(var) + ':%.*]]'
|
|
|
|
|
|
# Use a FileCheck variable.
|
|
def get_value_use(var):
|
|
return '[[' + get_value_name(var) + ']]'
|
|
|
|
# Replace IR value defs and uses with FileCheck variables.
|
|
def genericize_check_lines(lines, is_analyze):
|
|
# 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):
|
|
var = match.group(2)
|
|
if var in vars_seen:
|
|
rv = get_value_use(var)
|
|
else:
|
|
vars_seen.add(var)
|
|
rv = get_value_definition(var)
|
|
# re.sub replaces the entire regex match
|
|
# with whatever you return, so we have
|
|
# to make sure to hand it back everything
|
|
# including the commas and spaces.
|
|
return match.group(1) + rv + match.group(3)
|
|
|
|
vars_seen = set()
|
|
lines_with_def = []
|
|
|
|
for i, line in enumerate(lines):
|
|
# An IR variable named '%.' matches the FileCheck regex string.
|
|
line = line.replace('%.', '%dot')
|
|
# Ignore any comments, since the check lines will too.
|
|
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r'', line)
|
|
if is_analyze == False:
|
|
lines[i] = IR_VALUE_RE.sub(transform_line_vars, scrubbed_line)
|
|
else:
|
|
lines[i] = scrubbed_line
|
|
return lines
|
|
|
|
|
|
def add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, is_asm, is_analyze):
|
|
printed_prefixes = []
|
|
for p in prefix_list:
|
|
checkprefixes = p[0]
|
|
for checkprefix in checkprefixes:
|
|
if checkprefix in printed_prefixes:
|
|
break
|
|
# TODO func_dict[checkprefix] may be None, '' or not exist.
|
|
# Fix the call sites.
|
|
if func_name not in func_dict[checkprefix] or not func_dict[checkprefix][func_name]:
|
|
continue
|
|
|
|
# Add some space between different check prefixes, but not after the last
|
|
# check line (before the test code).
|
|
if is_asm == True:
|
|
if len(printed_prefixes) != 0:
|
|
output_lines.append(comment_marker)
|
|
|
|
printed_prefixes.append(checkprefix)
|
|
output_lines.append(check_label_format % (checkprefix, func_name))
|
|
func_body = str(func_dict[checkprefix][func_name]).splitlines()
|
|
|
|
# For ASM output, just emit the check lines.
|
|
if is_asm == True:
|
|
output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0]))
|
|
for func_line in func_body[1:]:
|
|
output_lines.append('%s %s-NEXT: %s' % (comment_marker, checkprefix, func_line))
|
|
break
|
|
|
|
# For IR output, change all defs to FileCheck variables, so we're immune
|
|
# to variable naming fashions.
|
|
func_body = genericize_check_lines(func_body, is_analyze)
|
|
|
|
# This could be selectively enabled with an optional invocation argument.
|
|
# Disabled for now: better to check everything. Be safe rather than sorry.
|
|
|
|
# Handle the first line of the function body as a special case because
|
|
# it's often just noise (a useless asm comment or entry label).
|
|
#if func_body[0].startswith("#") or func_body[0].startswith("entry:"):
|
|
# is_blank_line = True
|
|
#else:
|
|
# output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0]))
|
|
# is_blank_line = False
|
|
|
|
is_blank_line = False
|
|
|
|
for func_line in func_body:
|
|
if func_line.strip() == '':
|
|
is_blank_line = True
|
|
continue
|
|
# Do not waste time checking IR comments.
|
|
func_line = SCRUB_IR_COMMENT_RE.sub(r'', func_line)
|
|
|
|
# Skip blank lines instead of checking them.
|
|
if is_blank_line == True:
|
|
output_lines.append('{} {}: {}'.format(
|
|
comment_marker, checkprefix, func_line))
|
|
else:
|
|
output_lines.append('{} {}-NEXT: {}'.format(
|
|
comment_marker, checkprefix, func_line))
|
|
is_blank_line = False
|
|
|
|
# Add space between different check prefixes and also before the first
|
|
# line of code in the test function.
|
|
output_lines.append(comment_marker)
|
|
break
|
|
|
|
def add_ir_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
|
|
# Label format is based on IR string.
|
|
check_label_format = '{} %s-LABEL: @%s('.format(comment_marker)
|
|
add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, False)
|
|
|
|
def add_analyze_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
|
|
check_label_format = '{} %s-LABEL: \'%s\''.format(comment_marker)
|
|
add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, False, True)
|