[runtimes][ci] Run the tests for libunwind in the CI

[ldionne]

Summary

We should arguably have always been doing that. The state of libunwind
is quite sad, so this commit adds several XFAILs to make the CI pass.
We need to investigate why so many tests are not passing in some
configurations, but I'll defer that to folks who actually work on
libunwind for lack of bandwidth.

[ldionne]

Note that I suspect this won't work out-of-the-box cause the libunwind tests might be broken in a few ways (and that's why we haven't been running those tests from the start), however let's see what the CI tells us.

[ldionne]

Poke CI.

[ldionne]

Poke ci

[ldionne]

XFAIL a test on GCC

[danielkiss]

libcxx/utils/ci/run-buildbot

92

Isn't -DLIBCXXABI_USE_LLVM_UNWINDER=Y needed also to use the in tree version of libunwind?

[ldionne]

Add a bunch of XFAILs. This is really bad, we have like 8 tests and more than half
of them are failing even in some common configurations. We'll need some serious
investigation.

[jloser]

In D110872#3043923, @ldionne wrote:

Add a bunch of XFAILs. This is really bad, we have like 8 tests and more than half
of them are failing even in some common configurations. We'll need some serious
investigation.

Yikes.

[ldionne]

In D110872#3043948, @jloser wrote:

In D110872#3043923, @ldionne wrote:

Add a bunch of XFAILs. This is really bad, we have like 8 tests and more than half
of them are failing even in some common configurations. We'll need some serious
investigation.

Yikes.

I am pretty sure that all the tests used to pass on macOS a couple years ago, but apparently a lot of changes have landed without proper CI and testing, so now they're red.

Pinging some people who have touched libunwind lately: @vitalybuka @MaskRay @danielkiss. I'm not sure who's closest to being a libunwind code owner, but it would be awesome if we could get a grip over the project. I'd do it, but libc++ and libc++abi are already borderline too much. I'll add this CI to avoid introducing new regressions, at least that's one step forward.

[ldionne]

Rebase onto main (there were many concurrent changes in run-buildbot)

[danielkiss]

@ldionne I'll take a look.

libcxx/utils/ci/run-buildbot

${CMAKE} \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml" \
           "${@}"
 }
 
 function generate-cmake() {
     generate-cmake-base \
           -S "${MONOREPO_ROOT}/llvm" \
           -DLLVM_ENABLE_PROJECTS="libcxx;libunwind;libcxxabi" \
           -DLIBCXX_CXX_ABI=libcxxabi \
           "${@}"
 }
 
 function generate-cmake-libcxx-win() {
     # TODO: Clang-cl in MSVC configurations don't have access to compiler_rt
     # builtins helpers for int128 division. See
     # https://reviews.llvm.org/D91139#2429595 for a comment about longterm
     # intent for handling the issue. In the meantime, define
     # -D_LIBCPP_HAS_NO_INT128 (both when building the library itself and
     # when building tests) to allow enabling filesystem for running tests,
     # even if it uses a non-permanent ABI.
 
     generate-cmake-base \
           -S "${MONOREPO_ROOT}/libcxx" \
           -DCMAKE_C_COMPILER=clang-cl \
           -DCMAKE_CXX_COMPILER=clang-cl \
           -DLIBCXX_ENABLE_FILESYSTEM=YES \
           -DCMAKE_CXX_FLAGS="-D_LIBCPP_HAS_NO_INT128" \
           -DLIBCXX_TEST_COMPILER_FLAGS="-D_LIBCPP_HAS_NO_INT128" \
           "${@}"
 }
 
-function check-cxx-cxxabi() {
-    echo "--- Installing libc++ and libc++abi to a fake location"
-    ${NINJA} -vC "${BUILD_DIR}" install-cxx install-cxxabi
+function check-runtimes() {
+    echo "--- Installing libc++, libc++abi and libunwind to a fake location"
+    ${NINJA} -vC "${BUILD_DIR}" install-cxx install-cxxabi install-unwind
 
     echo "+++ Running the libc++ tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx
 
     echo "+++ Running the libc++abi tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxxabi
+
+    echo "+++ Running the libunwind tests"
+    ${NINJA} -vC "${BUILD_DIR}" check-unwind
 }
 
 # TODO: The goal is to test this against all configurations. We should also move
 #       this to the Lit test suite instead of being a separate CMake target.
 function check-abi-list() {
     echo "+++ Running the libc++ ABI list test"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx-abilist || (
         echo "+++ Generating the libc++ ABI list after failed check"
check-generated-output)
 
     # Reject patches that introduce dependency cycles in the headers.
     python3 libcxx/utils/graph_header_deps.py >/dev/null
 ;;
 generic-cxx03)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx03.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-cxx11)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx11.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-cxx14)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx14.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-cxx17)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx17.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-cxx20)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx20.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-cxx2b)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx2b.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-assertions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-assertions.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-debug-iterators)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-debug-iterators.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
     check-abi-list
 ;;
 generic-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-noexceptions.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-modules)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-modules.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-static)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-static.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-static.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-32bit)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-32bits.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-clang-11)
     export CC=clang-11
     export CXX=clang++-11
     clean
     generate-cmake -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-clang-12)
     export CC=clang-12
     export CXX=clang++-12
     clean
     generate-cmake -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-gcc)
     export CC=gcc-11
     export CXX=g++-11
     clean
     generate-cmake
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-gcc-cxx11)
     export CC=gcc-11
     export CXX=g++-11
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx11.cmake"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-asan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-asan.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-msan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-msan.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-tsan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-tsan.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-ubsan)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-ubsan.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-with_llvm_unwinder)
     clean
     generate-cmake -DLIBCXXABI_USE_LLVM_UNWINDER=ON \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-singlethreaded)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-singlethreaded.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-no-debug)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-debug.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-no-filesystem)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-filesystem.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-no-random_device)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-random_device.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-no-localization)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-localization.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 generic-no-unicode)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-unicode.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 x86_64-apple-system)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Apple.cmake" \
                    -DLIBCXX_TEST_CONFIG="apple-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 x86_64-apple-system-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Apple.cmake" \
                    -DLIBCXX_ENABLE_EXCEPTIONS=OFF \
                    -DLIBCXXABI_ENABLE_EXCEPTIONS=OFF \
                    -DLIBCXX_TEST_CONFIG="apple-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 x86_64-apple-system-backdeployment-*)
     clean
 
     if [[ "${OSX_ROOTS}" == "" ]]; then
         echo "--- Downloading previous macOS dylibs"
         PREVIOUS_DYLIBS_URL="https://dl.dropboxusercontent.com/s/liu4fmc53qzlfly/libcxx-roots.tar.gz"
         OSX_ROOTS="${BUILD_DIR}/macos-roots"
x86_64-apple-system-backdeployment-*)
     PARAMS+=";cxx_runtime_root=${OSX_ROOTS}/macOS/libc++/${DEPLOYMENT_TARGET}"
     PARAMS+=";abi_runtime_root=${OSX_ROOTS}/macOS/libc++abi/${DEPLOYMENT_TARGET}"
     PARAMS+=";use_system_cxx_lib=True"
 
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Apple.cmake" \
                    -DLIBCXX_TEST_PARAMS="${PARAMS}" \
                    -DLIBCXXABI_TEST_PARAMS="${PARAMS}"
 
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 benchmarks)
     clean
     generate-cmake -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
     check-cxx-benchmarks
 ;;
 documentation)
     clean
${CMAKE} \
           -S "${MONOREPO_ROOT}/libcxx/utils/ci/runtimes" \
           -B "${BUILD_DIR}" \
           -GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}" \
           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DLLVM_ENABLE_PROJECTS="libcxx;libcxxabi;libunwind" \
           -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
 
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 new-standalone)
     clean
 
     echo "--- Generating CMake"
     ${CMAKE} \
           -S "${MONOREPO_ROOT}/runtimes" \
           -B "${BUILD_DIR}" \
           -GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}" \
           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
           -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
 
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 runtimes-build)
     clean
 
     echo "--- Generating CMake"
     # TODO: We currently enable modules and assertions in the runtimes build
     #       because that provides coverage for some specific Clang failures
     #       we've been seeing recently, however it would be better to instead
runtimes-build)
     ${NINJA} -C "${BUILD_DIR}" check-runtimes
 
     echo "--- Installing libc++ and libc++abi to a fake location"
     ${NINJA} -C "${BUILD_DIR}" install-runtimes
 ;;
 legacy-test-config)
     clean
     generate-cmake -DLIBCXX_TEST_CONFIG="legacy.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 legacy-standalone)
     clean
 
     echo "--- Generating CMake"
     ${CMAKE} \
           -S "${MONOREPO_ROOT}/libcxx" \
           -B "${BUILD_DIR}/libcxx" \
legacy-standalone)
 
     echo "+++ Running the libc++abi tests"
     ${NINJA} -vC "${BUILD_DIR}/libcxxabi" check-cxxabi
 ;;
 aarch64)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/AArch64.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 aarch64-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/AArch64.cmake" \
                    -DLIBCXX_ENABLE_EXCEPTIONS=OFF \
                    -DLIBCXXABI_ENABLE_EXCEPTIONS=OFF \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 # Aka Armv8 32 bit
 armv8)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv8Arm.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 armv8-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv8Thumb-noexceptions.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 # Armv7 32 bit. One building Arm only one Thumb only code.
 armv7)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv7Arm.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 armv7-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv7Thumb-noexceptions.cmake" \
                    -DLIBCXX_TEST_CONFIG="llvm-libc++-shared.cfg.in"
-    check-cxx-cxxabi
+    check-runtimes
 ;;
 windows-dll)
     clean
     # TODO: Currently, building with the experimental library breaks running
     # tests (the test linking look for the c++experimental library with the
     # wrong name, and the statically linked c++experimental can't be linked
     # correctly when libc++ visibility attributes indicate dllimport linkage
     # anyway), thus just disable the experimental library. Remove this

libcxx/utils/libcxx/test/params.py

Parameter(name='enable_debug_tests', choices=[True, False], type=bool, default=True,
             actions=lambda enabled: [] if enabled else [
               AddFeature('libcxx-no-debug-mode')
             ]),
 
   Parameter(name='enable_32bit', choices=[True, False], type=bool, default=False,
             help="Whether to build the test suite in 32 bit mode even on a 64 bit target. This basically controls "
                  "whether -m32 is used when building the test suite.",
             actions=lambda enabled: [] if not enabled else [
-              AddFlag('-m32')
+              AddFlag('-m32'),
+              AddFeature('32bits-on-64bits')
             ]),
 
   Parameter(name='additional_features', type=list, default=[],
             help="A comma-delimited list of additional features that will be enabled when running the tests. "
                  "This should be used sparingly since specifying ad-hoc features manually is error-prone and "
                  "brittle in the long run as changes are made to the test suite.",
             actions=lambda features: [AddFeature(f) for f in features]),
 ]

libunwind/test/forceunwind.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: linux
 
+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 // Basic test for _Unwind_ForcedUnwind.
 // See libcxxabi/test/forced_unwind* tests too.
 
 #include <assert.h>
 #include <dlfcn.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>

libunwind/test/frameheadercache_test.pass.cpp

+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 // The other libunwind tests don't test internal interfaces, so the include path
 // is a little wonky.
 #include "../src/config.h"
 
 // Only run this test under supported configurations.
 
 #if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) &&                                 \
     defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)

libunwind/test/libunwind_01.pass.cpp

+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate these failures on x86_64 macOS
+// XFAIL: target=x86_64-apple-darwin{{.+}}
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 #include <libunwind.h>
 #include <stdlib.h>
 #include <string.h>
 
 void backtrace(int lower_bound) {
   unw_context_t context;
   unw_getcontext(&context);
 

libunwind/test/libunwind_02.pass.cpp

+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 #include <assert.h>
 #include <stdlib.h>
 #include <unwind.h>
 
 #define EXPECTED_NUM_FRAMES 50
 #define NUM_FRAMES_UPPER_BOUND 100
 
 _Unwind_Reason_Code callback(_Unwind_Context *context, void *cnt) {

libunwind/test/remember_state_leak.pass.sh.s

 # REQUIRES: target={{x86_64-.+-linux-gnu}}
 # RUN: %{build}
 # RUN: %{run}
 
+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
+# TODO: Investigate this failure on GCC.
+# XFAIL: gcc
+
 # The following assembly is a translation of this code:
 #
 #   _Unwind_Reason_Code callback(int, _Unwind_Action, long unsigned int,
 #                                _Unwind_Exception*, _Unwind_Context*, void*) {
 #     return _Unwind_Reason_Code(0);
 #   }
 #
 #   int main() {

libunwind/test/signal_frame.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Ensure that functions marked as signal frames are reported as such.
 
+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure on macOS
+// XFAIL: target={{.+}}-apple-darwin{{.+}}
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 // UNSUPPORTED: libunwind-arm-ehabi
 
 #include <assert.h>
 #include <stdlib.h>
 #include <libunwind.h>
 
 void test() {
   asm(".cfi_signal_frame");

libunwind/test/signal_unwind.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Ensure that the unwinder can cope with the signal handler.
 // REQUIRES: linux && (target={{aarch64-.+}} || target={{x86_64-.+}})
 
+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 #include <assert.h>
 #include <dlfcn.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>

libunwind/test/unw_getcontext.pass.cpp

+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
 #include <assert.h>
 #include <libunwind.h>
 
 int main(int, char**) {
   unw_context_t context;
   int ret = unw_getcontext(&context);
   assert(ret == UNW_ESUCCESS);
   return 0;
 }

libunwind/test/unwind_leaffunction.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Ensure that leaf function can be unwund.
 // REQUIRES: linux && (target={{aarch64-.+}} || target={{x86_64-.+}})
 
+// TODO: Investigate these failures
+// XFAIL: asan, tsan, ubsan
+
+// TODO: Investigate this failure
+// XFAIL: 32bits-on-64bits
+
 #include <assert.h>
 #include <dlfcn.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
__attribute__((noinline)) void crashing_leaf_func(void) {
   *faultyPointer = 0;
 }
 
 int main(int, char**) {
   signal(SIGSEGV, signal_handler);
   crashing_leaf_func();
   return -2;
 }
 No newline at end of file