Remove canned hello_world binary

src/trusted/service_runtime/build.scons

 # -*- 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 platform
 import os
 
 Import('env')
 
@@ skipping 536 matching lines @@
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_format_string_test')
 
 
 if env.Bit('target_x86_32'):
   arch_testdata_dir = 'testdata/x86_32'
 elif env.Bit('target_x86_64'):
   arch_testdata_dir = 'testdata/x86_64'
 else:
   arch_testdata_dir = 'testdata/' + env['TARGET_ARCHITECTURE']
 
+if not env.Bit('bitcode') or env.Bit('target_mips32'):

[Mark Seaborn, 2013/10/15 23:38:45]

Why would this work for env.Bit('target_mips32') but not for env.Bit('bitcode')
in general?  Can't this be enabled even if 'bitcode' is true?

It might be that you want to check "pnacl_generate_pexe" rather than "bitcode"
here.  Or maybe you just need to apply env.GetTranslatedNexe() so that this
works even for pnacl_generate_pexe=1.

[petarj, 2013/10/16 00:24:37]

This is a workaround to the issue with NO-NATIVE-CC-INVOCATION-ALLOWED
that comes out with call to MakeUntrustedNativeEnv().

+  untrusted_env = env.MakeUntrustedNativeEnv()
+  hello_world_src = env.File('${MAIN_DIR}/tests/hello_world/hello_world.c')
+  hello_world_obj = untrusted_env.ComponentObject('hello_world',
+                                                  hello_world_src)
+  hello_world_nexe = untrusted_env.ComponentProgram(

[Mark Seaborn, 2013/10/15 23:38:45]

Can you do:
untrusted_env.File('$STAGING_DIR/hello_world$PROGSUFFIX')
so that hello_world.nexe isn't rebuilt here?

[petarj, 2013/10/16 23:36:08]

Done.

+      'hello_world',
+      hello_world_obj,
+      EXTRA_LIBS=['${NONIRT_LIBS}'])
 
 # Doesn't work on windows under coverage.
 # TODO(bradnelson): fix this to work on windows under coverage.
-if not env.Bit('windows') or not env.Bit('coverage_enabled'):
+if ((not env.Bit('windows') or not env.Bit('coverage_enabled')) and
+    (not env.Bit('bitcode') or env.Bit('target_mips32'))):
   # NOTE: uses validator
   mmap_test_objs = [env.ComponentObject('mmap_test.c')]
   mmap_test_exe = env.ComponentProgram(
       'mmap_test',
       mmap_test_objs,
       EXTRA_LIBS=['sel',
                   'env_cleanser',
                   'manifest_proxy',
                   'simple_service',
                   'thread_interface',
                   'gio_wrapped_desc',
                   'nonnacl_srpc',
                   'nrd_xfer',
                   'nacl_perf_counter',
                   'nacl_base',
                   'imc',
                   'nacl_fault_inject',
                   'nacl_interval',
                   'platform',
                   'sel_test',
                   ])
 
-  mmap_test_file = env.File(arch_testdata_dir + '/hello_world.nexe')
-  mmap_test_command = env.AddBootstrap(mmap_test_exe, [mmap_test_file])
+  if env.Bit('nacl_glibc'):
+    mmap_test_args = ['%s/runnable-ld.so' % (untrusted_env['NACL_SDK_LIB'])]
+    mmap_test_args = mmap_test_args + [hello_world_nexe]

[Mark Seaborn, 2013/10/15 23:38:45]

This is kind of misleading: since this test wouldn't be running ld.so, it
wouldn't load hello_world, so the hello_world argument is immaterial.  Maybe
remove the hello_world argument or just disable this test for
env.Bit('nacl_glibc').

[petarj, 2013/10/16 23:36:08]

Done.

+  else:
+    mmap_test_args = [hello_world_nexe]
+
+  mmap_test_command = env.AddBootstrap(mmap_test_exe, mmap_test_args)
 
   # TODO(robertm): This test emits lots of messages to stderr
   node = env.CommandTest (
       "mmap_test.out",
       command=mmap_test_command,
       # TODO(mseaborn): Extend this test to cover the case where the
       # dynamic code segment is present.
       osenv='NACL_DISABLE_DYNAMIC_LOADING=1')
   env.AddNodeToTestSuite(node, ['medium_tests'], 'run_trusted_mmap_test')
 
@@ skipping 199 matching lines @@
 # Test that sel_ldr does not crash if the executable file cannot be opened.
 node = env.CommandSelLdrTestNacl(
     'sel_ldr_exe_not_found.out',
     'name_of_file_that_does_not_exist.nexe',
     exit_status='1')
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_sel_ldr_exe_not_found_test')
 
 # Check that "-F" makes sel_ldr stop after loading the nexe but before running
 # it.
 if not env.Bit('bitcode') or env.Bit('target_mips32'):
-  untrusted_env = env.MakeUntrustedNativeEnv()
   nullptr_src = env.File('${MAIN_DIR}/tests/nullptr/nullptr.c')
   nullptr_obj = untrusted_env.ComponentObject('nullptr', nullptr_src)
   nullptr_nexe = untrusted_env.ComponentProgram('nullptr', nullptr_obj)
 
   node = env.CommandSelLdrTestNacl(
       'fuzz_nullptr_test.out',
       nullptr_nexe,
       sel_ldr_flags=['-F'])
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_fuzz_nullptr_test')
 
-# ----------------------------------------------------------
-# Small tests with canned binaries
-# ----------------------------------------------------------
-
-if env.Bit('target_x86_64'):
-  node = env.CommandSelLdrTestNacl(
-      'hello_x32.out',
-      env.File(os.path.join(arch_testdata_dir, 'hello_x32.nexe')),
-      stdout_golden=env.File(os.path.join('${MAIN_DIR}',
-                                          'tests/hello_world',
-                                          'hello_world.stdout'))
-      )
-  env.AddNodeToTestSuite(node, ['small_tests'], 'run_hello_x32_test')
-
-# Test canned hello_world binary with obsolete, non-ragel based validator.
-if not env.Bit('validator_ragel') and env.Bit('target_x86'):
-  node = env.CommandSelLdrTestNacl(
+# Test hello_world binary with obsolete, non-ragel based validator.
+if (not env.Bit('validator_ragel') and env.Bit('target_x86') and
+    not env.Bit('bitcode')):
+  node = untrusted_env.CommandSelLdrTestNacl(
       'dfa_hwd.out',
-      env.File(arch_testdata_dir + '/hello_world.nexe'),
+      hello_world_nexe,
       stdout_golden = env.File('testdata/hello_world.stdout'),
       stderr_golden = env.File('testdata/non_dfa_validator_hello.stderr'),
       filter_regex = '"^(Hello, World!)$' + '|' +
         '^[[][^]]*[]] (USING OBSOLETE NON-DFA-BASED VALIDATOR!)$"',
       filter_group_only = 'true',
       )
   env.AddNodeToTestSuite(node, ['medium_tests', 'validator_tests'],
                          'run_dfa_validator_hello_world_test')
 
 if env.Bit('target_mips32'):
   text_region_start = 0x00020000
   # Use arbitrary non-page-aligned addresses for data and rodata.
   rodata_region_start = 0x10020094
   data_region_start = 0x10030098
-  untrusted_env = env.MakeUntrustedNativeEnv()

[Mark Seaborn, 2013/10/15 23:38:45]

Better to leave this in.  Otherwise you're relying on untrusted_env being
assigned in a block above which is conditionalised under a different condition,
which is a bit dodgy.

[petarj, 2013/10/16 23:36:08]

untrusted_env is not assigned under condition anymore.

   untrusted_env.Append(CPPFLAGS=['--pnacl-allow-native', '-arch', 'mips32'])
   unaligned_data_objs = untrusted_env.ComponentObject(
       'arch/mips/unaligned_data_test.S')
   unaligned_data_nexe = untrusted_env.ComponentProgram(
       'unaligned_data.nexe',
       unaligned_data_objs,
       LINKFLAGS=['-nostdlib',
                  '--pnacl-allow-native', '-arch', 'mips32',
                  '-Wn,--section-start=.text=0x%x' % (text_region_start),
                  '-Wn,--section-start=.rodata=0x%x' % (rodata_region_start),
@@ skipping 21 matching lines @@
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_unaligned_data_test')
 
 node = env.CommandSelLdrTestNacl(
     'unaligned_data_irt.out',
     unaligned_data_nexe,
     sel_ldr_flags=['-B', unaligned_data_irt_nexe]
     )
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_unaligned_data_irt_test')
 
 # ----------------------------------------------------------
+# Small tests with canned binaries
+# ----------------------------------------------------------
+
+if env.Bit('target_x86_64'):
+  node = env.CommandSelLdrTestNacl(

[Mark Seaborn, 2013/10/15 23:38:45]

Why is this moved?

[petarj, 2013/10/16 00:24:37]

It is not this part that was moved, but the other tests left the
"canned binaries" section.

+      'hello_x32.out',
+      env.File(os.path.join(arch_testdata_dir, 'hello_x32.nexe')),
+      stdout_golden=env.File(os.path.join('${MAIN_DIR}',
+                                          'tests/hello_world',
+                                          'hello_world.stdout'))
+      )
+  env.AddNodeToTestSuite(node, ['small_tests'], 'run_hello_x32_test')
+
+# ----------------------------------------------------------
 # Integration Tests With Canned x86 Binaries
 # ----------------------------------------------------------
 # To update the canned tests run:
 # ./scons platform=x86-64
 # cp scons-out/nacl-x86-64/staging/{mandel.nexe,fib_*} \
 #     src/trusted/service_runtime/testdata/x86_64/
 # ./scons platform=x86-32
 # cp scons-out/nacl-x86-32/staging/{mandel.nexe,fib_*} \
 #     src/trusted/service_runtime/testdata/x86_32/
 
@@ skipping 12 matching lines @@
   node = env.SelUniversalTest(
       test + '_canned.out',
       env.File(arch_testdata_dir + '/' + test + '.nexe'),
       stdin = location + '.stdin',
       stdout_golden = location + '.stdout',
       )
   env.AddNodeToTestSuite(node,
                          ['medium_tests'],
                          'run_%s_integration_test' % test)
 
-if env.Bit('target_x86'):
+if env.Bit('target_x86') and not env.Bit('bitcode'):
   RE_HELLO = '^(Hello, World!)$'
   RE_IDENT = '^\[[0-9,:.]*\] (e_ident\+1 = ELF)$'
 
-  node = env.CommandSelLdrTestNacl(
+  node = untrusted_env.CommandSelLdrTestNacl(
       'nacl_log.out',
-      env.File(arch_testdata_dir + '/hello_world.nexe'),
+      hello_world_nexe,
       log_golden = env.File('testdata/hello_world.log'),
       stdout_golden = env.File('testdata/hello_world.stdout'),
       filter_regex = '"' + RE_HELLO + '|' + RE_IDENT + '"',
       filter_group_only = 'true',
       )
   env.AddNodeToTestSuite(node, ['medium_tests'],
                          'run_service_runtime_hello_world_test')
 
   assert len(INTEGRATION_TESTS_X86) == len(INTEGRATION_TESTS_X86_STDIN_OUT)
   map(AddIntegrationTest,
@@ skipping 129 matching lines @@
                        is_broken=is_broken)
 
 dyn_array_test_exe = env.ComponentProgram('dyn_array_test',
                                           ['dyn_array_test.c'],
                                           EXTRA_LIBS=sel_ldr_libs)
 
 node = env.CommandTest('dyn_array_test.out',
                        command=[dyn_array_test_exe])
 
 env.AddNodeToTestSuite(node, ['small_tests'], 'run_dyn_array_test')