[libunwind] Fix test execution.

[danielkiss]

Summary

Tests and libunwind are not dependent libcxxabi except
in case of a santizer is in use.
Signal frame is only supported on elf/dwarf based systems.
To build 32bit on a 64bit systems gcc\g++-multilib packages are needed.

[arichardson]

libunwind/test/signal_frame.pass.cpp

11

Shouldn't this also work on other ELF+DWARF platforms, e.g. FreeBSD?

[arichardson]

libunwind/test/libunwind/test/config.py

71

Why do we need the C++ library?

I can see the following issue:

$ nm -D -u /usr/lib/gcc/x86_64-linux-gnu/7/libasan.so
                 U _Unwind_Backtrace
                 U _Unwind_GetIP

readelf --dynamic /usr/lib/gcc/x86_64-linux-gnu/7/libasan.so

Dynamic section at offset 0x151550 contains 31 entries:
  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libdl.so.2]
 0x0000000000000001 (NEEDED)             Shared library: [librt.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libpthread.so.0]
 0x0000000000000001 (NEEDED)             Shared library: [libm.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libgcc_s.so.1]
 0x000000000000000e (SONAME)             Library soname: [libasan.so.4]

And on Ubuntu clang's libclang-rt even links against libstdc++...

$ readelf --dynamic /usr/lib/clang/10/lib/linux/libclang_rt.asan-x86_64.so
 0x0000000000000001 (NEEDED)             Shared library: [libstdc++.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libgcc_s.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libdl.so.2]
 0x0000000000000001 (NEEDED)             Shared library: [librt.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libm.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libpthread.so.0]
 0x000000000000000e (SONAME)             Library soname: [libclang_rt.asan-x86_64.so]

Is that the problem?
I don't think we should be linking against the C++ library since that might pull in another unwind library.

[danielkiss]

libunwind/test/libunwind/test/config.py

71

in case of the asan build the static library is used ... --whole-archive /usr/lib/llvm-13/lib/clang/13.0.0/lib/linux/libclang_rt.asan_cxx-x86_64.a ...
It depends on typeinfo for std::type_info,typeinfo for __cxxabiv1::__class_type_info, __dynamic_cast... and so on.
just adding libcxxabi.a seems enough.

libunwind/test/lit.site.cfg.in

8

libunwind/test/signal_frame.pass.cpp

11

Correct it should work on FreeBSD too but right now the libuninwd's tests are broken there because the test always links to libgcc_s so the test won't call libunwind actually.
I will look at this later.

[danielkiss]

check-unwind tested on freebsd14/aarch64 too.

[danielkiss]

Fix gcc build.

[danielkiss]

generic-32bit config won't be green until the docker image is rebuilt.

[danielkiss]

libunwind/test/signal_frame.pass.cpp

12

// REQUIRES: linux || freebsd

[danielkiss]

fixed in other changes.

libcxx/utils/ci/Dockerfile

 # Install clang-format
 RUN apt-get install -y clang-format-$LLVM_LATEST_VERSION
 RUN ln -s /usr/bin/clang-format-$LLVM_LATEST_VERSION /usr/bin/clang-format && [ -e $(readlink /usr/bin/clang-format) ]
 RUN ln -s /usr/bin/git-clang-format-$LLVM_LATEST_VERSION /usr/bin/git-clang-format && [ -e $(readlink /usr/bin/git-clang-format) ]
 
 # Install the most recent GCC
 ENV GCC_LATEST_VERSION=11
 RUN add-apt-repository ppa:ubuntu-toolchain-r/test
-RUN apt-get update && apt install -y gcc-$GCC_LATEST_VERSION g++-$GCC_LATEST_VERSION
+RUN apt-get update && apt install -y gcc-$GCC_LATEST_VERSION g++-$GCC_LATEST_VERSION gcc-$GCC_LATEST_VERSION-multilib g++-$GCC_LATEST_VERSION-multilib
 
 # Install a recent CMake
 RUN wget https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-linux-x86_64.sh -O /tmp/install-cmake.sh
 RUN bash /tmp/install-cmake.sh --prefix=/usr --exclude-subdir --skip-license
 RUN rm /tmp/install-cmake.sh
 
 # Change the user to a non-root user, since some of the libc++ tests
 # (e.g. filesystem) require running as non-root. Also setup passwordless sudo.

libcxx/utils/libcxx/test/target_info.py

def allow_cxxabi_link(self):
         return False
 
 
 class FreeBSDLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(FreeBSDLocalTI, self).__init__(full_config)
 
     def add_cxx_link_flags(self, flags):
-        flags += ['-lc', '-lm', '-lpthread', '-lgcc_s', '-lcxxrt']
+        flags += ['-lc', '-lm', '-lpthread', '-lcxxrt']
+        llvm_unwinder = self.full_config.get_lit_bool('llvm_unwinder', False)
+        if llvm_unwinder:
+            flags += ['-lunwind', '-ldl']
+        else:
+            flags += ['-lgcc_s']
 
 
 class NetBSDLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(NetBSDLocalTI, self).__init__(full_config)
 
     def add_cxx_link_flags(self, flags):
         flags += ['-lc', '-lm', '-lpthread', '-lgcc_s', '-lc++abi',

libunwind/test/floatregister.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 && target={{aarch64-.+}}
+// REQUIRES: (linux || freebsd) && target={{aarch64-.+}}
 
 // Basic test for float registers number are accepted.
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unwind.h>
 

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
+// REQUIRES: linux || freebsd
 
 // Basic test for _Unwind_ForcedUnwind.
 // See libcxxabi/test/forced_unwind* tests too.
 
 #include <assert.h>
 #include <dlfcn.h>
 #include <signal.h>
 #include <stdint.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/test/config.py

class Configuration(LibcxxConfiguration):
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += ['-DLIBUNWIND_NO_TIMER']
         # Stack unwinding tests need unwinding tables and these are not
         # generated by default on all Targets.
         self.cxx.compile_flags += ['-funwind-tables']
         # Make symbols available in the tests.
         triple = self.get_lit_conf('target_triple', None)
-        if triple is not None and 'linux' in triple:
+        if triple is not None and ('linux' in triple or 'freebsd' in triple):
             self.cxx.link_flags += ['-Wl,--export-dynamic']
         if not self.get_lit_bool('enable_threads', True):
             self.cxx.compile_flags += ['-D_LIBUNWIND_HAS_NO_THREADS']
             self.config.available_features.add('libunwind-no-threads')
         if self.get_lit_bool('x86_cet', False):
             self.cxx.compile_flags += ['-fcf-protection=full']
         super(Configuration, self).configure_compile_flags()
 
     def configure_compile_flags_header_includes(self):
         libunwind_headers = self.get_lit_conf(
             'libunwind_headers',
             os.path.join(self.libunwind_src_root, 'include'))
         if not os.path.isdir(libunwind_headers):
             self.lit_config.fatal("libunwind_headers='%s' is not a directory."
                                   % libunwind_headers)
         self.cxx.compile_flags += ['-I' + libunwind_headers]
 
     def configure_link_flags_cxx_library(self):
         # libunwind tests should not link with libc++
         pass
 
     def configure_link_flags_abi_library(self):
-        # libunwind tests should not link with libc++abi
-        pass
+        # libunwind tests should not link with libcabi++ except when a sanitizer is used.
+        sanitizers = getattr(self.config, 'use_sanitizer', None)
+        if sanitizers is not None:
+            super().configure_link_flags_abi_library()
+            if 'Thread' in  sanitizers:
+                # -fsanitize=thread depends on __gcc_personality_v0
+                self.cxx.link_flags += ['-lgcc_s']

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);
 
void test_reg_names() {
   unw_cursor_t cursor;
   unw_init_local(&cursor, &context);
 
   int max_reg_num = -100;
 #if defined(__i386__)
   max_reg_num = 7;
 #elif defined(__x86_64__)
   max_reg_num = 32;
+#elif defined(__aarch64__)
+  max_reg_num = 32;
 #endif
 
   const char prefix[] = "unknown";
   for (int i = -2; i < max_reg_num; ++i) {
     if (strncmp(prefix, unw_regname(&cursor, i), sizeof(prefix) - 1) == 0)
       abort();
   }
 

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/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 
 @SERIALIZED_LIT_PARAMS@
 
 import os
+import platform
+import pipes
 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_root         = "@LIBUNWIND_LIBRARY_DIR@"
 config.libcxx_src_root          = "@LIBUNWIND_LIBCXX_PATH@"
 config.libunwind_headers        = "@LIBUNWIND_SOURCE_DIR@/include"

 config.suffixes = ['.cpp', '.s']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.join(config.libunwind_src_root, 'test')
 
 # Allow expanding substitutions that are based on other substitutions
 config.recursiveExpansionLimit = 10
 
+if platform.system() == 'Darwin':
+  config.substitutions.append(('%{exec}',
+      '{} --execdir %T --env DYLD_LIBRARY_PATH={} -- '.format(
+          config.executor,
+          pipes.quote(config.abi_library_root))
+  ))
+
 # Infer the test_exec_root from the build directory.
 config.test_exec_root = os.path.join(config.libunwind_obj_root, 'test')
 
 import libcxx.test.format
 config.test_format = libcxx.test.format.CxxStandardLibraryTest()
 
 lit_config.note('Using configuration variant: libunwind')
 import libunwind.test.config
 configuration = libunwind.test.config.Configuration(lit_config, config)
 configuration.configure()
 configuration.print_config_info()

libunwind/test/remember_state_leak.pass.sh.s

 # REQUIRES: target={{x86_64-.+-linux-gnu}}
+# UNSUPPORTED: 32bits-on-64bits
 # 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() {
main:                                   # @main
     .cfi_startproc
     subq    $8, %rsp   # Adjust stack alignment
     subq    $SIZEOF_UNWIND_EXCEPTION, %rsp
     .cfi_def_cfa_offset 48
     .cfi_remember_state
     movq    %rsp, %rdi
     movabsq $callback, %rsi
     xorl    %edx, %edx
-    callq    _Unwind_ForcedUnwind
+    callq   *_Unwind_ForcedUnwind@GOTPCREL(%rip)
     .cfi_restore_state
     xorl    %eax, %eax
     addq    $SIZEOF_UNWIND_EXCEPTION, %rsp
     addq    $8, %rsp   # Undo stack alignment adjustment
     .cfi_def_cfa_offset 8
     retq
 .Lfunc_end1:
     .size    main, .Lfunc_end1-main
     .cfi_endproc
                                         # -- End function

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
-
+// cfi_signal_frame is only supported on DWARF based systems.
+// REQUIRED: linux || freebsd
 // 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>

 void signal_handler(int signum) {
   (void)signum;
   _Unwind_Backtrace(frame_handler, NULL);
   _Exit(-1);
 }
 
 int* faultyPointer = NULL;
 
-__attribute__((noinline)) void crashing_leaf_func(void) {
+__attribute__((noinline,no_sanitize("undefined"))) 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