text: #!/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()
  