[libcxxabi] Fix exception address alignment test for EHABI

[rmaprath]

Summary

This test was failing on our downstream (bare-metal) runs and only now I got around to investigate it.

The problem is, this test assumes the Itanium ABI, whereas EHABI requires the exception address to be 8-byte aligned.

I was a bit puzzled at first because this should've failed on the public arm-linux builder too. I think the reason it passes there is because we don't include libunwind headers in the include path when running the libcxxabi tests, so the system unwind.h gets picked up.

[rmaprath]

Fixed a few paths.

[rengolin]

This looks like a simple oversight from my perspective, so looks good.

But I'll let the others have a look at it, as I'm not overly familiar with libcxxabi.

cheers,
--renato

[EricWF]

For the most part this LGTM other than the nits mentioned.

test/libcxxabi/test/config.py

34 ↗

(On Diff #92450)

I think the correct default here is None, not ../libunwind/src, since we might not be using libunwind at all.

93 ↗

(On Diff #92450)

I'm not sure if this is default is optimal. I think None might be less surprising.

test/lit.site.cfg.in

9 ↗

(On Diff #92450)

I don't think we need the unwind sources anywhere within the test suite. I would remove this option all together and simply depend on libunwind_headers.

10 ↗

(On Diff #92450)

I think libunwind_headers should be the empty string when LIBCXXABI_LIBUNWIND_INCLUDE_INTERNAL has not been found, instead of expanding to "LIBCXXABI_LIBUNWIND_INCLUDE_INTERNAL-NOTFOUND"

test/test_exception_address_alignment.pass.cpp

30 ↗

(On Diff #92450)

Shouldn't this be an #ifdef?

[rmaprath]

Addressed review comments from @EricWF .

libcxxabi/trunk/CMakeLists.txt

find_path(
     NO_DEFAULT_PATH
   )
 
   if (LIBCXXABI_LIBUNWIND_SOURCES STREQUAL "LIBCXXABI_LIBUNWIND_SOURCES-NOTFOUND")
     message(WARNING "LIBCXXABI_LIBUNWIND_SOURCES was not specified and couldn't be infered.")
     set(LIBCXXABI_LIBUNWIND_SOURCES "")
   endif()
 
-  if (NOT LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL STREQUAL "LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL-NOTFOUND")
+  if (LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL STREQUAL "LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL-NOTFOUND")
+    set(LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL "")
+  endif()
+
+  if (NOT LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL STREQUAL "")
     include_directories("${LIBCXXABI_LIBUNWIND_INCLUDES_INTERNAL}")
   endif()
+
   if (NOT LIBCXXABI_LIBUNWIND_SOURCES STREQUAL "")
     include_directories("${LIBCXXABI_LIBUNWIND_SOURCES}")
   endif()
 endif()
 
 # Add source code. This also contains all of the logic for deciding linker flags
 # soname, etc...
 add_subdirectory(src)

libcxxabi/trunk/test/libcxxabi/test/config.py

def configure_compile_flags_header_includes(self):
         libcxxabi_headers = self.get_lit_conf(
             'libcxxabi_headers',
             os.path.join(self.libcxxabi_src_root, 'include'))
         if not os.path.isdir(libcxxabi_headers):
             self.lit_config.fatal("libcxxabi_headers='%s' is not a directory."
                                   % libcxxabi_headers)
         self.cxx.compile_flags += ['-I' + libcxxabi_headers]
 
+        libunwind_headers = self.get_lit_conf('libunwind_headers', None)
+        if self.get_lit_bool('llvm_unwinder', False) and libunwind_headers:
+            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_compile_flags_exceptions(self):
         pass
 
     def configure_compile_flags_rtti(self):
         pass

libcxxabi/trunk/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 config.cxx_under_test           = "@LIBCXXABI_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.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.enable_threads           = "@LIBCXXABI_ENABLE_THREADS@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.enable_32bit             = "@LIBCXXABI_BUILD_32_BITS@"
 config.target_info              = "@LIBCXXABI_TARGET_INFO@"
 config.executor                 = "@LIBCXXABI_EXECUTOR@"
 config.libcxxabi_shared         = "@LIBCXXABI_ENABLE_SHARED@"

libcxxabi/trunk/test/test_exception_address_alignment.pass.cpp

 // UNSUPPORTED: libcxxabi-no-exceptions
 // UNSUPPORTED: c++98, c++03
 
 // The system unwind.h on OS X provides an incorrectly aligned _Unwind_Exception
 // type. That causes these tests to fail. This XFAIL is my best attempt at
 // working around this failure.
 // XFAIL: darwin && libcxxabi-has-system-unwinder
 
-// Test that the address of the exception object is properly aligned to the
-// largest supported alignment for the system.
+// Test that the address of the exception object is properly aligned as required
+// by the relevant ABI
 
 #include <cstdint>
 #include <cassert>
 
 #include <unwind.h>
 
 struct __attribute__((aligned)) AlignedType {};
-static_assert(alignof(AlignedType) == alignof(_Unwind_Exception),
+
+// EHABI  : 8-byte aligned
+// Itanium: Largest supported alignment for the system
+#if defined(_LIBUNWIND_ARM_EHABI)
+#  define EXPECTED_ALIGNMENT 8
+#else
+#  define EXPECTED_ALIGNMENT alignof(AlignedType)
+#endif
+
+static_assert(alignof(_Unwind_Exception) == EXPECTED_ALIGNMENT,
   "_Unwind_Exception is incorrectly aligned. This test is expected to fail");
 
 struct MinAligned {  };
 static_assert(alignof(MinAligned) == 1 && sizeof(MinAligned) == 1, "");
 
 int main() {
   for (int i=0; i < 10; ++i) {
     try {
       throw MinAligned{};
     } catch (MinAligned const& ref) {
-      assert(reinterpret_cast<uintptr_t>(&ref) % alignof(AlignedType) == 0);
+      assert(reinterpret_cast<uintptr_t>(&ref) % EXPECTED_ALIGNMENT == 0);
     }
   }
 }