Subzero: Add Non-SFI support for x86-32.

pydir/crosstest_generator.py

 #!/usr/bin/env python2
 
 import argparse
 import ConfigParser
 import os
 import shutil
 import sys
 
 from utils import shellcmd
 from utils import FindBaseNaCl
@@ skipping 38 matching lines @@
   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' ]
-  sandboxing = [ 'native', 'sandbox' ]
+  sandboxing = [ 'native', 'sandbox', 'nonsfi' ]
   opt_levels = [ 'Om1', 'O2' ]
   arch_attrs = { 'x8632': [ 'sse2', 'sse4.1' ],
                  'x8664': [ 'sse2', 'sse4.1' ],
                  'arm32': [ 'neon', 'hwdiv-arm' ] }
   flat_attrs = []
   for v in arch_attrs.values():
     flat_attrs += v
   arch_flags = { 'x8632': [],
                  'x8664': [],
                  # ARM doesn't have an ELF writer yet, and iasm does not
@@ skipping 26 matching lines @@
   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',
-                           help='Path to toolchain binaries.')
+                         default=(
+                           '{root}/toolchain/linux_x86/pnacl_newlib_raw/bin'
+                         ).format(root=root),
+                         help='Path to toolchain binaries.')
   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')
 
@@ skipping 32 matching lines @@
                 attr=attr)
               extra = (tests.get(test, 'flags').split(' ')
                        if tests.has_option(test, 'flags') else [])
               # 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-x86-32/obj/src/nonsfi/' +
+                           'loader/nonsfi_loader ').format(root=root) + run_cmd
               else:
                 run_cmd = RunNativePrefix(args.toolchain_root, target, 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 +
                           ' --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()