Index: utils/update_test_checks.py =================================================================== --- /dev/null +++ utils/update_test_checks.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python + +"""A test case update script. + +This script is a utility to update LLVM test cases with new FileCheck patterns. +""" + +import argparse +import itertools +import subprocess +import sys +import tempfile +import re + + +def llc(args, cmd_args, ir): + with open(ir) as ir_file: + stdout = subprocess.check_output(args.llc_binary + ' ' + cmd_args, + shell=True, stdin=ir_file) + return stdout + + +ASM_SCRUB_WHITESPACE_RE = re.compile(r'(?!^ \w)[ \t]+', flags=re.M) +ASM_SCRUB_SHUFFLES_RE = ( + re.compile( + r'^(\s*\w+) [^#\n]+#+ ((?:[xyz]mm\d+|mem) = .*)$', + flags=re.M)) +ASM_SCRUB_SP_RE = re.compile(r'\d+$%(esp|rsp)$') + + +def scrub_asm(asm): + asm = asm.replace('\t', ' ') + asm = ASM_SCRUB_WHITESPACE_RE.sub(r' ', asm) + asm = ASM_SCRUB_SHUFFLES_RE.sub(r'\1 {{.*#+}} \2', asm) + asm = ASM_SCRUB_SP_RE.sub(r'{{[0-9]+}}(%\1)', asm) + return asm + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('-v', '--verbose', action='store_true', + help='Show verbose output') + parser.add_argument('--llc-binary', default='llc', + help='The "llc" binary to use to generate the test case') + parser.add_argument( + '--function', help='The function in the test file to update') + parser.add_argument('tests', nargs='+') + args = parser.parse_args() + + run_line_re = re.compile('^\s*;\s*RUN:\s*(.*)$') + ir_function_re = re.compile('^\s*define\s+(?:internal\s+)?[^@]*@(\w+)\s*\(') + asm_function_re = re.compile(r'^\s*\.type\s+(?P\w+),@function.*?' + r'(?P=f):[^:]+?' + r'(?P^# \S+:(?:.*?^\s+ret[lq]\s*)*?)' + r'^\S+:\s*\.size[^\n]*\s*.cfi_endproc', + flags=(re.M | re.S)) + check_prefix_re = re.compile('--check-prefix=(\S+)') + check_re = re.compile(r'^\s*;\s*([^:]+?)(?:-NEXT|-NOT|-DAG|-LABEL)?:') + + for test in args.tests: + if args.verbose: + print >>sys.stderr, 'Scanning for RUN lines in test file: %s' % (test,) + with open(test) as f: + test_lines = [l.rstrip() for l in f] + + run_lines = [m.group(1) + for m in [run_line_re.match(l) for l in test_lines] if m] + if args.verbose: + print >>sys.stderr, 'Found %d RUN lines:' % (len(run_lines),) + for l in run_lines: + print >>sys.stderr, ' RUN: ' + l + + checks = [] + for l in run_lines: + (llc_cmd, filecheck_cmd) = tuple([cmd.strip() for cmd in l.split('|', 1)]) + if not llc_cmd.startswith('llc '): + print >>sys.stderr, 'WARNING: Skipping non-llc RUN line: ' + l + continue + + if not filecheck_cmd.startswith('FileCheck '): + print >>sys.stderr, 'WARNING: Skipping non-FileChecked RUN line: ' + l + continue + + llc_cmd_args = llc_cmd[len('llc'):].strip() + llc_cmd_args = llc_cmd_args.replace('< %s', '').replace('%s', '').strip() + if args.verbose: + print >>sys.stderr, 'Extracted LLC cmd: llc ' + llc_cmd_args + + check_prefixes = [m.group(1) + for m in check_prefix_re.finditer(filecheck_cmd)] + if not check_prefixes: + check_prefixes = ['CHECK'] + if args.verbose: + print>>sys.stderr, 'Extracted FileCheck prefixes: %s' % ( + check_prefixes,) + + # FIXME: We should use multiple check prefixes to common check lines. For + # now, we just ignore all but the last. + checks.append((check_prefixes, llc_cmd_args)) + + asm = {} + for prefixes, _ in checks: + for prefix in prefixes: + asm.update({prefix: dict()}) + for prefixes, llc_args in checks: + raw_asm = llc(args, llc_args, test) + # Build up a dictionary of all the function bodies. + for m in asm_function_re.finditer(raw_asm): + if not m: + continue + f = m.group('f') + f_asm = scrub_asm(m.group('body')) + for prefix in prefixes: + if f in asm[prefix]: + if asm[prefix][f] != f_asm: + asm[prefix][f] = None + if prefix == prefixes[-1]: + print >>sys.stderr, ('WARNING: Found conflicting asm under the ' + 'same prefix!') + asm[prefix][f] = f_asm + else: + asm[prefix].update({f: f_asm}) + + is_in_function = False + prefix_set = set([prefix for prefixes, _ in checks for prefix in prefixes]) + if args.verbose: + print >>sys.stderr, 'Rewriting FileCheck prefixes: %s' % (prefix_set,) + fixed_lines = [] + for l in test_lines: + if is_in_function: + if l.strip() == ';': + continue + m = check_re.match(l) + if m: + if m.group(1) in prefix_set: + continue + fixed_lines.append(l) + if l.strip() == '}': + is_in_function = False + continue + + fixed_lines.append(l) + + m = ir_function_re.match(l) + if not m: + continue + name = m.group(1) + if args.function is not None and name != args.function: + # When filtering on a specific function, skip all others. + continue + is_in_function = True + + # Print out the various check lines here + printed_prefixes = [] + for prefixes, _ in checks: + for prefix in prefixes: + if prefix in printed_prefixes: + break + if not asm[prefix][name]: + continue + if len(printed_prefixes) != 0: + fixed_lines.append(';') + printed_prefixes.append(prefix) + fixed_lines.append('; %s-LABEL: %s:' % (prefix, name)) + asm_lines = asm[prefix][name].splitlines() + fixed_lines.append('; %s: %s' % (prefix, asm_lines[0])) + for asm_line in asm_lines[1:]: + fixed_lines.append('; %s-NEXT: %s' % (prefix, asm_line)) + break + + if args.verbose: + print>>sys.stderr, 'Writing %d fixed lines to %s...' % ( + len(fixed_lines), test) + with open(test, 'w') as f: + f.writelines([l + '\n' for l in fixed_lines]) + + +if __name__ == '__main__': + main()