| #!/usr/bin/env python2 |
| |
| import argparse |
| import collections |
| import ConfigParser |
| import os |
| import shutil |
| import sys |
| |
| from utils import shellcmd |
| from utils import FindBaseNaCl |
| |
| def Match(desc, includes, excludes, default_match): |
| """Determines whether desc is a match against includes and excludes. |
| |
| 'desc' is a set of attributes, and 'includes' and 'excludes' are lists of sets |
| of attributes. |
| |
| If 'desc' matches any element from 'excludes', the result is False. |
| Otherwise, if 'desc' matches any element from 'includes', the result is True. |
| Otherwise, the 'default_match' value is returned. |
| """ |
| for exclude in excludes: |
| if exclude <= desc: |
| return False |
| for include in includes: |
| if include <= desc: |
| return True |
| return default_match |
| |
| |
| def RunNativePrefix(toolchain_root, target, attr, run_cmd): |
| """Returns a prefix for running an executable for the target. |
| |
| For example, we may be running an ARM or MIPS target executable on an |
| x86 machine and need to use an emulator. |
| """ |
| arch_map = { 'x8632' : '', |
| 'x8664' : '', |
| 'arm32' : os.path.join(toolchain_root, 'arm_trusted', |
| 'run_under_qemu_arm'), |
| 'mips32': os.path.join(toolchain_root, 'mips_trusted', |
| 'run_under_qemu_mips32'), |
| } |
| attr_map = collections.defaultdict(str, { |
| 'arm32-neon': ' -cpu cortex-a9', |
| 'arm32-hwdiv-arm': ' -cpu cortex-a15', |
| 'mips32-base': ' -cpu mips32r5-generic'}) |
| prefix = arch_map[target] + attr_map[target + '-' + attr] |
| if target == 'mips32': |
| prefix = 'QEMU_SET_ENV=LD_LIBRARY_PATH=/usr/mipsel-linux-gnu/lib/ ' + prefix |
| return (prefix + ' ' + run_cmd) if prefix else run_cmd |
| |
| def NonsfiLoaderArch(target): |
| """Returns the arch for the nonsfi_loader""" |
| arch_map = { 'arm32' : 'arm', |
| 'x8632' : 'x86-32', |
| 'mips32' : 'mips32', |
| } |
| return arch_map[target] |
| |
| |
| def main(): |
| """Framework for cross test generation and execution. |
| |
| Builds and executes cross tests from the space of all possible attribute |
| combinations. The space can be restricted by providing subsets of attributes |
| to specifically include or exclude. |
| """ |
| # pypath is where to find other Subzero python scripts. |
| pypath = os.path.abspath(os.path.dirname(sys.argv[0])) |
| root = FindBaseNaCl() |
| |
| # The rest of the attribute sets. |
| targets = [ 'x8632', 'x8664', 'arm32', 'mips32' ] |
| sandboxing = [ 'native', 'sandbox', 'nonsfi' ] |
| opt_levels = [ 'Om1', 'O2' ] |
| arch_attrs = { 'x8632': [ 'sse2', 'sse4.1' ], |
| 'x8664': [ 'sse2', 'sse4.1' ], |
| 'arm32': [ 'neon', 'hwdiv-arm' ], |
| 'mips32': [ 'base' ] |
| } |
| flat_attrs = [] |
| for v in arch_attrs.values(): |
| flat_attrs += v |
| arch_flags = { 'x8632': [], |
| 'x8664': [], |
| 'arm32': [], |
| 'mips32': [] |
| } |
| # all_keys is only used in the help text. |
| all_keys = '; '.join([' '.join(targets), ' '.join(sandboxing), |
| ' '.join(opt_levels), ' '.join(flat_attrs)]) |
| |
| argparser = argparse.ArgumentParser( |
| description=' ' + main.__doc__ + |
| 'The set of attributes is the set of tests plus the following:\n' + |
| all_keys, formatter_class=argparse.RawTextHelpFormatter) |
| argparser.add_argument('--config', default='crosstest.cfg', dest='config', |
| metavar='FILE', help='Test configuration file') |
| argparser.add_argument('--print-tests', default=False, action='store_true', |
| help='Print the set of test names and exit') |
| argparser.add_argument('--include', '-i', default=[], dest='include', |
| action='append', metavar='ATTR_LIST', |
| help='Attributes to include (comma-separated). ' + |
| 'Can be used multiple times.') |
| argparser.add_argument('--exclude', '-e', default=[], dest='exclude', |
| action='append', metavar='ATTR_LIST', |
| help='Attributes to include (comma-separated). ' + |
| 'Can be used multiple times.') |
| argparser.add_argument('--verbose', '-v', default=False, action='store_true', |
| help='Use verbose output') |
| argparser.add_argument('--defer', default=False, action='store_true', |
| help='Defer execution until all executables are built') |
| argparser.add_argument('--no-compile', '-n', default=False, |
| action='store_true', |
| help="Don't build; reuse binaries from the last run") |
| argparser.add_argument('--dir', dest='dir', metavar='DIRECTORY', |
| default=('{root}/toolchain_build/src/subzero/' + |
| 'crosstest/Output').format(root=root), |
| help='Output directory') |
| argparser.add_argument('--lit', default=False, action='store_true', |
| help='Generate files for lit testing') |
| argparser.add_argument('--toolchain-root', dest='toolchain_root', |
| default=( |
| '{root}/toolchain/linux_x86/pnacl_newlib_raw/bin' |
| ).format(root=root), |
| help='Path to toolchain binaries.') |
| argparser.add_argument('--filetype', default=None, dest='filetype', |
| help='File type override, one of {asm, iasm, obj}.') |
| args = argparser.parse_args() |
| |
| # Run from the crosstest directory to make it easy to grab inputs. |
| crosstest_dir = '{root}/toolchain_build/src/subzero/crosstest'.format( |
| root=root) |
| os.chdir(crosstest_dir) |
| |
| tests = ConfigParser.RawConfigParser() |
| tests.read('crosstest.cfg') |
| |
| if args.print_tests: |
| print 'Test name attributes: ' + ' '.join(sorted(tests.sections())) |
| sys.exit(0) |
| |
| # includes and excludes are both lists of sets. |
| includes = [ set(item.split(',')) for item in args.include ] |
| excludes = [ set(item.split(',')) for item in args.exclude ] |
| # If any --include args are provided, the default is to not match. |
| default_match = not args.include |
| |
| # Delete and recreate the output directory, unless --no-compile was specified. |
| if not args.no_compile: |
| if os.path.exists(args.dir): |
| if os.path.isdir(args.dir): |
| shutil.rmtree(args.dir) |
| else: |
| os.remove(args.dir) |
| if not os.path.exists(args.dir): |
| os.makedirs(args.dir) |
| |
| # If --defer is specified, collect the run commands into deferred_cmds for |
| # later execution. |
| deferred_cmds = [] |
| for test in sorted(tests.sections()): |
| for target in targets: |
| for sb in sandboxing: |
| for opt in opt_levels: |
| for attr in arch_attrs[target]: |
| desc = [ test, target, sb, opt, attr ] |
| if Match(set(desc), includes, excludes, default_match): |
| exe = '{test}_{target}_{sb}_{opt}_{attr}'.format( |
| test=test, target=target, sb=sb, opt=opt, |
| attr=attr) |
| extra = (tests.get(test, 'flags').split(' ') |
| if tests.has_option(test, 'flags') else []) |
| if args.filetype: |
| extra += ['--filetype={ftype}'.format(ftype=args.filetype)] |
| # Generate the compile command. |
| cmp_cmd = ( |
| ['{path}/crosstest.py'.format(path=pypath), |
| '-{opt}'.format(opt=opt), |
| '--mattr={attr}'.format(attr=attr), |
| '--prefix=Subzero_', |
| '--target={target}'.format(target=target), |
| '--nonsfi={nsfi}'.format(nsfi='1' if sb=='nonsfi' else '0'), |
| '--sandbox={sb}'.format(sb='1' if sb=='sandbox' else '0'), |
| '--dir={dir}'.format(dir=args.dir), |
| '--output={exe}'.format(exe=exe), |
| '--driver={drv}'.format(drv=tests.get(test, 'driver'))] + |
| extra + |
| ['--test=' + t |
| for t in tests.get(test, 'test').split(' ')] + |
| arch_flags[target]) |
| run_cmd_base = os.path.join(args.dir, exe) |
| # Generate the run command. |
| run_cmd = run_cmd_base |
| if sb == 'sandbox': |
| run_cmd = '{root}/run.py -q '.format(root=root) + run_cmd |
| elif sb == 'nonsfi': |
| run_cmd = ( |
| '{root}/scons-out/opt-linux-{arch}/obj/src/nonsfi/' + |
| 'loader/nonsfi_loader ').format( |
| root=root, arch=NonsfiLoaderArch(target)) + run_cmd |
| run_cmd = RunNativePrefix(args.toolchain_root, target, attr, |
| run_cmd) |
| else: |
| run_cmd = RunNativePrefix(args.toolchain_root, target, attr, |
| run_cmd) |
| if args.lit: |
| # Create a file to drive the lit test. |
| with open(run_cmd_base + '.xtest', 'w') as f: |
| f.write('# RUN: sh %s | FileCheck %s\n') |
| f.write('cd ' + crosstest_dir + ' && \\\n') |
| f.write(' '.join(cmp_cmd) + ' && \\\n') |
| f.write(run_cmd + '\n') |
| f.write('echo Recreate a failure using ' + __file__ + |
| ' --toolchain-root=' + args.toolchain_root + |
| (' --filetype=' + args.filetype |
| if args.filetype else '') + |
| ' --include=' + ','.join(desc) + '\n') |
| f.write('# CHECK: Failures=0\n') |
| else: |
| if not args.no_compile: |
| shellcmd(cmp_cmd, |
| echo=args.verbose) |
| if (args.defer): |
| deferred_cmds.append(run_cmd) |
| else: |
| shellcmd(run_cmd, echo=True) |
| for run_cmd in deferred_cmds: |
| shellcmd(run_cmd, echo=True) |
| |
| if __name__ == '__main__': |
| main() |
