This is an archive of the discontinued LLVM Phabricator instance.

Differential D70432

[UpdateTestChecks] Share the code to parse RUN: lines between all scripts
ClosedPublic

Authored by arichardson on Nov 19 2019, 4:24 AM.

Details

Reviewers
xbolva00
MaskRay
jdoerfert
Commits
rGd9542db49e90: [UpdateTestChecks] Share the code to parse RUN: lines between all scripts
Summary

This commit also introduces a common.debug() function to avoid many
if args.verbose: statements. Depends on D70428.

Diff Detail

Event Timeline

arichardson created this revision.Nov 19 2019, 4:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 19 2019, 4:24 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B41163: Diff 230034.Nov 19 2019, 4:28 AM
xbolva00 added a comment.EditedNov 23 2019, 12:59 PM

I like this patch. Please ensure that everything works (we really need some tests for update scripts :) ).

@MaskRay ?

MaskRay added inline comments.Nov 23 2019, 1:33 PM
llvm/utils/UpdateTestChecks/common.py
109

Use single quotes '

arichardson updated this revision to Diff 230855.Nov 25 2019, 2:05 AM
  • Python2 fixes
  • Address feedback
Harbormaster completed remote builds in B41434: Diff 230855.Nov 25 2019, 2:06 AM
arichardson mentioned this in D70660: Add initial tests for update_{llc,cc}_test_checks.py.Nov 25 2019, 2:08 AM
MaskRay accepted this revision.Nov 25 2019, 12:51 PM
This revision is now accepted and ready to land.Nov 25 2019, 12:51 PM
Closed by commit rGd9542db49e90: [UpdateTestChecks] Share the code to parse RUN: lines between all scripts (authored by arichardson). · Explain WhyDec 2 2019, 3:09 AM
This revision was automatically updated to reflect the committed changes.
qiucf mentioned this in D70941: [UpdateTestChecks] Fix issue on handling backslashes of RUN lines..Dec 3 2019, 12:03 AM

Revision Contents

Diff 230034

llvm/utils/UpdateTestChecks/common.py

from __future__ import print_function from __future__ import print_function
import re import re
import string import string
import subprocess import subprocess
import sys import sys
import copy import copy
if sys.version_info[0] > 2: if sys.version_info[0] > 2:
class string: class string:
expandtabs = str.expandtabs expandtabs = str.expandtabs
else: else:
import string import string
##### Common utilities for update_*test_checks.py ##### Common utilities for update_*test_checks.py
_verbose = False
def parse_commandline_args(parser): def parse_commandline_args(parser):
parser.add_argument('-v', '--verbose', action='store_true', parser.add_argument('-v', '--verbose', action='store_true',
help='Show verbose output') help='Show verbose output')
parser.add_argument('-u', '--update-only', action='store_true', parser.add_argument('-u', '--update-only', action='store_true',
help='Only update test if it was already autogened') help='Only update test if it was already autogened')
return parser.parse_args() args = parser.parse_args()
global _verbose
_verbose = args.verbose
return args
def should_add_line_to_output(input_line, prefix_set): def should_add_line_to_output(input_line, prefix_set):
# Skip any blank comment lines in the IR. # Skip any blank comment lines in the IR.
if input_line.strip() == ';': if input_line.strip() == ';':
return False return False
# Skip any blank lines in the IR. # Skip any blank lines in the IR.
#if input_line.strip() == '': #if input_line.strip() == '':
# return False # return False
Show All 17 Lines else:
shell=True, stdin=ir_file) shell=True, stdin=ir_file)
if sys.version_info[0] > 2: if sys.version_info[0] > 2:
stdout = stdout.decode() stdout = stdout.decode()
# Fix line endings to unix CR style. # Fix line endings to unix CR style.
return stdout.replace('\r\n', '\n') return stdout.replace('\r\n', '\n')
##### LLVM IR parser ##### LLVM IR parser
RUN_LINE_RE = re.compile(r'^\s*[;#]\s*RUN:\s*(.*)$') RUN_LINE_RE = re.compile(r'^\s*(?://|[;#])\s*RUN:\s*(.*)$')
CHECK_PREFIX_RE = re.compile(r'--?check-prefix(?:es)?[= ](\S+)') CHECK_PREFIX_RE = re.compile(r'--?check-prefix(?:es)?[= ](\S+)')
PREFIX_RE = re.compile('^[a-zA-Z0-9_-]+$') PREFIX_RE = re.compile('^[a-zA-Z0-9_-]+$')
CHECK_RE = re.compile(r'^\s*[;#]\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL|-SAME)?:') CHECK_RE = re.compile(r'^\s*[;#]\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL|-SAME)?:')
OPT_FUNCTION_RE = re.compile( OPT_FUNCTION_RE = re.compile(
r'^\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w-]+?)\s*' r'^\s*define\s+(?:internal\s+)?[^@]*@(?P<func>[\w-]+?)\s*'
r'(?P<args_and_sig>\((\)|(.*?[\w\.\-]+?)\))[^{]*)\{\n(?P<body>.*?)^\}$', r'(?P<args_and_sig>\((\)|(.*?[\w\.\-]+?)\))[^{]*)\{\n(?P<body>.*?)^\}$',
flags=(re.M | re.S)) flags=(re.M | re.S))
Show All 21 Lines if test_file:
msg = '{}: {}'.format(msg, test_file) msg = '{}: {}'.format(msg, test_file)
print('ERROR: {}'.format(msg), file=sys.stderr) print('ERROR: {}'.format(msg), file=sys.stderr)
def warn(msg, test_file=None): def warn(msg, test_file=None):
if test_file: if test_file:
msg = '{}: {}'.format(msg, test_file) msg = '{}: {}'.format(msg, test_file)
print('WARNING: {}'.format(msg), file=sys.stderr) print('WARNING: {}'.format(msg), file=sys.stderr)
def debug(*args, file=sys.stderr, **kwargs):
if _verbose:
print(*args, file=file, **kwargs)
def find_run_lines(test, lines):
debug('Scanning for RUN lines in test file:', test)
raw_lines = [m.group(1)
for m in [RUN_LINE_RE.match(l) for l in lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith("\\"):
MaskRayUnsubmitted
Not Done
ReplyInline Actions

Use single quotes '

MaskRay: Use single quotes '
run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
else:
run_lines.append(l)
debug('Found {} RUN lines in {}:'.format(len(run_lines), test))
for l in run_lines:
debug(' RUN: {}'.format(l))
return run_lines
def scrub_body(body): def scrub_body(body):
# Scrub runs of whitespace out of the assembly, but leave the leading # Scrub runs of whitespace out of the assembly, but leave the leading
# whitespace in place. # whitespace in place.
body = SCRUB_WHITESPACE_RE.sub(r' ', body) body = SCRUB_WHITESPACE_RE.sub(r' ', body)
# Expand the tabs used for indentation. # Expand the tabs used for indentation.
body = string.expandtabs(body, 2) body = string.expandtabs(body, 2)
# Strip trailing whitespace. # Strip trailing whitespace.
body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body) body = SCRUB_TRAILING_WHITESPACE_RE.sub(r'', body)
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

llvm/utils/update_analyze_test_checks.py

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesdef main():
opt_basename = os.path.basename(args.opt_binary) opt_basename = os.path.basename(args.opt_binary)
if (opt_basename != "opt"): if (opt_basename != "opt"):
common.error('Unexpected opt name: ' + opt_basename) common.error('Unexpected opt name: ' + opt_basename)
sys.exit(1) sys.exit(1)
test_paths = [test for pattern in args.tests for test in glob.glob(pattern)] test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
for test in test_paths: for test in test_paths:
if args.verbose:
print('Scanning for RUN lines in test file: %s' % (test,), file=sys.stderr)
with open(test) as f: with open(test) as f:
input_lines = [l.rstrip() for l in f] input_lines = [l.rstrip() for l in f]
first_line = input_lines[0] if input_lines else "" first_line = input_lines[0] if input_lines else ""
if 'autogenerated' in first_line and script_name not in first_line: if 'autogenerated' in first_line and script_name not in first_line:
common.warn("Skipping test which wasn't autogenerated by " + script_name + ": " + test) common.warn("Skipping test which wasn't autogenerated by " + script_name + ": " + test)
continue continue
if args.update_only: if args.update_only:
if not first_line or 'autogenerated' not in first_line: if not first_line or 'autogenerated' not in first_line:
common.warn("Skipping test which isn't autogenerated: " + test) common.warn("Skipping test which isn't autogenerated: " + test)
continue continue
raw_lines = [m.group(1) run_lines = common.find_run_lines(test, input_lines)
for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith("\\"):
run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
else:
run_lines.append(l)
if args.verbose:
print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
for l in run_lines:
print(' RUN: ' + l, file=sys.stderr)
prefix_list = [] prefix_list = []
for l in run_lines: for l in run_lines:
if '|' not in l: if '|' not in l:
common.warn('Skipping unparseable RUN line: ' + l) common.warn('Skipping unparseable RUN line: ' + l)
continue continue
(tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)]) (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
common.verify_filecheck_prefixes(filecheck_cmd) common.verify_filecheck_prefixes(filecheck_cmd)
Show All 18 Lines for l in run_lines:
# now, we just ignore all but the last. # now, we just ignore all but the last.
prefix_list.append((check_prefixes, tool_cmd_args)) prefix_list.append((check_prefixes, tool_cmd_args))
func_dict = {} func_dict = {}
for prefixes, _ in prefix_list: for prefixes, _ in prefix_list:
for prefix in prefixes: for prefix in prefixes:
func_dict.update({prefix: dict()}) func_dict.update({prefix: dict()})
for prefixes, opt_args in prefix_list: for prefixes, opt_args in prefix_list:
if args.verbose: common.debug('Extracted opt cmd:', opt_basename, opt_args, file=sys.stderr)
print('Extracted opt cmd: ' + opt_basename + ' ' + opt_args, file=sys.stderr) common.debug('Extracted FileCheck prefixes:', str(prefixes), file=sys.stderr)
print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
raw_tool_outputs = common.invoke_tool(args.opt_binary, opt_args, test) raw_tool_outputs = common.invoke_tool(args.opt_binary, opt_args, test)
# Split analysis outputs by "Printing analysis " declarations. # Split analysis outputs by "Printing analysis " declarations.
for raw_tool_output in re.split(r'Printing analysis ', raw_tool_outputs): for raw_tool_output in re.split(r'Printing analysis ', raw_tool_outputs):
common.build_function_body_dictionary( common.build_function_body_dictionary(
common.ANALYZE_FUNCTION_RE, common.scrub_body, [], common.ANALYZE_FUNCTION_RE, common.scrub_body, [],
raw_tool_output, prefixes, func_dict, args.verbose, False) raw_tool_output, prefixes, func_dict, args.verbose, False)
is_in_function = False is_in_function = False
is_in_function_start = False is_in_function_start = False
prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes]) prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
if args.verbose: common.debug('Rewriting FileCheck prefixes:', str(prefix_set), file=sys.stderr)
print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
output_lines = [] output_lines = []
output_lines.append(autogenerated_note) output_lines.append(autogenerated_note)
for input_line in input_lines: for input_line in input_lines:
if is_in_function_start: if is_in_function_start:
if input_line == '': if input_line == '':
continue continue
if input_line.lstrip().startswith(';'): if input_line.lstrip().startswith(';'):
Show All 29 Lines for input_line in input_lines:
if not m: if not m:
continue continue
func_name = m.group(1) func_name = m.group(1)
if args.function is not None and func_name != args.function: if args.function is not None and func_name != args.function:
# When filtering on a specific function, skip all others. # When filtering on a specific function, skip all others.
continue continue
is_in_function = is_in_function_start = True is_in_function = is_in_function_start = True
if args.verbose: common.debug('Writing %d lines to %s...' % (len(output_lines), test))
print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
with open(test, 'wb') as f: with open(test, 'wb') as f:
f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines]) f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
if __name__ == '__main__': if __name__ == '__main__':
main() main()

llvm/utils/update_cc_test_checks.py

Show All 23 Lines
import re import re
import tempfile import tempfile
from UpdateTestChecks import asm, common from UpdateTestChecks import asm, common
ADVERT = '// NOTE: Assertions have been autogenerated by ' ADVERT = '// NOTE: Assertions have been autogenerated by '
CHECK_RE = re.compile(r'^\s*//\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:') CHECK_RE = re.compile(r'^\s*//\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:')
RUN_LINE_RE = re.compile(r'^//\s*RUN:\s*(.*)$')
SUBST = { SUBST = {
'%clang': [], '%clang': [],
'%clang_cc1': ['-cc1'], '%clang_cc1': ['-cc1'],
'%clangxx': ['--driver-mode=g++'], '%clangxx': ['--driver-mode=g++'],
} }
def get_line2spell_and_mangled(args, clang_args): def get_line2spell_and_mangled(args, clang_args):
def debug_mangled(*print_args, **kwargs):
if args.verbose:
print(*print_args, file=sys.stderr, **kwargs)
ret = {} ret = {}
# Use clang's JSON AST dump to get the mangled name # Use clang's JSON AST dump to get the mangled name
json_dump_args = [args.clang, *clang_args, '-fsyntax-only', '-o', '-'] json_dump_args = [args.clang, *clang_args, '-fsyntax-only', '-o', '-']
if '-cc1' not in json_dump_args: if '-cc1' not in json_dump_args:
# For tests that invoke %clang instead if %clang_cc1 we have to use # For tests that invoke %clang instead if %clang_cc1 we have to use
# -Xclang -ast-dump=json instead: # -Xclang -ast-dump=json instead:
json_dump_args.append('-Xclang') json_dump_args.append('-Xclang')
json_dump_args.append('-ast-dump=json') json_dump_args.append('-ast-dump=json')
debug_mangled('Running', ' '.join(json_dump_args)) common.debug('Running', ' '.join(json_dump_args))
status = subprocess.run(json_dump_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) status = subprocess.run(json_dump_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if status.returncode != 0: if status.returncode != 0:
sys.stderr.write('Failed to run ' + ' '.join(json_dump_args) + '\n') sys.stderr.write('Failed to run ' + ' '.join(json_dump_args) + '\n')
sys.stderr.write(status.stderr.decode()) sys.stderr.write(status.stderr.decode())
sys.stderr.write(status.stdout.decode()) sys.stderr.write(status.stdout.decode())
sys.exit(2) sys.exit(2)
ast = json.loads(status.stdout.decode()) ast = json.loads(status.stdout.decode())
if ast['kind'] != 'TranslationUnitDecl': if ast['kind'] != 'TranslationUnitDecl':
common.error('Clang AST dump JSON format changed?') common.error('Clang AST dump JSON format changed?')
sys.exit(2) sys.exit(2)
# Get the inner node and iterate over all children of type FunctionDecl. # Get the inner node and iterate over all children of type FunctionDecl.
# TODO: Should we add checks for global variables being emitted? # TODO: Should we add checks for global variables being emitted?
for node in ast['inner']: for node in ast['inner']:
if node['kind'] != 'FunctionDecl': if node['kind'] != 'FunctionDecl':
continue continue
if node.get('isImplicit') is True and node.get('storageClass') == 'extern': if node.get('isImplicit') is True and node.get('storageClass') == 'extern':
debug_mangled('Skipping builtin function:', node['name'], '@', node['loc']) common.debug('Skipping builtin function:', node['name'], '@', node['loc'])
continue continue
debug_mangled('Found function:', node['kind'], node['name'], '@', node['loc']) common.debug('Found function:', node['kind'], node['name'], '@', node['loc'])
line = node['loc'].get('line') line = node['loc'].get('line')
# If there is no line it is probably a builtin function -> skip # If there is no line it is probably a builtin function -> skip
if line is None: if line is None:
debug_mangled('Skipping function without line number:', node['name'], '@', node['loc']) common.debug('Skipping function without line number:', node['name'], '@', node['loc'])
continue continue
spell = node['name'] spell = node['name']
mangled = node.get('mangledName', spell) mangled = node.get('mangledName', spell)
ret[int(line)-1] = (spell, mangled) ret[int(line)-1] = (spell, mangled)
if args.verbose:
for line, func_name in sorted(ret.items()): for line, func_name in sorted(ret.items()):
print('line {}: found function {}'.format(line+1, func_name), file=sys.stderr) common.debug('line {}: found function {}'.format(line+1, func_name), file=sys.stderr)
if not ret: if not ret:
common.warn('Did not find any functions using', ' '.join(json_dump_args)) common.warn('Did not find any functions using', ' '.join(json_dump_args))
return ret return ret
def config(): def config():
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description=__doc__, description=__doc__,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines if 'autogenerated' in first_line and script_name not in first_line:
continue continue
if args.update_only: if args.update_only:
if not first_line or 'autogenerated' not in first_line: if not first_line or 'autogenerated' not in first_line:
common.warn("Skipping test which isn't autogenerated: " + filename) common.warn("Skipping test which isn't autogenerated: " + filename)
continue continue
# Extract RUN lines. # Extract RUN lines.
raw_lines = [m.group(1) run_lines = common.find_run_lines(filename, input_lines)
for m in [RUN_LINE_RE.match(l) for l in input_lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith("\\"):
run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
else:
run_lines.append(l)
if args.verbose:
print('Found {} RUN lines:'.format(len(run_lines)), file=sys.stderr)
for l in run_lines:
print(' RUN: ' + l, file=sys.stderr)
# Build a list of clang command lines and check prefixes from RUN lines. # Build a list of clang command lines and check prefixes from RUN lines.
run_list = [] run_list = []
line2spell_and_mangled_list = collections.defaultdict(list) line2spell_and_mangled_list = collections.defaultdict(list)
for l in run_lines: for l in run_lines:
commands = [cmd.strip() for cmd in l.split('|')] commands = [cmd.strip() for cmd in l.split('|')]
triple_in_cmd = None triple_in_cmd = None
Show All 40 Lines for filename in args.tests:
# Execute clang, generate LLVM IR, and extract functions. # Execute clang, generate LLVM IR, and extract functions.
func_dict = {} func_dict = {}
for p in run_list: for p in run_list:
prefixes = p[0] prefixes = p[0]
for prefix in prefixes: for prefix in prefixes:
func_dict.update({prefix: dict()}) func_dict.update({prefix: dict()})
for prefixes, clang_args, extra_commands, triple_in_cmd in run_list: for prefixes, clang_args, extra_commands, triple_in_cmd in run_list:
if args.verbose: common.debug('Extracted clang cmd: clang {}'.format(clang_args))
print('Extracted clang cmd: clang {}'.format(clang_args), file=sys.stderr) common.debug('Extracted FileCheck prefixes: {}'.format(prefixes))
print('Extracted FileCheck prefixes: {}'.format(prefixes), file=sys.stderr)
get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict) get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict)
# Invoke clang -Xclang -ast-dump=json to get mapping from start lines to # Invoke clang -Xclang -ast-dump=json to get mapping from start lines to
# mangled names. Forward all clang args for now. # mangled names. Forward all clang args for now.
for k, v in get_line2spell_and_mangled(args, clang_args).items(): for k, v in get_line2spell_and_mangled(args, clang_args).items():
line2spell_and_mangled_list[k].append(v) line2spell_and_mangled_list[k].append(v)
Show All 33 Lines

llvm/utils/update_llc_test_checks.py

Show All 37 Lines parser.add_argument(
'--no_x86_scrub_rip', action='store_false', dest='x86_scrub_rip') '--no_x86_scrub_rip', action='store_false', dest='x86_scrub_rip')
parser.add_argument('tests', nargs='+') parser.add_argument('tests', nargs='+')
args = common.parse_commandline_args(parser) args = common.parse_commandline_args(parser)
script_name = os.path.basename(__file__) script_name = os.path.basename(__file__)
test_paths = [test for pattern in args.tests for test in glob.glob(pattern)] test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
for test in test_paths: for test in test_paths:
if args.verbose:
print('Scanning for RUN lines in test file: %s' % (test,), file=sys.stderr)
with open(test) as f: with open(test) as f:
input_lines = [l.rstrip() for l in f] input_lines = [l.rstrip() for l in f]
first_line = input_lines[0] if input_lines else "" first_line = input_lines[0] if input_lines else ""
if 'autogenerated' in first_line and script_name not in first_line: if 'autogenerated' in first_line and script_name not in first_line:
common.warn("Skipping test which wasn't autogenerated by " + script_name, test) common.warn("Skipping test which wasn't autogenerated by " + script_name, test)
continue continue
if args.update_only: if args.update_only:
if not first_line or 'autogenerated' not in first_line: if not first_line or 'autogenerated' not in first_line:
common.warn("Skipping test which isn't autogenerated: " + test) common.warn("Skipping test which isn't autogenerated: " + test)
continue continue
triple_in_ir = None triple_in_ir = None
for l in input_lines: for l in input_lines:
m = common.TRIPLE_IR_RE.match(l) m = common.TRIPLE_IR_RE.match(l)
if m: if m:
triple_in_ir = m.groups()[0] triple_in_ir = m.groups()[0]
break break
raw_lines = [m.group(1) run_lines = common.find_run_lines(test, input_lines)
for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith("\\"):
run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
else:
run_lines.append(l)
if args.verbose:
print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
for l in run_lines:
print(' RUN: ' + l, file=sys.stderr)
run_list = [] run_list = []
for l in run_lines: for l in run_lines:
if '|' not in l: if '|' not in l:
common.warn('Skipping unparseable RUN line: ' + l) common.warn('Skipping unparseable RUN line: ' + l)
continue continue
commands = [cmd.strip() for cmd in l.split('|', 1)] commands = [cmd.strip() for cmd in l.split('|', 1)]
llc_cmd = commands[0] llc_cmd = commands[0]
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for test in test_paths:
autogenerated_note = (comment_sym + ADVERT + 'utils/' + script_name) autogenerated_note = (comment_sym + ADVERT + 'utils/' + script_name)
func_dict = {} func_dict = {}
for p in run_list: for p in run_list:
prefixes = p[0] prefixes = p[0]
for prefix in prefixes: for prefix in prefixes:
func_dict.update({prefix: dict()}) func_dict.update({prefix: dict()})
for prefixes, llc_args, triple_in_cmd, march_in_cmd in run_list: for prefixes, llc_args, triple_in_cmd, march_in_cmd in run_list:
if args.verbose: common.debug('Extracted LLC cmd:', llc_tool, llc_args)
print('Extracted LLC cmd: ' + llc_tool + ' ' + llc_args, file=sys.stderr) common.debug('Extracted FileCheck prefixes:', str(prefixes))
print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
raw_tool_output = common.invoke_tool(args.llc_binary, llc_args, test) raw_tool_output = common.invoke_tool(args.llc_binary, llc_args, test)
triple = triple_in_cmd or triple_in_ir triple = triple_in_cmd or triple_in_ir
if not triple: if not triple:
triple = asm.get_triple_from_march(march_in_cmd) triple = asm.get_triple_from_march(march_in_cmd)
asm.build_function_body_dictionary_for_triple(args, raw_tool_output, asm.build_function_body_dictionary_for_triple(args, raw_tool_output,
triple, prefixes, func_dict) triple, prefixes, func_dict)
is_in_function = False is_in_function = False
is_in_function_start = False is_in_function_start = False
func_name = None func_name = None
prefix_set = set([prefix for p in run_list for prefix in p[0]]) prefix_set = set([prefix for p in run_list for prefix in p[0]])
if args.verbose: common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
output_lines = [] output_lines = []
output_lines.append(autogenerated_note) output_lines.append(autogenerated_note)
for input_line in input_lines: for input_line in input_lines:
if is_in_function_start: if is_in_function_start:
if input_line == '': if input_line == '':
continue continue
if input_line.lstrip().startswith(';'): if input_line.lstrip().startswith(';'):
Show All 27 Lines for input_line in input_lines:
if not m: if not m:
continue continue
func_name = m.group(1) func_name = m.group(1)
if args.function is not None and func_name != args.function: if args.function is not None and func_name != args.function:
# When filtering on a specific function, skip all others. # When filtering on a specific function, skip all others.
continue continue
is_in_function = is_in_function_start = True is_in_function = is_in_function_start = True
if args.verbose: common.debug('Writing %d lines to %s...' % (len(output_lines), test))
print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
with open(test, 'wb') as f: with open(test, 'wb') as f:
f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines]) f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
if __name__ == '__main__': if __name__ == '__main__':
main() main()

llvm/utils/update_mca_test_checks.py

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines if not args.llvm_mca_binary:
raise Error('--llvm-mca-binary value cannot be empty string') raise Error('--llvm-mca-binary value cannot be empty string')
if 'llvm-mca' not in os.path.basename(args.llvm_mca_binary): if 'llvm-mca' not in os.path.basename(args.llvm_mca_binary):
_warn('unexpected binary name: {}'.format(args.llvm_mca_binary)) _warn('unexpected binary name: {}'.format(args.llvm_mca_binary))
return args return args
def _find_run_lines(input_lines, args):
raw_lines = [m.group(1)
for m in [common.RUN_LINE_RE.match(l) for l in input_lines]
if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith(r'\\'):
run_lines[-1] = run_lines[-1].rstrip('\\') + ' ' + l
else:
run_lines.append(l)
if args.verbose:
sys.stderr.write('Found {} RUN line{}:\n'.format(
len(run_lines), '' if len(run_lines) == 1 else 's'))
for line in run_lines:
sys.stderr.write(' RUN: {}\n'.format(line))
return run_lines
def _get_run_infos(run_lines, args): def _get_run_infos(run_lines, args):
run_infos = [] run_infos = []
for run_line in run_lines: for run_line in run_lines:
try: try:
(tool_cmd, filecheck_cmd) = tuple([cmd.strip() (tool_cmd, filecheck_cmd) = tuple([cmd.strip()
for cmd in run_line.split('|', 1)]) for cmd in run_line.split('|', 1)])
except ValueError: except ValueError:
_warn('could not split tool and filecheck commands: {}'.format(run_line)) _warn('could not split tool and filecheck commands: {}'.format(run_line))
▲ Show 20 Lines • Show All 425 Lines • ▼ Show 20 Linesdef _write_output(test_path, input_lines, prefix_list, block_infos, # noqa
while len(output_lines) > 0 and output_lines[-1] == '': while len(output_lines) > 0 and output_lines[-1] == '':
output_lines.pop() output_lines.pop()
if input_lines == output_lines: if input_lines == output_lines:
sys.stderr.write(' [unchanged]\n') sys.stderr.write(' [unchanged]\n')
return return
sys.stderr.write(' [{} lines total]\n'.format(len(output_lines))) sys.stderr.write(' [{} lines total]\n'.format(len(output_lines)))
if args.verbose: common.debug('Writing', len(output_lines), 'lines to', test_path, '..\n\n')
sys.stderr.write(
'Writing {} lines to {}...\n\n'.format(len(output_lines), test_path))
with open(test_path, 'wb') as f: with open(test_path, 'wb') as f:
f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines]) f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
def main(): def main():
args = _parse_args() args = _parse_args()
test_paths = [test for pattern in args.tests for test in glob.glob(pattern)] test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
for test_path in test_paths: for test_path in test_paths:
sys.stderr.write('Test: {}\n'.format(test_path)) sys.stderr.write('Test: {}\n'.format(test_path))
# Call this per test. By default each warning will only be written once # 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 # per source location. Reset the warning filter so that now each warning
# will be written once per source location per test. # will be written once per source location per test.
_configure_warnings(args) _configure_warnings(args)
if args.verbose:
sys.stderr.write(
'Scanning for RUN lines in test file: {}\n'.format(test_path))
if not os.path.isfile(test_path): if not os.path.isfile(test_path):
raise Error('could not find test file: {}'.format(test_path)) raise Error('could not find test file: {}'.format(test_path))
with open(test_path) as f: with open(test_path) as f:
input_lines = [l.rstrip() for l in f] input_lines = [l.rstrip() for l in f]
run_lines = _find_run_lines(input_lines, args) run_lines = common.find_run_lines(test_path, input_lines)
run_infos = _get_run_infos(run_lines, args) run_infos = _get_run_infos(run_lines, args)
common_prefix, prefix_pad = _get_useful_prefix_info(run_infos) common_prefix, prefix_pad = _get_useful_prefix_info(run_infos)
block_infos = _get_block_infos(run_infos, test_path, args, common_prefix) block_infos = _get_block_infos(run_infos, test_path, args, common_prefix)
_write_output(test_path, _write_output(test_path,
input_lines, input_lines,
run_infos, run_infos,
block_infos, block_infos,
args, args,
Show All 13 Lines

llvm/utils/update_mir_test_checks.py

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
def find_triple_in_ir(lines, verbose=False): def find_triple_in_ir(lines, verbose=False):
for l in lines: for l in lines:
m = common.TRIPLE_IR_RE.match(l) m = common.TRIPLE_IR_RE.match(l)
if m: if m:
return m.group(1) return m.group(1)
return None return None
def find_run_lines(test, lines, verbose=False):
raw_lines = [m.group(1)
for m in [common.RUN_LINE_RE.match(l) for l in lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith("\\"):
run_lines[-1] = run_lines[-1].rstrip("\\") + " " + l
else:
run_lines.append(l)
if verbose:
log('Found {} RUN lines:'.format(len(run_lines)))
for l in run_lines:
log(' RUN: {}'.format(l))
return run_lines
def build_run_list(test, run_lines, verbose=False): def build_run_list(test, run_lines, verbose=False):
run_list = [] run_list = []
all_prefixes = [] all_prefixes = []
for l in run_lines: for l in run_lines:
if '|' not in l: if '|' not in l:
common.warn('Skipping unparseable RUN line: ' + l) common.warn('Skipping unparseable RUN line: ' + l)
continue continue
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Linesdef should_add_line_to_output(input_line, prefix_set):
# Skip any check lines that we're handling. # Skip any check lines that we're handling.
m = common.CHECK_RE.match(input_line) m = common.CHECK_RE.match(input_line)
if m and m.group(1) in prefix_set: if m and m.group(1) in prefix_set:
return False return False
return True return True
def update_test_file(args, test): def update_test_file(args, test):
log('Scanning for RUN lines in test file: {}'.format(test), args.verbose)
with open(test) as fd: with open(test) as fd:
input_lines = [l.rstrip() for l in fd] input_lines = [l.rstrip() for l in fd]
script_name = os.path.basename(__file__) script_name = os.path.basename(__file__)
first_line = input_lines[0] if input_lines else "" first_line = input_lines[0] if input_lines else ""
if 'autogenerated' in first_line and script_name not in first_line: if 'autogenerated' in first_line and script_name not in first_line:
common.warn("Skipping test which wasn't autogenerated by " + common.warn("Skipping test which wasn't autogenerated by " +
script_name + ": " + test) script_name + ": " + test)
return return
if args.update_only: if args.update_only:
if not first_line or 'autogenerated' not in first_line: if not first_line or 'autogenerated' not in first_line:
common.warn("Skipping test which isn't autogenerated: " + test) common.warn("Skipping test which isn't autogenerated: " + test)
return return
triple_in_ir = find_triple_in_ir(input_lines, args.verbose) triple_in_ir = find_triple_in_ir(input_lines, args.verbose)
run_lines = find_run_lines(test, input_lines, args.verbose) run_lines = common.find_run_lines(test, input_lines)
run_list, common_prefixes = build_run_list(test, run_lines, args.verbose) run_list, common_prefixes = build_run_list(test, run_lines, args.verbose)
simple_functions = find_functions_with_one_bb(input_lines, args.verbose) simple_functions = find_functions_with_one_bb(input_lines, args.verbose)
func_dict = {} func_dict = {}
for run in run_list: for run in run_list:
for prefix in run.prefixes: for prefix in run.prefixes:
func_dict.update({prefix: dict()}) func_dict.update({prefix: dict()})
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/utils/update_test_checks.py

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesdef main():
for test in args.tests: for test in args.tests:
if not glob.glob(test): if not glob.glob(test):
common.warn("Test file pattern '%s' was not found. Ignoring it." % (test,)) common.warn("Test file pattern '%s' was not found. Ignoring it." % (test,))
continue continue
# On Windows we must expand the patterns ourselves. # On Windows we must expand the patterns ourselves.
test_paths = [test for pattern in args.tests for test in glob.glob(pattern)] test_paths = [test for pattern in args.tests for test in glob.glob(pattern)]
for test in test_paths: for test in test_paths:
if args.verbose:
print('Scanning for RUN lines in test file: ' + test, file=sys.stderr)
with open(test) as f: with open(test) as f:
input_lines = [l.rstrip() for l in f] input_lines = [l.rstrip() for l in f]
first_line = input_lines[0] if input_lines else "" first_line = input_lines[0] if input_lines else ""
if 'autogenerated' in first_line and script_name not in first_line: if 'autogenerated' in first_line and script_name not in first_line:
common.warn("Skipping test which wasn't autogenerated by " + script_name, test) common.warn("Skipping test which wasn't autogenerated by " + script_name, test)
continue continue
if args.update_only: if args.update_only:
if not first_line or 'autogenerated' not in first_line: if not first_line or 'autogenerated' not in first_line:
common.warn("Skipping test which isn't autogenerated: " + test) common.warn("Skipping test which isn't autogenerated: " + test)
continue continue
raw_lines = [m.group(1) run_lines = common.find_run_lines(test, input_lines)
for m in [common.RUN_LINE_RE.match(l) for l in input_lines] if m]
run_lines = [raw_lines[0]] if len(raw_lines) > 0 else []
for l in raw_lines[1:]:
if run_lines[-1].endswith('\\'):
run_lines[-1] = run_lines[-1].rstrip('\\') + ' ' + l
else:
run_lines.append(l)
if args.verbose:
print('Found %d RUN lines:' % (len(run_lines),), file=sys.stderr)
for l in run_lines:
print(' RUN: ' + l, file=sys.stderr)
prefix_list = [] prefix_list = []
for l in run_lines: for l in run_lines:
if '|' not in l: if '|' not in l:
common.warn('Skipping unparseable RUN line: ' + l) common.warn('Skipping unparseable RUN line: ' + l)
continue continue
(tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)]) (tool_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)])
common.verify_filecheck_prefixes(filecheck_cmd) common.verify_filecheck_prefixes(filecheck_cmd)
Show All 17 Lines for l in run_lines:
# now, we just ignore all but the last. # now, we just ignore all but the last.
prefix_list.append((check_prefixes, tool_cmd_args)) prefix_list.append((check_prefixes, tool_cmd_args))
func_dict = {} func_dict = {}
for prefixes, _ in prefix_list: for prefixes, _ in prefix_list:
for prefix in prefixes: for prefix in prefixes:
func_dict.update({prefix: dict()}) func_dict.update({prefix: dict()})
for prefixes, opt_args in prefix_list: for prefixes, opt_args in prefix_list:
if args.verbose: common.debug('Extracted opt cmd: ' + opt_basename + ' ' + opt_args)
print('Extracted opt cmd: ' + opt_basename + ' ' + opt_args, file=sys.stderr) common.debug('Extracted FileCheck prefixes: ' + str(prefixes))
print('Extracted FileCheck prefixes: ' + str(prefixes), file=sys.stderr)
raw_tool_output = common.invoke_tool(args.opt_binary, opt_args, test) raw_tool_output = common.invoke_tool(args.opt_binary, opt_args, test)
common.build_function_body_dictionary( common.build_function_body_dictionary(
common.OPT_FUNCTION_RE, common.scrub_body, [], common.OPT_FUNCTION_RE, common.scrub_body, [],
raw_tool_output, prefixes, func_dict, args.verbose, raw_tool_output, prefixes, func_dict, args.verbose,
args.function_signature) args.function_signature)
is_in_function = False is_in_function = False
is_in_function_start = False is_in_function_start = False
prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes]) prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
if args.verbose: common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
print('Rewriting FileCheck prefixes: %s' % (prefix_set,), file=sys.stderr)
output_lines = [] output_lines = []
output_lines.append(autogenerated_note) output_lines.append(autogenerated_note)
for input_line in input_lines: for input_line in input_lines:
if is_in_function_start: if is_in_function_start:
if input_line == '': if input_line == '':
continue continue
if input_line.lstrip().startswith(';'): if input_line.lstrip().startswith(';'):
Show All 30 Lines for input_line in input_lines:
if not m: if not m:
continue continue
func_name = m.group(1) func_name = m.group(1)
if args.function is not None and func_name != args.function: if args.function is not None and func_name != args.function:
# When filtering on a specific function, skip all others. # When filtering on a specific function, skip all others.
continue continue
is_in_function = is_in_function_start = True is_in_function = is_in_function_start = True
if args.verbose: common.debug('Writing %d lines to %s...' % (len(output_lines), test))
print('Writing %d lines to %s...' % (len(output_lines), test), file=sys.stderr)
with open(test, 'wb') as f: with open(test, 'wb') as f:
f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines]) f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
if __name__ == '__main__': if __name__ == '__main__':
main() main()