Add a scons pnacl finalize step for pnacl_generate_pexe tests.

SConstruct

 #! -*- 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.
 
 import atexit
 import os
 import platform
 import re
 import subprocess
@@ skipping 334 matching lines @@
   BitFromArgument(env, 'x86_64_zero_based_sandbox', default=False,
     desc='Use the zero-address-based x86-64 sandbox model instead of '
       'the r15-based model.')
 
   BitFromArgument(env, 'android', default=False,
                   desc='Build for Android target')
 
   BitFromArgument(env, 'arm_hard_float', default=False,
                   desc='Build for hard float ARM ABI')
 
+  BitFromArgument(env, 'skip_nonstable_bitcode', default=False,
+                  desc='Skip tests involving non-stable bitcode')
+
   #########################################################################
   # EXPERIMENTAL
   # This is for generating a testing library for use within private test
   # enuminsts, where we want to compare and test different validators.
   #
   BitFromArgument(env, 'ncval_testing', default=False,
     desc='EXPERIMENTAL: Compile validator code for testing within enuminsts')
 
   # PNaCl sanity checks
   if ((env.Bit('pnacl_generate_pexe') or env.Bit('use_sandboxed_translator'))
@@ skipping 859 matching lines @@
 
 def HasSuffix(item, suffix):
   if isinstance(item, str):
     return item.endswith(suffix)
   elif hasattr(item, '__getitem__'):
     return HasSuffix(item[0], suffix)
   else:
     return item.path.endswith(suffix)
 
 
+def StripSuffix(string, suffix):
+  assert string.endswith(suffix)
+  return string[:-len(suffix)]
+
+
 def DualLibrary(env, lib_name, *args, **kwargs):
   """Builder to build both .a and _shared.a library in one step.
 
   Args:
     env: Environment in which we were called.
     lib_name: Library name.
     args: Positional arguments.
     kwargs: Keyword arguments.
   """
   static_objs = [i for i in Flatten(args[0]) if not HasSuffix(i, '.os')]
@@ skipping 309 matching lines @@
 def ShouldUseVerboseOptions(env, extra):
   """ Heuristic for setting up Verbose NACLLOG options. """
   return ('process_output_single' in extra or
           'log_golden' in extra)
 
 pre_base_env.AddMethod(ShouldUseVerboseOptions)
 
 
 DeclareBit('tests_use_irt', 'Non-browser tests also load the IRT image', False)
 
-# Translate the given pexe.
-def GetTranslatedNexe(env, pexe):
+# Bit to be set by individual test/nacl.scons files that need to opt out.
+DeclareBit('nonstable_bitcode', 'Tests use non-stable bitcode features', False)
+
+
+def GetFinalizedPexe(env, pexe):
+  """ Prep and finalize the ABI for a given pexe if needed.
+  """
+  if not env.Bit('pnacl_generate_pexe') or env.Bit('nonstable_bitcode'):
+    return pexe
+
+  # We can remove this once we move all CommandSelLdrTestNacl to a nacl.scons
+  # file instead.  There are currently some canned nexe tests in build.scons.
+  if env['NACL_BUILD_FAMILY'] == 'TRUSTED':
+    return pexe
+
+  # Otherwise, finalize during the build step, since there is no finalize tool
+  # that can run on triggered bots such as the ARM HW bots.
   pexe_name = pexe.abspath
-  nexe_name = pexe_name[:pexe_name.index('.pexe')] + '.nexe'
+  final_name = StripSuffix(pexe_name, '.nonfinal.pexe') + '.final.pexe'
   # Make sure the pexe doesn't get removed by the fake builders when
   # built_elsewhere=1
   env.Precious(pexe)
-  node = env.Command(target=nexe_name, source=[pexe_name],
-                     action=[Action('${TRANSLATECOM}', '${TRANSLATECOMSTR}')])
+  node = env.Command(target=final_name, source=[pexe_name],
+                     action=[Action('${PNACLFINALIZECOM}',
+                                    '${PNACLFINALIZECOMSTR}')])
   assert len(node) == 1, node
   return node[0]
 
-pre_base_env.AddMethod(GetTranslatedNexe)
 
+# Translate the given pexe.
+def GetTranslatedNexe(env, pexe):
+  # First finalize the pexe.
+  pexe = GetFinalizedPexe(env, pexe)
 
-def ShouldTranslateToNexe(env, pexe):
-  """ Determine when we need to translate a Pexe to a Nexe.
-  """
+  # Then check if we need to translate.
   # Check if we started with a pexe, so there is actually a translation step.
   if not env.Bit('pnacl_generate_pexe'):
-    return False
+    return pexe
 
-  # There is no bitcode for trusted code.
+  # We can remove this once we move all CommandSelLdrTestNacl to a nacl.scons
+  # file instead.  There are currently some canned nexe tests in build.scons.
   if env['NACL_BUILD_FAMILY'] == 'TRUSTED':
-    return False
+    return pexe
 
   # Often there is a build step (do_not_run_tests=1) and a test step
   # (which is run with -j1). Normally we want to translate in the build step
   # so we can translate in parallel. However when we do sandboxed translation
   # on arm hw, we do the build step on x86 and translation on arm, so we have
   # to force the translation to be done in the test step. Hence,
   # we check the bit 'translate_in_build_step' / check if we are
   # in the test step.
-  return (
-    env.Bit('translate_in_build_step') or not env.Bit('do_not_run_tests'))
+  if not env.Bit('translate_in_build_step') and env.Bit('do_not_run_tests'):
+    return pexe
 
-pre_base_env.AddMethod(ShouldTranslateToNexe)
+  pexe_name = pexe.abspath
+  # Tidy up the suffix (remove the .final.pexe or .nonfinal.pexe),
+  # depending on whether or not the pexe was finalized.
+  suffix_to_strip = '.final.pexe'
+  if not pexe_name.endswith(suffix_to_strip):
+    suffix_to_strip = '.nonfinal.pexe'
+  nexe_name = StripSuffix(pexe_name, suffix_to_strip) + '.nexe'
+  # Make sure the pexe doesn't get removed by the fake builders when
+  # built_elsewhere=1
+  env.Precious(pexe)
+  node = env.Command(target=nexe_name, source=[pexe_name],
+                     action=[Action('${TRANSLATECOM}', '${TRANSLATECOMSTR}')])
+  assert len(node) == 1, node
+  return node[0]
+
+pre_base_env.AddMethod(GetTranslatedNexe)
 
 
 def CommandTestFileDumpCheck(env,
                              name,
                              target,
                              check_file,
                              objdump_flags):
   """Create a test that disassembles a binary (|target|) and checks for
   patterns in the |check_file|.  Disassembly is done using |objdump_flags|.
   """
 
   # Do not try to run OBJDUMP if 'built_elsewhere', since that *might* mean
   # that a toolchain is not even present.  E.g., the arm hw buildbots do
   # not have the pnacl toolchain. We should be able to look for the host
   # ARM objdump though... a TODO(jvoung) for when there is time.
   if env.Bit('built_elsewhere'):
     return []
-  if env.ShouldTranslateToNexe(target):
-    target_obj = env.GetTranslatedNexe(target)
-  else:
-    target_obj = target
+  target = env.GetTranslatedNexe(target)
   return env.CommandTestFileCheck(name,
-                                  ['${OBJDUMP}', objdump_flags, target_obj],
+                                  ['${OBJDUMP}', objdump_flags, target],
                                   check_file)
 
 pre_base_env.AddMethod(CommandTestFileDumpCheck)
 
 
 def CommandTestFileCheck(env, name, cmd, check_file):
   """Create a test that runs a |cmd| (array of strings),
   which is expected to print to stdout.  The results
   of stdout will then be piped to the file_check.py tool which
   will search for the regexes specified in |check_file|. """
@@ skipping 20 matching lines @@
                           # e.g., [ 'python', 'time_check.py', '--' ]
                           **extra):
   # Disable all sel_ldr tests for windows under coverage.
   # Currently several .S files block sel_ldr from being instrumented.
   # See http://code.google.com/p/nativeclient/issues/detail?id=831
   if ('TRUSTED_ENV' in env and
       env['TRUSTED_ENV'].Bit('coverage_enabled') and
       env['TRUSTED_ENV'].Bit('windows')):
     return []
 
-  if env.ShouldTranslateToNexe(nexe):
-    # The nexe is actually a pexe.  Translate it before we run it.
-    nexe = env.GetTranslatedNexe(nexe)
+  # The nexe might be a pexe that needs finalization, and translation.
+  nexe = env.GetTranslatedNexe(nexe)
+
   command = [nexe]
   if args is not None:
     command += args
 
   if loader is None:
     loader = env.GetSelLdr()
     if loader is None:
       print 'WARNING: no sel_ldr found. Skipping test %s' % name
       return []
 
@@ skipping 2108 matching lines @@
   nacl_env.ValidateSdk()
 
 if BROKEN_TEST_COUNT > 0:
   msg = "There are %d broken tests." % BROKEN_TEST_COUNT
   if GetOption('brief_comstr'):
     msg += " Add --verbose to the command line for more information."
   print msg
 
 # separate warnings from actual build output
 Banner('B U I L D - O U T P U T:')