Add test running support for tests generated as pexes.

site_scons/site_tools/naclsdk.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Nacl SDK tool SCons."""
 
 import __builtin__
 import re
 import os
@@ skipping 196 matching lines @@
 def _SetEnvForPnacl(env, root):
   # All the PNaCl tools require Python to be in the PATH.
   # On the Windows bots, however, Python is not installed system-wide.
   # It must be pulled from ../third_party/python_26.
   python_dir = os.path.join('..', 'third_party', 'python_26')
   env.AppendENVPath('PATH', python_dir)
 
   arch = env['TARGET_FULLARCH']
   assert arch in ['arm', 'arm-thumb2', 'x86-32', 'x86-64']
 
+  arch_flag = ' -arch %s' % arch
   if env.Bit('pnacl_stop_with_pexe'):
-    arch_flag = ''
+    ld_arch_flag = ''
   else:
-    arch_flag = ' -arch %s' % arch
+    ld_arch_flag = arch_flag
+

[Mark Seaborn, 2012/03/13 22:16:55]

Style nit: Shouldn't have >1 blank line inside a function

 
   if env.Bit('nacl_glibc'):
     subroot = root + '/glibc'
   else:
     subroot = root + '/newlib'
 
   binprefix = os.path.join(subroot, 'bin', 'pnacl-')
   binext = ''
   if env.Bit('host_windows'):
     binext = '.bat'
@@ skipping 10 matching lines @@
 
   #TODO(robertm): remove NACL_SDK_INCLUDE ASAP
   if env.Bit('nacl_glibc'):
     pnacl_include = os.path.join(root, 'glibc', 'usr', 'include')
   else:
     pnacl_include = os.path.join(root, 'newlib', 'usr', 'include')
   pnacl_ar = binprefix + 'ar' + binext
   pnacl_as = binprefix + 'as' + binext
   pnacl_nm = binprefix + 'nm' + binext
   pnacl_ranlib = binprefix + 'ranlib' + binext
+  pnacl_translate = binprefix + 'translate' + binext
 
   frontend = env['PNACL_FRONTEND']
   if frontend == 'clang':
     pnacl_cc = binprefix + 'clang' + binext
     pnacl_cxx = binprefix + 'clang++' + binext
   elif frontend == 'dragonegg':
     pnacl_cc = binprefix + 'dgcc' + binext
     pnacl_cxx = binprefix + 'dg++' + binext
   else:
     print "Unknown frontend"
     sys.exit(-1)
 
   pnacl_ld = binprefix + 'ld' + binext
   pnacl_nativeld = binprefix + 'nativeld' + binext
   pnacl_disass = binprefix + 'dis' + binext
   pnacl_strip = binprefix + 'strip' + binext
   pnacl_nmf = binprefix + 'nmf' + binext
 
   # NOTE: XXX_flags start with space for easy concatenation
   # The flags generated here get baked into the commands (CC, CXX, LINK)
   # instead of CFLAGS etc to keep them from getting blown away by some
   # tests. Don't add flags here unless they always need to be preserved.
   pnacl_cxx_flags = ''
   pnacl_cc_flags = ' -std=gnu99'
   pnacl_ld_flags = ' ' + ' '.join(env['PNACL_BCLDFLAGS'])
+  pnacl_translate_flags = ''
 
   if env.Bit('nacl_pic'):
     pnacl_cc_flags += ' -fPIC'
     pnacl_cxx_flags += ' -fPIC'
     # NOTE: this is a special hack for the pnacl backend which
     #       does more than linking
     pnacl_ld_flags += ' -fPIC'
+    pnacl_translate_flags += ' -fPIC'
 
   if env.Bit('use_sandboxed_translator'):
-    pnacl_ld_flags += ' --pnacl-sb --pnacl-default-command-line'
+    sb_flags = ' --pnacl-sb --pnacl-default-command-line'
     if env.Bit('sandboxed_translator_is_dynamic'):
-      pnacl_ld_flags += ' --pnacl-sb-dynamic'
+      sb_flags += ' --pnacl-sb-dynamic'
+    pnacl_ld_flags += sb_flags
+    pnacl_translate_flags += sb_flags
 
   if pnacl_extra_lib:
     env.Prepend(LIBPATH=pnacl_extra_lib)
 
   env.Replace(# Replace header and lib paths.
               PNACL_ROOT=root,
               NACL_SDK_INCLUDE=pnacl_include,
               NACL_SDK_LIB=pnacl_lib,
               # Replace the normal unix tools with the PNaCl ones.
               CC=pnacl_cc + pnacl_cc_flags,
               CXX=pnacl_cxx + pnacl_cxx_flags,
               ASPP=pnacl_cc + pnacl_cc_flags,
               LIBPREFIX="lib",
               SHLIBPREFIX="lib",
               SHLIBSUFFIX=".so",
               OBJSUFFIX=".bc",
-              LINK=pnacl_cxx + arch_flag + pnacl_ld_flags,
+              LINK=pnacl_cxx + ld_arch_flag + pnacl_ld_flags,
               # Although we are currently forced to produce native output
               # for LINK, we are free to produce bitcode for SHLINK
               # (SharedLibrary linking) because scons doesn't do anything
               # with shared libraries except use them with the toolchain.
-              SHLINK=pnacl_cxx + arch_flag + pnacl_ld_flags,
+              SHLINK=pnacl_cxx + ld_arch_flag + pnacl_ld_flags,
               LD=pnacl_ld,
               NATIVELD=pnacl_nativeld,
               AR=pnacl_ar,
-              AS=pnacl_as + arch_flag,
+              AS=pnacl_as + ld_arch_flag,
               RANLIB=pnacl_ranlib,
               DISASS=pnacl_disass,
               OBJDUMP=pnacl_disass,
               STRIP=pnacl_strip,
               GENNMF=pnacl_nmf,
+              TRANSLATE=pnacl_translate + arch_flag + pnacl_translate_flags,
               )
 
 
 def _SetEnvForSdkManually(env):
   def GetEnvOrDummy(v):
     return os.getenv('NACL_SDK_' + v, 'MISSING_SDK_' + v)
 
   env.Replace(# Replace header and lib paths.
               NACL_SDK_INCLUDE=GetEnvOrDummy('INCLUDE'),
               NACL_SDK_LIB=GetEnvOrDummy('LIB'),
@@ skipping 272 matching lines @@
   # Dependency files it produces are to be found in ${LIBPATH}.
   # It is applied recursively to those dependencies in case
   # some of them are linker scripts too.
   ldscript_scanner = SCons.Scanner.Base(
       function=ScanLinkerScript,
       skeys=['.a', '.so', '.pso'],
       path_function=SCons.Scanner.FindPathDirs('LIBPATH'),
       recursive=True
       )
   env.Append(SCANNERS=ldscript_scanner)