Add nacl-clang testing to SCons

tests/toolchain/nacl.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('env')
 
 # force inclusion of entire library, so that we can validate it
 # NOTE: This approach does not work for -lc because of tons of
 #       undefined symbols which would have to be stubbed out
 DEP_LIBS = ['nacl', 'srpc', 'imc_syscalls', 'platform', 'gio', 'pthread', 'm']
 
 # -lgcc is not exposed to the bitcode in PNaCl
 if env.Bit('bitcode'):
   LIBGCC = []
 else:
   LIBGCC = ['-lgcc']
 
 DEP_LINKFLAGS = (['-Wl,--whole-archive'] + LIBGCC +
                    ['-l' + name for name in DEP_LIBS] +
                    ['-Wl,--no-whole-archive'])
 
 # TODO(robertm): get rid of -allow-asm once we can distinguish
 #                real asms from the redirect ones used here
 if env.Bit('bitcode'):
   env.Append(CCFLAGS=['-allow-asm'])
 
 # Test C++11 code with both supported C++ standard libraries.
-cpp11_libs = ['libstdc++', 'libc++']
+cpp11_libs = ['libc++']
+if env.Bit('bitcode'):
+  # PNaCl still supports libstdc++ but nacl-clang does not.
+  cpp11_libs.append('libstdc++')
 cpp11_envs = {}
 for lib in cpp11_libs:
   cpp11_envs[lib] = env.Clone()
   cpp11_envs[lib].Append(CCFLAGS=['-std=c++11', '-stdlib=' + lib])
   cpp11_envs[lib].Append(LINKFLAGS=['-stdlib=' + lib])
+  if lib == 'libstdc++':
+    # c++ is added to NONIRT_LIBS for clang to ensure that its dependence on
+    # pthreads can be satisfied by pthread_private instead of pthread. Filter it
+    # out here to ensure that we use libstdc++.
+    cpp11_envs[lib].FilterOut(NONIRT_LIBS=['c++'])
 
 # All the libraries were already included via -l switches in LINKFLAGS.
 # But we use them again in LIBS so scons knows about the dependencies.
 # _LIBFLAGS is the internal variable that puts the expansion of LIBS
 # into the command line; so by clearing that, we prevent scons from
 # adding repeated -l switches at the end of the link.
 nexe = env.ComponentProgram('dummy', 'dummy.c',
                             EXTRA_LINKFLAGS=DEP_LINKFLAGS,
                             LIBS=DEP_LIBS,
                             _LIBFLAGS='')
@@ skipping 28 matching lines @@
 AddIntrinsicTest(env, 'float2.c', '0', golden_file=env.File('float2.stdout'))
 AddIntrinsicTest(env, 'synchronization_sync.c', '0',
                  # TODO(jfb) Blocked on bugs 3579 and 2981. This should
                  # work on PNaCl because it avoids the broken 16-bit
                  # instructions on x86-32 by using 32-bit instructions.
                  # The test also exercises instructions that confuse valgrind.
                  is_broken=((env.Bit('target_x86_32') and
                              not env.Bit('bitcode')) or
                             env.IsRunningUnderValgrind()))
 AddIntrinsicTest(env, 'synchronization_volatile.c', '0')
-if env.Bit('bitcode'):
+if env.Bit('bitcode') or env.Bit('nacl_clang'):
   # The following tests were only made to work on LLVM for
   # PNaCl. Command-line flags and libraries need to be updated for GCC
   # support.
   # pthread is needed when building with libc++.
   for lib in cpp11_envs:
     AddIntrinsicTest(cpp11_envs[lib], 'condition_variable_cpp11.cc', '0',
                      test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
     AddIntrinsicTest(cpp11_envs[lib], 'future_cpp11.cc', '0',
                      test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
     AddIntrinsicTest(cpp11_envs[lib], 'mutex_cpp11.cc', '0',
                      test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
     AddIntrinsicTest(cpp11_envs[lib], 'synchronization_cpp11.cc', '0',
                      test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
     AddIntrinsicTest(cpp11_envs[lib], 'thread_cpp11.cc', '0',
                      test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
     if lib != 'libstdc++':
       # TODO(jfb) Can't compile with libstdc++.
       AddIntrinsicTest(cpp11_envs[lib], 'long_double_cpp11.cc', '0',
                        test_suffix=lib, EXTRA_LIBS=['${PTHREAD_LIBS}'])
 
 # This test redirects C function calls to llvm instrinsic functions,
 # so they only work w/ PNaCl.
-if env.Bit('bitcode'):
+if env.Bit('bitcode') or env.Bit('nacl_clang'):
   AddIntrinsicTest(env, 'llvm_bitmanip_intrinsics.c', '0',
                    golden_file=env.File('llvm_bitmanip_intrinsics.stdout'))
   AddIntrinsicTest(env, 'llvm_math_intrinsics.c', '0',
                    golden_file=env.File('llvm_math_intrinsics.stdout'))
   # Also test the math functions with -ffast-math, so we are a tiny bit more
   # confident that sin() or __builtin_sin() doesn't get turned into
   # something like llvm.sin.f64.
   fastmath_env = env.Clone()
   fastmath_env.Append(CCFLAGS=['-ffast-math'])
   AddIntrinsicTest(fastmath_env, 'llvm_math_intrinsics.c', '0',
@@ skipping 118 matching lines @@
     new_env.Append(CCFLAGS=['-O2'])
   else:
     new_env.FilterOut(CFLAGS=['-O2'])
     new_env.FilterOut(CCFLAGS=['-O2'])
     new_env.FilterOut(LINKFLAGS=['-O3'])
   return new_env
 
 EH_ENVIRONMENTS_TO_TRY = []
 
 base_eh_env = env.Clone()
+
 supports_cxx11 = env.Bit('bitcode') or env.Bit('target_arm')
 base_eh_env.Append(CPPDEFINES=[['SUPPORTS_CXX11', str(int(supports_cxx11))]])
 if supports_cxx11:
   # This flag is necessary for testing std::rethrow_exception(), at
   # least when using libstdc++.
   base_eh_env.Append(CXXFLAGS=['-std=gnu++11'])
 
 if env.Bit('bitcode') and env['TOOLCHAIN_FEATURE_VERSION'] >= 1:
   for lib in ('libstdc++', 'libc++'):
     sjlj_eh_env = base_eh_env.Clone()
     sjlj_eh_env.Append(LINKFLAGS=['--pnacl-exceptions=sjlj',
                                   '-stdlib=%s' % lib])
     sjlj_eh_env.Append(CCFLAGS=['-stdlib=%s' % lib])
+    # c++ is added to NONIRT_LIBS for clang to ensure that its dependence on
+    # pthreads can be satisfied by pthread_private instead of pthread. Filter it
+    # out here to ensure that we use libstdc++.
+    if lib == 'libstdc++':
+      sjlj_eh_env.FilterOut(NONIRT_LIBS=['c++'])
     EH_ENVIRONMENTS_TO_TRY.append(('sjlj_%s' % lib, sjlj_eh_env))
 
 if env.Bit('bitcode'):
   zerocost_eh_env = base_eh_env.Clone()
   zerocost_eh_env.Append(LINKFLAGS=['--pnacl-allow-exceptions'])
   zerocost_eh_env.Append(TRANSLATEFLAGS=['--pnacl-allow-exceptions'])
 else:
   zerocost_eh_env = base_eh_env
 # Zero-cost C++ exception handling is not currently supported in
 # PNaCl's stable ABI.
@@ skipping 329 matching lines @@
   mixedlink_env.Append(CCFLAGS=['-Wt,-force-align-stack'])
   nexe = mixedlink_env.ComponentProgram(
       'stackalign_test',
       ['call_with_misaligned_stack.S', 'stackalign_test.c'],
       EXTRA_LIBS=['${NONIRT_LIBS}'])
   node = mixedlink_env.CommandSelLdrTestNacl('stackalign.out', nexe)
   mixedlink_env.AddNodeToTestSuite(
       node,
       ['nonpexe_tests', 'small_tests', 'toolchain_tests'],
       'run_stackalign_test')