[libcxx] Use "-stdlib=libc++" when possible instead of '-nodefaultlibs' in the test suite.

[EricWF]

Summary

Currently we use '-nodefaultlibs' when building and running the libc++ tests. However we should prefer using '-stdlib=libc++'.
This patch automatically detects when the test suite can use "-stdlib=libc++" and prefers it when possible.

We use -stdlib=libc++ when the following are true:

1. CXX is clang or apple clang.
2. 'cxx_abi' is set to 'none'. This means that libc++ handles the ABI library dependency on its own.
3. We are using the default unwinder (ie not libunwind).

[jroelofs]

test/libcxx/test/config.py

364

Maybe it makes sense to name this 'auto' instead of 'none'?

[EricWF]

test/libcxx/test/config.py

364

I don't think so. I think the CMake option LIBCXX_CXX_ABI should learn "auto" instead of "none". Once CMake knows the correct library it can pass that on to the test suite. Currently CMake passes "none" when it knows "libc++.so" exports the ABI library symbols directly.

[EricWF]

Update diff against ToT.

[jroelofs]

test/libcxx/test/config.py

364

ohh, I see now.

[EricWF]

This is long dead.

test/libcxx/compiler.py

def _initTypeAndVersion(self):
         elif '__GNUC__' in macros.keys():
             compiler_type = 'gcc'
             major_ver = macros['__GNUC__']
             minor_ver = macros['__GNUC_MINOR__']
             patchlevel = macros['__GNUC_PATCHLEVEL__']
         self.type = compiler_type
         self.version = (major_ver, minor_ver, patchlevel)
 
+    def isClang(self):
+        return self.type == 'clang' or self.type == 'apple-clang'
+
+    def isGCC(self):
+        return self.type == 'gcc'
+
     def _basicCmd(self, source_files, out, is_link=False, input_is_cxx=False):
         cmd = []
         if self.use_ccache and not is_link:
             cmd += ['ccache']
         cmd += [self.path]
         if out is not None:
             cmd += ['-o', out]
         if input_is_cxx:

test/libcxx/test/config.py

def __init__(self, lit_config, config):
         self.cxx = None
         self.project_obj_root = None
         self.libcxx_src_root = None
         self.libcxx_obj_root = None
         self.cxx_library_root = None
         self.abi_library_root = None
         self.env = {}
         self.use_target = False
+        self.use_stdlib_eq_libcxx = False
         self.use_system_cxx_lib = False
         self.use_clang_verify = False
         self.long_tests = None
         self.execute_external = False
 
     def get_lit_conf(self, name, default=None):
         val = self.lit_config.params.get(name, None)
         if val is None:
def configure(self):
         self.configure_triple()
         self.configure_src_root()
         self.configure_obj_root()
         self.configure_cxx_library_root()
         self.configure_use_system_cxx_lib()
         self.configure_use_clang_verify()
         self.configure_execute_external()
         self.configure_ccache()
+        self.configure_use_stdlib_eq_libcxx()
         self.configure_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_color_diagnostics()
         self.configure_debug_mode()
         self.configure_warnings()
         self.configure_sanitizer()
         self.configure_coverage()
def configure_features(self):
         if self.long_tests:
             self.config.available_features.add('long_tests')
 
         # Run a compile test for the -fsized-deallocation flag. This is needed
         # in test/std/language.support/support.dynamic/new.delete
         if self.cxx.hasCompileFlag('-fsized-deallocation'):
             self.config.available_features.add('fsized-deallocation')
 
+    def configure_use_stdlib_eq_libcxx(self):
+        cxx_abi = self.get_lit_conf('cxx_abi', 'libcxxabi')
+        use_llvm_unwinder = self.get_lit_bool('llvm_unwinder', False)
+        deduced_use_stdlib_eq_libcxx = (self.cxx.isClang() and
+                                        cxx_abi == 'none' and
+                                        not use_llvm_unwinder)
+        self.use_stdlib_eq_libcxx = self.get_lit_bool(
+            'use_stdlib_eq_libcxx', deduced_use_stdlib_eq_libcxx)
+        if self.use_stdlib_eq_libcxx and not deduced_use_stdlib_eq_libcxx:
+            self.lit_config.fatal('--param=use_stdlib_eq_libcxx=true cannot be '
+                'specified in this configuration.')
+
+
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.configure_default_compile_flags()
         # Configure extra flags
         compile_flags_str = self.get_lit_conf('compile_flags', '')
         self.cxx.compile_flags += shlex.split(compile_flags_str)
         sysroot_flags = getSysrootFlagsOnDarwin(self.config, self.lit_config)
def configure_compile_flags_abi_version(self):
           self.cxx.compile_flags += ['-D_LIBCPP_ABI_VERSION=' + abi_version]
         if abi_unstable:
           self.config.available_features.add('libcpp-abi-unstable')
           self.cxx.compile_flags += ['-D_LIBCPP_ABI_UNSTABLE']
 
     def configure_link_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
+            if not self.use_stdlib_eq_libcxx:
                 self.cxx.link_flags += ['-nodefaultlibs']
 
             # Configure library path
             self.configure_link_flags_cxx_library_path()
             self.configure_link_flags_abi_library_path()
 
-            # Configure libraries
             self.configure_link_flags_cxx_library()
             self.configure_link_flags_abi_library()
-            self.configure_extra_library_flags()
+
+            enable_threads = ('libcpp-has-no-threads' not in
+                               self.config.available_features)
+
+            if not self.use_stdlib_eq_libcxx:
+                self.configure_builtin_libraries(enable_threads)
+            elif enable_threads:
+                self.cxx.link_flags += ['-lpthread']
 
         link_flags_str = self.get_lit_conf('link_flags', '')
         self.cxx.link_flags += shlex.split(link_flags_str)
 
     def configure_link_flags_cxx_library_path(self):
         libcxx_library = self.get_lit_conf('libcxx_library')
         # Configure libc++ library paths.
         if libcxx_library is not None:
def configure_link_flags_abi_library_path(self):
         # Configure ABI library paths.
         self.abi_library_root = self.get_lit_conf('abi_library_path')
         if self.abi_library_root:
             self.cxx.link_flags += ['-L' + self.abi_library_root,
                                     '-Wl,-rpath,' + self.abi_library_root]
 
     def configure_link_flags_cxx_library(self):
         libcxx_library = self.get_lit_conf('libcxx_library')
-        if libcxx_library:
+        if self.use_stdlib_eq_libcxx:
+            self.cxx.link_flags += ['-stdlib=libc++']
+        elif libcxx_library:
             self.cxx.link_flags += [libcxx_library]
         else:
             self.cxx.link_flags += ['-lc++']
 
     def configure_link_flags_abi_library(self):
+
         cxx_abi = self.get_lit_conf('cxx_abi', 'libcxxabi')
         if cxx_abi == 'libstdc++':
             self.cxx.link_flags += ['-lstdc++']
         elif cxx_abi == 'libsupc++':
             self.cxx.link_flags += ['-lsupc++']
         elif cxx_abi == 'libcxxabi':
             # Don't link libc++abi explicitly on OS X because the symbols
             # should be available in libc++ directly.
             if self.target_info.platform() != 'darwin':
                 self.cxx.link_flags += ['-lc++abi']
         elif cxx_abi == 'libcxxrt':
             self.cxx.link_flags += ['-lcxxrt']
         elif cxx_abi == 'none':
             pass
         else:
             self.lit_config.fatal(
                 'C++ ABI setting %s unsupported for tests' % cxx_abi)
 
-    def configure_extra_library_flags(self):
-        enable_threads = ('libcpp-has-no-threads' not in
-                          self.config.available_features)
+    def configure_builtin_libraries(self, enable_threads):
+        assert not self.use_stdlib_eq_libcxx
         llvm_unwinder = self.get_lit_bool('llvm_unwinder', False)
         target_platform = self.target_info.platform()
         if target_platform == 'darwin':
             self.cxx.link_flags += ['-lSystem']
         elif target_platform == 'linux':
             self.cxx.link_flags += ['-lm']
             if not llvm_unwinder:
                 self.cxx.link_flags += ['-lgcc_s', '-lgcc']
def configure_sanitizer(self):
             if cxx_path is not None:
                 symbolizer_search_paths = (
                     os.path.dirname(cxx_path) +
                     os.pathsep + symbolizer_search_paths)
             llvm_symbolizer = lit.util.which('llvm-symbolizer',
                                              symbolizer_search_paths)
             # Setup the sanitizer compile flags
             self.cxx.flags += ['-g', '-fno-omit-frame-pointer']
-            if self.target_info.platform() == 'linux':
+            if self.target_info.platform() == 'linux' and \
+               not self.use_stdlib_eq_libcxx:
                 # The libraries and their order are taken from the
                 # linkSanitizerRuntimeDeps function in
                 # clang/lib/Driver/Tools.cpp
                 self.cxx.link_flags += ['-lpthread', '-lrt', '-lm', '-ldl']
             if san == 'Address':
                 self.cxx.flags += ['-fsanitize=address']
                 if llvm_symbolizer is not None:
                     self.env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
def configure_sanitizer(self):
             elif san == 'Thread':
                 self.cxx.flags += ['-fsanitize=thread']
                 self.config.available_features.add('tsan')
                 self.config.available_features.add('sanitizer-new-delete')
             else:
                 self.lit_config.fatal('unsupported value for '
                                       'use_sanitizer: {0}'.format(san))
             san_lib = self.get_lit_conf('sanitizer_library')
-            if san_lib:
+            # FIXME Issues a warning when sanitizer_library is given
+            # when self.use_stdlib_eq_libcxx is ON.
+            if san_lib and not self.use_stdlib_eq_libcxx:
                 self.cxx.link_flags += [
                     san_lib, '-Wl,-rpath,%s' % os.path.dirname(san_lib)]
 
     def configure_coverage(self):
         self.generate_coverage = self.get_lit_bool('generate_coverage', False)
         if self.generate_coverage:
             self.cxx.flags += ['-g', '--coverage']
             self.cxx.compile_flags += ['-O0']