Allow running back-deployment testing against libc++abi

[ldionne]

Summary

Before this patch, we could only link against the back-deployment libc++abi
dylib. This patch allows linking against the just-built libc++abi, but
running against the back-deployment one -- just like we do for libc++.

Also, add XFAIL markup to flag expected errors.

[ldionne]

Rebase onto main to trigger the CI and see what's missing to close the loop on this.

[ldionne]

Fix failing tests.

libcxx/test/configs/legacy.cfg.in

 @AUTO_GEN_COMMENT@
 
 import os
 import site
 
 config.cxx_under_test           = "@CMAKE_CXX_COMPILER@"
 config.project_obj_root         = "@CMAKE_BINARY_DIR@"
 config.libcxx_src_root          = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root          = "@LIBCXX_BINARY_DIR@"
 config.cxx_library_root         = "@LIBCXX_LIBRARY_DIR@"
+config.abi_library_root         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.enable_exceptions        = @LIBCXX_ENABLE_EXCEPTIONS@
 config.enable_debug_tests       = @LIBCXX_ENABLE_DEBUG_MODE_SUPPORT@
 config.enable_experimental      = @LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY@
 config.enable_rtti              = @LIBCXX_ENABLE_RTTI@
 config.enable_shared            = @LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX@
 config.enable_32bit             = @LIBCXX_BUILD_32_BITS@
 config.cxx_abi                  = "@LIBCXX_CXX_ABI_LIBNAME@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.sanitizer_library        = "@LIBCXX_SANITIZER_LIBRARY@"
-config.abi_library_path         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.host_triple              = "@LLVM_HOST_TRIPLE@"
 config.target_triple            = "@TARGET_TRIPLE@"
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
 config.generate_coverage        = @LIBCXX_GENERATE_COVERAGE@
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.test_linker_flags        = "@LIBCXX_TEST_LINKER_FLAGS@"

libcxx/utils/ci/run-buildbot

if [[ "${OSX_ROOTS}" == "" ]]; then
         echo "--- Downloading previous macOS dylibs"
         PREVIOUS_DYLIBS_URL="http://lab.llvm.org:8080/roots/libcxx-roots.tar.gz"
         OSX_ROOTS="${BUILD_DIR}/macos-roots"
         mkdir -p "${OSX_ROOTS}"
         curl "${PREVIOUS_DYLIBS_URL}" | tar -xz --strip-components=1 -C "${OSX_ROOTS}"
     fi
 
     DEPLOYMENT_TARGET="${BUILDER#x86_64-apple-system-backdeployment-}"
+
+    # TODO: On Apple platforms, we never produce libc++abi.1.dylib, always libc++abi.dylib.
+    #       Fix that in the build so that the tests stop searching for @rpath/libc++abi.1.dylib.
+    cp "${OSX_ROOTS}/macOS/libc++abi/${DEPLOYMENT_TARGET}/libc++abi.dylib" \
+       "${OSX_ROOTS}/macOS/libc++abi/${DEPLOYMENT_TARGET}/libc++abi.1.dylib"
+
     PARAMS="target_triple=x86_64-apple-macosx${DEPLOYMENT_TARGET}"
     PARAMS+=";cxx_runtime_root=${OSX_ROOTS}/macOS/libc++/${DEPLOYMENT_TARGET}"
-    PARAMS+=";abi_library_path=${OSX_ROOTS}/macOS/libc++abi/${DEPLOYMENT_TARGET}"
+    PARAMS+=";abi_runtime_root=${OSX_ROOTS}/macOS/libc++abi/${DEPLOYMENT_TARGET}"
     PARAMS+=";use_system_cxx_lib=True"
 
     export CC=clang
     export CXX=clang++
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Apple.cmake" \
                    -DLIBCXX_TEST_PARAMS="${PARAMS}" \
                    -DLIBCXXABI_TEST_PARAMS="${PARAMS}"
 
-    # TODO: Also run the libc++abi tests
-    echo "+++ Running the libc++ tests"
-    ninja -C "${BUILD_DIR}" check-cxx
+    check-cxx-cxxabi
 ;;
 benchmarks)
     export CC=clang
     export CXX=clang++
     clean
     generate-cmake
     check-cxx-benchmarks
 ;;

libcxx/utils/libcxx/compiler.py

def __init__(self, config, path, flags=None, compile_flags=None, link_flags=None,
                  use_ccache=False, use_warnings=False, compile_env=None,
                  cxx_type=None, cxx_version=None):
         self.libcxx_config = config
         self.source_lang = 'c++'
         self.path = path
         self.flags = list(flags or [])
         self.compile_flags = list(compile_flags or [])
         self.link_flags = list(link_flags or [])
-        self.link_libcxxabi_flag = '-lc++abi'
         self.warning_flags = list(warning_flags or [])
         self.verify_supported = verify_supported
         self.use_verify = use_verify
         self.verify_flags = list(verify_flags or [])
         assert not use_verify or verify_supported
         assert not use_verify or verify_flags is not None
         self.modules_flags = list(modules_flags or [])
         self.use_modules = use_modules

libcxx/utils/libcxx/test/config.py

def configure(self):
         self.target_info = make_target_info(self)
         self.executor = self.get_lit_conf('executor')
         self.configure_cxx()
         self.configure_triple()
         self.configure_src_root()
         self.configure_obj_root()
         self.cxx_stdlib_under_test = self.get_lit_conf('cxx_stdlib_under_test', 'libc++')
         self.cxx_library_root = self.get_lit_conf('cxx_library_root', self.libcxx_obj_root)
-        self.abi_library_root = self.get_lit_conf('abi_library_path', None)
+        self.abi_library_root = self.get_lit_conf('abi_library_root', None)
         self.cxx_runtime_root = self.get_lit_conf('cxx_runtime_root', self.cxx_library_root)
+        self.abi_runtime_root = self.get_lit_conf('abi_runtime_root', self.abi_library_root)
         self.configure_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_debug_mode()
         self.configure_sanitizer()
         self.configure_coverage()
         self.configure_modules()
         self.configure_substitutions()
def print_config_info(self):
             self.lit_config.note('Using warnings: %s' % self.cxx.warning_flags)
         show_env_vars = {}
         for k,v in self.exec_env.items():
             if k not in os.environ or os.environ[k] != v:
                 show_env_vars[k] = v
         self.lit_config.note('Adding environment variables: %r' % show_env_vars)
         self.lit_config.note("Linking against the C++ Library at {}".format(self.cxx_library_root))
         self.lit_config.note("Running against the C++ Library at {}".format(self.cxx_runtime_root))
+        self.lit_config.note("Linking against the ABI Library at {}".format(self.abi_library_root))
+        self.lit_config.note("Running against the ABI Library at {}".format(self.abi_runtime_root))
         sys.stderr.flush()  # Force flushing to avoid broken output on Windows
 
     def get_test_format(self):
         from libcxx.test.format import LibcxxTestFormat
         return LibcxxTestFormat(
             self.cxx,
             self.use_clang_verify,
             self.executor,
def configure_link_flags_cxx_library_path(self):
         additional_flags = self.get_lit_conf('test_linker_flags')
         if additional_flags:
             self.cxx.link_flags += shlex.split(additional_flags)
 
     def configure_link_flags_abi_library_path(self):
         # Configure ABI library paths.
         if self.abi_library_root:
             self.cxx.link_flags += ['-L' + self.abi_library_root]
+        if self.abi_runtime_root:
             if not self.target_info.is_windows():
-                self.cxx.link_flags += ['-Wl,-rpath,' + self.abi_library_root]
+                self.cxx.link_flags += ['-Wl,-rpath,' + self.abi_runtime_root]
             else:
-                self.add_path(self.exec_env, self.abi_library_root)
+                self.add_path(self.exec_env, self.abi_runtime_root)
 
     def configure_link_flags_cxx_library(self):
         if self.link_shared:
             self.cxx.link_flags += ['-lc++']
         else:
             if self.cxx_library_root:
                 libname = self.make_static_lib_name('c++')
                 abs_path = os.path.join(self.cxx_library_root, libname)
def configure_link_flags_abi_library(self):
             if self.target_info.allow_cxxabi_link() or testing_libcxxabi:
                 libcxxabi_shared = self.get_lit_bool('libcxxabi_shared', default=True)
                 if libcxxabi_shared:
                     self.cxx.link_flags += ['-lc++abi']
                 else:
                     if self.abi_library_root:
                         libname = self.make_static_lib_name('c++abi')
                         abs_path = os.path.join(self.abi_library_root, libname)
-                        self.cxx.link_libcxxabi_flag = abs_path
                         self.cxx.link_flags += [abs_path]
                     else:
                         self.cxx.link_flags += ['-lc++abi']
         elif cxx_abi == 'libcxxrt':
             self.cxx.link_flags += ['-lcxxrt']
         elif cxx_abi == 'vcruntime':
             debug_suffix = 'd' if self.debug_build else ''
             self.cxx.link_flags += ['-l%s%s' % (lib, debug_suffix) for lib in
class Configuration(object):
     def configure_substitutions(self):
         sub = self.config.substitutions
         sub.append(('%{cxx}', pipes.quote(self.cxx.path)))
         flags = self.cxx.flags + (self.cxx.modules_flags if self.cxx.use_modules else [])
         compile_flags = self.cxx.compile_flags + (self.cxx.warning_flags if self.cxx.use_warnings else [])
         sub.append(('%{flags}',         ' '.join(map(pipes.quote, flags))))
         sub.append(('%{compile_flags}', ' '.join(map(pipes.quote, compile_flags))))
         sub.append(('%{link_flags}',    ' '.join(map(pipes.quote, self.cxx.link_flags))))
-        sub.append(('%{link_libcxxabi}', pipes.quote(self.cxx.link_libcxxabi_flag)))
+
         codesign_ident = self.get_lit_conf('llvm_codesign_identity', '')
         env_vars = ' '.join('%s=%s' % (k, pipes.quote(v)) for (k, v) in self.exec_env.items())
         exec_args = [
             '--execdir %T',
             '--codesign_identity "{}"'.format(codesign_ident),
             '--env {}'.format(env_vars)
         ]
         sub.append(('%{exec}', '{} {} -- '.format(self.executor, ' '.join(exec_args))))

libcxxabi/test/catch_function_01.pass.cpp

 //===----------------------- catch_function_01.cpp ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
 
 // GCC incorrectly allows function pointer to be caught by reference.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69372
 // XFAIL: gcc
 // UNSUPPORTED: no-exceptions
 
+// 65ace9daa360 made it in the dylib in macOS 10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cassert>
 
 template <class Tp>
 bool can_convert(Tp) { return true; }
 
 template <class>
 bool can_convert(...) { return false; }
 

libcxxabi/test/catch_member_data_pointer_01.pass.cpp

 //===----------------- catch_member_data_pointer_01.cpp -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// 1b00fc5d8133 made it in the dylib in macOS 10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cassert>
 
 struct A
 {
     A() : i(0), j(0) {} // explicitly initialize 'i' to prevent warnings
     const int i;
     int j;
 };

libcxxabi/test/catch_member_pointer_nullptr.pass.cpp

 //===----------------- catch_member_pointer_nullptr.cpp -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// Catching an exception thrown as nullptr was not properly handled before
+// 2f984cab4fa7, which landed in macOS 10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 // UNSUPPORTED: no-exceptions
 
 #include <cassert>
 
 #if __has_feature(cxx_nullptr)
 
 struct A
 {

libcxxabi/test/catch_multi_level_pointer.pass.cpp

 //===--------------------- catch_pointer_nullptr.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// 1b00fc5d8133 made it in the dylib in macOS 10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
 
 // Roll our own assertion macro to get better error messages out of the tests.
 // In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
 #define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)
 

libcxxabi/test/catch_pointer_nullptr.pass.cpp

 //===--------------------- catch_pointer_nullptr.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// Catching an exception thrown as nullptr was not properly handled before
+// 2f984cab4fa7, which landed in macOS 10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 // UNSUPPORTED: c++03
 // UNSUPPORTED: no-exceptions
 
 #include <cassert>
 #include <cstdlib>
 
 struct A {};
 

libcxxabi/test/catch_ptr_02.pass.cpp

 //===------------------------- catch_ptr_02.cpp ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
 // FIXME: GCC doesn't allow turning off the warning for exceptions being caught
 //        by earlier handlers, which this test is exercising. We have to disable
 //        warnings altogether to remove the error.
 //        See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97675.
 // ADDITIONAL_COMPILE_FLAGS: -Wno-error
 
+// The fix for PR17222 made it in the dylib for macOS 10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cassert>
 
 // Clang emits  warnings about exceptions of type 'Child' being caught by
 // an earlier handler of type 'Base'. Congrats clang, you've just
 // diagnosed the behavior under test.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wexceptions"
 #endif

libcxxabi/test/cxa_vec_new_overflow_PR41395.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// PR41395 isn't fixed until the dylib shipped with macOS 10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include "cxxabi.h"
 #include <new>
 #include <cassert>
 
 void dummy_ctor(void*) { assert(false && "should not be called"); }
 void dummy_dtor(void*) { assert(false && "should not be called"); }
 
 void *dummy_alloc(size_t) { assert(false && "should not be called"); }

libcxxabi/test/dynamic_cast.pass.cpp

 //===------------------------- dynamic_cast.pass.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: gcc-7, gcc-8, gcc-9
 
+// PR33425 and PR33487 are not fixed until the dylib shipped with macOS 10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+
+// PR33439 isn't fixed until the dylib shipped with macOS 10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cassert>
 
 // This test explicitly tests dynamic cast with types that have inaccessible
 // bases.
 #if defined(__clang__)
 #   pragma clang diagnostic ignored "-Winaccessible-base"
 #elif defined(__GNUC__) && (__GNUC__ >= 10)
 #   pragma GCC diagnostic ignored "-Winaccessible-base"

libcxxabi/test/exception_object_alignment.pass.cpp

 //===---------------- exception_object_alignment.pass.cpp -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// The situation for the alignment of exception objects is badly messed up
+// before macOS 10.14. The test fails on macOS 10.9 to 10.12, passes on macOS
+// 10.13 (no investigation done), and passes afterwards. Just mark all the OSes
+// before 10.14 as unsupported.
+// UNSUPPORTED: with_system_cxx_lib=macosx10.13
+// UNSUPPORTED: with_system_cxx_lib=macosx10.12
+// UNSUPPORTED: with_system_cxx_lib=macosx10.11
+// UNSUPPORTED: with_system_cxx_lib=macosx10.10
+// UNSUPPORTED: with_system_cxx_lib=macosx10.9
+
 // Check that the pointer __cxa_allocate_exception returns is aligned to the
 // default alignment for the target architecture.
 
 #include <cassert>
 #include <cstdint>
 #include <cxxabi.h>
 #include <type_traits>
 #include <__cxxabi_config.h>

libcxxabi/test/forced_unwind1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // _Unwind_ForcedUnwind raised exception can be caught by catch (...) and be
 // rethrown. If not rethrown, exception_cleanup will be called.
 
 // UNSUPPORTED: no-exceptions, c++03
 
+// These tests fail on previously released dylibs, investigation needed.
+// XFAIL: with_system_cxx_lib=macosx10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <stdlib.h>
 #include <string.h>
 #include <unwind.h>
 #include <tuple>
 #include <__cxxabi_config.h>
 
 #if defined(_LIBCXXABI_ARM_EHABI)
 int main(int, char**) {

libcxxabi/test/forced_unwind2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Forced unwinding causes std::terminate when going through noexcept.
 
 // UNSUPPORTED: no-exceptions, c++03
 
+// These tests fail on previously released dylibs, investigation needed.
+// XFAIL: with_system_cxx_lib=macosx10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <exception>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unwind.h>
 #include <tuple>
 #include <__cxxabi_config.h>
 

libcxxabi/test/incomplete_type.sh.cpp

 // (i.e. of the types represented) or ordering by comparison of their name
 // NTBS addresses. In addition, unless either or both have either of the
 // incomplete flags set, equality can be tested by comparing the type_info
 // addresses.
 
 // UNSUPPORTED: no-exceptions
 // UNSUPPORTED: no-rtti
 
-// NOTE: Link libc++abi explicitly and before libc++ so that libc++ doesn't drag
-// in the system libc++abi installation on OS X. (DYLD_LIBRARY_PATH is ignored
-// for shell tests because of Apple security features).
+// The fix for PR25898 landed in the system dylibs in macOS 10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
 
 // RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c %s -o %t.one.o
 // RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c %s -o %t.two.o -DTU_ONE
-// RUN: %{cxx} %{flags} %t.one.o %t.two.o %{link_libcxxabi} %{link_flags} -o %t.exe
+// RUN: %{cxx} %{flags} %t.one.o %t.two.o %{link_flags} -o %t.exe
 // RUN: %{exec} %t.exe
 
 #include <stdio.h>
 #include <cstring>
 #include <cassert>
 #include <typeinfo>
 
 // Check that the addresses of the typeinfo differ but still compare equal

libcxxabi/test/libcxxabi/test/config.py

 
 
 class Configuration(LibcxxConfiguration):
     # pylint: disable=redefined-outer-name
     def __init__(self, lit_config, config):
         super(Configuration, self).__init__(lit_config, config)
         self.libcxxabi_src_root = None
         self.libcxxabi_obj_root = None
-        self.abi_library_path = None
+        self.abi_library_root = None
         self.libcxx_src_root = None
 
     def configure_src_root(self):
         self.libcxxabi_src_root = self.get_lit_conf(
             'libcxxabi_src_root',
             os.path.dirname(self.config.test_source_root))
         self.libcxx_src_root = self.get_lit_conf(
             'libcxx_src_root',

libcxxabi/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 
 import os
 import site
 
 config.cxx_under_test           = "@CMAKE_CXX_COMPILER@"
 config.project_obj_root         = "@CMAKE_BINARY_DIR@"
 config.libcxxabi_src_root       = "@LIBCXXABI_SOURCE_DIR@"
 config.libcxxabi_obj_root       = "@LIBCXXABI_BINARY_DIR@"
-config.abi_library_path         = "@LIBCXXABI_LIBRARY_DIR@"
+config.abi_library_root         = "@LIBCXXABI_LIBRARY_DIR@"
 config.libcxx_src_root          = "@LIBCXXABI_LIBCXX_PATH@"
 config.cxx_headers              = "@LIBCXXABI_LIBCXX_INCLUDES@"
 config.libunwind_headers        = "@LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL@"
 config.cxx_library_root         = "@LIBCXXABI_LIBCXX_LIBRARY_PATH@"
 config.llvm_unwinder            = @LIBCXXABI_USE_LLVM_UNWINDER@
 config.builtins_library         = "@LIBCXXABI_BUILTINS_LIBRARY@"
 config.enable_threads           = @LIBCXXABI_ENABLE_THREADS@
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"

libcxxabi/test/test_aux_runtime_op_array_new.pass.cpp

 //===-------------------------- test_aux_runtime_op_array_new.cpp ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// ___cxa_throw_bad_array_new_length is re-exported from libc++ only starting
+// in macosx 10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cxxabi.h>
 #include <new>
 
 //  If the expression passed to operator new[] would result in an overflow, the
 //  allocation function is not called, and a std::bad_array_new_length exception
 //  is thrown instead (5.3.4p7).
 bool bad_array_new_length_test() {
     try {

libcxxabi/test/test_demangle.pass.cpp

 //===-------------------------- test_demangle.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// The demangler does not pass all these tests with the system dylibs on macOS.
+// XFAIL: with_system_cxx_lib=macosx10.15
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include "support/timer.h"
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
 #include <cxxabi.h>
 #include <string>
 
 // Is long double fp80?  (Only x87 extended double has 64-bit mantissa)

libcxxabi/test/test_exception_address_alignment.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // UNSUPPORTED: c++03
 
 // The <unwind.h> header provided in the SDK of older Xcodes used to provide
 // an incorrectly aligned _Unwind_Exception type. That causes these tests to
-// fail with those SDKs.
-// FIXME: We mark the test as unsupported on Apple until we have a Lit feature
-//        representing the SDK version.
-// UNSUPPORTED: darwin
+// fail when compiling against such a SDK, or when running against a system
+// libc++abi that was compiled with an incorrect definition of _Unwind_Exception.
+// XFAIL: apple-clang-12.0.0
+// XFAIL: apple-clang-11
+// XFAIL: apple-clang-10
+// XFAIL: apple-clang-9
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
 
 // Test that the address of the exception object is properly aligned as required
 // by the relevant ABI
 
 #include <cstdint>
 #include <cassert>
 #include <__cxxabi_config.h>
 

libcxxabi/test/thread_local_destruction_order.pass.cpp

 //===-------------- thread_local_destruction_order.pass.cpp ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// Darwin TLV finalization routines used to fail when creating a thread-local
-// variable in the destructor for another thread-local variable:
-//  - http://lists.llvm.org/pipermail/cfe-dev/2016-November/051376.html
-//  - rdar://29523281
-// This was fixed in dyld in macos 10.15.
-//
-// XFAIL: macosx10.14
-// XFAIL: macosx10.13
-// XFAIL: macosx10.12
-// XFAIL: macosx10.11
-// XFAIL: macosx10.10
-// XFAIL: macosx10.9
-
 // UNSUPPORTED: c++03
 // UNSUPPORTED: libcxxabi-no-threads
 
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 

libcxxabi/test/uncaught_exceptions.pass.cpp

 //===------------------- uncaught_exceptions.pass.cpp ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
+// __cxa_uncaught_exceptions is not re-exported from libc++ until macOS 10.15.
+// XFAIL: with_system_cxx_lib=macosx10.14
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+
 #include <cxxabi.h>
 #include <cassert>
 
 // namespace __cxxabiv1 {
 //      extern unsigned int __cxa_uncaught_exceptions() throw();
 // }
 
 struct A {

libunwind/test/libunwind/test/config.py

 
 
 class Configuration(LibcxxConfiguration):
     # pylint: disable=redefined-outer-name
     def __init__(self, lit_config, config):
         super(Configuration, self).__init__(lit_config, config)
         self.libunwind_src_root = None
         self.libunwind_obj_root = None
-        self.abi_library_path = None
+        self.abi_library_root = None
         self.libcxx_src_root = None
 
     def configure_src_root(self):
         self.libunwind_src_root = (self.get_lit_conf('libunwind_src_root')
             or os.path.dirname(self.config.test_source_root))
         self.libcxx_src_root = (self.get_lit_conf('libcxx_src_root')
             or os.path.join(self.libunwind_src_root, '..', 'libcxx'))
 

libunwind/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 
 import os
 import site
 
 config.cxx_under_test           = "@CMAKE_CXX_COMPILER@"
 config.project_obj_root         = "@CMAKE_BINARY_DIR@"
 config.libunwind_src_root       = "@LIBUNWIND_SOURCE_DIR@"
 config.libunwind_obj_root       = "@LIBUNWIND_BINARY_DIR@"
-config.abi_library_path         = "@LIBUNWIND_LIBRARY_DIR@"
+config.abi_library_root         = "@LIBUNWIND_LIBRARY_DIR@"
 config.libcxx_src_root          = "@LIBUNWIND_LIBCXX_PATH@"
 config.libunwind_headers        = "@LIBUNWIND_SOURCE_DIR@/include"
 config.cxx_library_root         = "@LIBUNWIND_LIBCXX_LIBRARY_PATH@"
 config.llvm_unwinder            = True
 config.builtins_library         = "@LIBUNWIND_BUILTINS_LIBRARY@"
 config.enable_threads           = @LIBUNWIND_ENABLE_THREADS@
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.enable_32bit             = @LIBUNWIND_BUILD_32_BITS@