Run NaClEnvCleanser in standalone sel_ldr (in addition to sel_main_chrome). Add a couple of ld.so...

src/trusted/service_runtime/build.scons

 # -*- python -*-
 # Copyright (c) 2011 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('env')
 
 # TODO(robertm): consider adding this to the top level scons files
@@ skipping 248 matching lines @@
   # TODO(ncbray) why do we need to link against Cocoa?
   # run_fake_browser_ppapi_test fails on mac, otherwise.
   # http://code.google.com/p/nativeclient/issues/detail?id=1242
   sel_ldr_env = env.Clone()
   if env.Bit('mac'):
     sel_ldr_env.Append(FRAMEWORKS=['Cocoa'])
 
   SEL_LDR_NODE = sel_ldr_env.ComponentProgram('sel_ldr',
                                           'sel_main.c',
                                           EXTRA_LIBS=['sel',
+                                                      'env_cleanser',
                                                       'nacl_error_code',
                                                       'simple_service',
                                                       'thread_interface',
                                                       'gio_wrapped_desc',
                                                       'nonnacl_srpc',
                                                       'nrd_xfer',
                                                       'nacl_perf_counter',
                                                       'nacl_base',
                                                       'imc',
                                                       'container',
                                                       'platform',
                                                       'platform_qual_lib',
                                                       'gio',
                                                       ] + VALIDATOR_LIBS
                                                       + DEBUG_LIBS)
 
   # we need this to build the plugin, so register it here
   env.AddPluginPrerequisite(SEL_LDR_NODE)
 
   # NOTE: we do not have segments on ARM
   if env.Bit('build_x86'):
     env.ComponentProgram('nacl_ldt_unittest',
                          'nacl_ldt_unittest.c',
                          EXTRA_LIBS=['sel',
+                                     'env_cleanser',
                                      'nacl_perf_counter',
                                      'gio_wrapped_desc',
                                      'platform',
                                      'gio',
                                      ])
   env.Requires(SEL_LDR_NODE, crt)
 
 env.EnsureRequiredBuildWarnings()
 
 # ----------------------------------------------------------
@@ skipping 25 matching lines @@
     'sel_mem_test.cc',
     'sel_ldr_test.cc',
 ]
 
 if (not env.CrossToolsBuild() and
     (not env.Bit('coverage_enabled') or not env.Bit('windows'))):
   unit_tests_exe = gtest_env.ComponentProgram('service_runtime_tests',
                                               unittest_inputs,
                                               EXTRA_LIBS=['gtest',
                                                           'sel',
+                                                          'env_cleanser',
                                                           'simple_service',
                                                           'thread_interface',
                                                           'gio_wrapped_desc',
                                                           'nonnacl_srpc',
                                                           'nrd_xfer',
                                                           'nacl_perf_counter',
                                                           'nacl_base',
                                                           'imc',
                                                           'platform',
                                                           'gio',
                                                           ] + VALIDATOR_LIBS
                                                           + DEBUG_LIBS)
   gtest_env.Requires(unit_tests_exe, crt)
 
   node = gtest_env.CommandTest(
       'gtest_output.xml.out',
       command=[unit_tests_exe, '--gtest_output=xml:${TARGET}'])
   gtest_env.AddNodeToTestSuite(node, ['small_tests'],
       'run_service_runtime_tests')
 
 
 if not env.Bit('coverage_enabled') or not env.Bit('windows'):
   format_string_test_exe = env.ComponentProgram(
       'format_string_test',
       ['format_string_test.c'],
       EXTRA_LIBS=['sel',
+                  'env_cleanser',
                   'nacl_perf_counter'])
   env.Requires(format_string_test_exe, crt)
 
   node = env.CommandTest(
       'format_string_test.out',
       command=[format_string_test_exe])
   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']
 
 
 # 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')) and
     not env.CrossToolsBuild()):
   # NOTE: uses validator
   mmap_test_exe = env.ComponentProgram('mmap_test',
                                            ['mmap_test.c'],
                                            EXTRA_LIBS=['sel',
+                                                       'env_cleanser',
                                                        'simple_service',
                                                        'thread_interface',
                                                        'gio_wrapped_desc',
                                                        'nonnacl_srpc',
                                                        'nrd_xfer',
                                                        'nacl_perf_counter',
                                                        'nacl_base',
                                                        'imc',
                                                        'platform',
                                                        'gio',
@@ skipping 15 matching lines @@
                          is_broken=env.Bit('build_arm') and env.UsingEmulator())
 
 
 # also seems to have issues with windows coverage or VMs
 # NOTE: uses validator
 is_broken = env.Bit('coverage_enabled') or env.Bit('running_on_vm')
 nacl_sync_cond_test_exe = env.ComponentProgram(
     'nacl_sync_cond_test',
     ['nacl_sync_cond_test.c'],
     EXTRA_LIBS=['sel',
+                'env_cleanser',
                 'simple_service',
                 'thread_interface',
                 'gio_wrapped_desc',
                 'nonnacl_srpc',
                 'nrd_xfer',
                 'nacl_perf_counter',
                 'nacl_base',
                 'imc',
                 'platform',
                 'gio',
@@ skipping 20 matching lines @@
 env.Requires(env_cleanser_test_exe, crt)
 env.AddNodeToTestSuite(node, ['small_tests'])
 
 # Test nacl_signal
 if (not env.Bit('coverage_enabled') and
     not env.Bit('target_arm') and
     not env.IsRunningUnderValgrind()):
   nacl_signal_exe = env.ComponentProgram('nacl_signal_unittest',
                                          'nacl_signal_unittest.c',
                                          EXTRA_LIBS=['sel',
+                                                     'env_cleanser',
                                                      'nacl_perf_counter',
                                                      'gio_wrapped_desc',
                                                      'platform',
                                                      'gio',
                                                      ])
   node = env.CommandTest('nacl_signal_unittest.out',
                          command=[nacl_signal_exe],
                          exit_status='trusted_sigsegv_or_equivalent')
 
   env.Requires(nacl_signal_exe, crt)
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_nacl_signal_test')
 
 if env.Bit('posix'):
   test_prog = env.ComponentProgram('nacl_signal_frame_test',
                                    'nacl_signal_frame_test.c',
                                    EXTRA_LIBS=['sel',
+                                               'env_cleanser',
                                                'nacl_perf_counter',
                                                'gio_wrapped_desc',
                                                'platform',
                                                'gio',
                                                ])
   node = env.CommandTest('nacl_signal_frame_test.out',
                          command=[test_prog],
                          exit_status='trusted_segfault')
   env.AddNodeToTestSuite(node, ['small_tests'], 'run_signal_frame_test')
 
 
 check_test_exe = env.ComponentProgram('nacl_check_test',
                                       ['nacl_check_test.c'],
                                       EXTRA_LIBS=['sel',
+                                                  'env_cleanser',
                                                   'nacl_perf_counter',
                                                   'gio_wrapped_desc',
                                                   'platform',
                                                   'gio',
                                                   ])
 node = env.CommandTest(
     'check_test.out',
     command=[check_test_exe, '-C'])
 env.Requires(check_test_exe, crt)
 env.AddNodeToTestSuite(node, ['small_tests'])
@@ skipping 91 matching lines @@
 
 # Doesn't work on windows under coverage.
 # TODO(bradnelson): fix this to work on windows under coverage.
 # NOTE: uses validator
 if ((not env.Bit('windows') or not env.Bit('coverage_enabled')) and
     not env.CrossToolsBuild()):
   obj_proxy_test_inputs = [ 'fs/obj_proxy_test.c', ]
   obj_proxy_test = env.ComponentProgram('obj_proxy_test',
                                             obj_proxy_test_inputs,
                                             EXTRA_LIBS=['sel',
+                                                        'env_cleanser',
                                                         'simple_service',
                                                         'thread_interface',
                                                         'gio_wrapped_desc',
                                                         'nonnacl_srpc',
                                                         'nrd_xfer',
                                                         'nacl_perf_counter',
                                                         'nacl_base',
                                                         'imc',
                                                         'platform',
                                                         'gio',
@@ skipping 123 matching lines @@
 # ----------------------------------------------------------
 # More Death Tests
 # ----------------------------------------------------------
 if (not env.CrossToolsBuild() and
     (not env.Bit('coverage_enabled') or not env.Bit('windows'))):
   # NOTE: uses validator
   sel_ldr_thread_death_test_exe = env.ComponentProgram(
       'sel_ldr_thread_death_test',
       ['sel_ldr_thread_death_test.c'],
       EXTRA_LIBS=['sel',
+                  'env_cleanser',
                   'simple_service',
                   'thread_interface',
                   'gio_wrapped_desc',
                   'nonnacl_srpc',
                   'nrd_xfer',
                   'nacl_perf_counter',
                   'nacl_base',
                   'imc',
                   'platform',
                   'gio',
                   ] + VALIDATOR_LIBS
                   + DEBUG_LIBS)
 
   node = env.CommandTest(
       'sel_ldr_thread_death_test.out',
       command=[sel_ldr_thread_death_test_exe],
       exit_status='sigabrt')
 
   # TODO(tuduce): Make it work on windows.
   env.AddNodeToTestSuite(node, ['medium_tests'],
                          'run_sel_ldr_thread_death_test',
                          is_broken=env.Bit('windows'))