[libcxxabi] Fix alignment of allocated exceptions in 32 bit builds

[EricWF]

Summary

In 32 bit builds on a 64 bit system std::malloc does not return correctly aligned memory. This leads to undefined behavior.

This patch switches to using posix_memalign to allocate correctly aligned memory instead.

[compnerd]

I thought we had gotten this merged already. Oops. LGTM with the minor tweak for windows.

src/fallback_malloc.cpp

214

Given that libc++abi has some Windows support and usage (e.g. MinGW), we should change this to:

void *dest;
#if defined(_WIN32)
  if ((dest = _aligned_malloc(size, alignof(__aligned_type)) == nullptr)
    return fallback_malloc(size);
  return dest;
#else
  if (::posix_memalign(&dest, alignof(__aligned_type), size) == 0)
    return dest;
  return fallback_malloc(size);
#endif

[EricWF]

• Use _aligned_malloc on windows.
• Ensure posix_memalign isn't called with a size of 0. I'm 99% sure that's currently impossible but we might as well handle it.

I'll commit after testing on OS X.

[EricWF]

I ran into some test failures on OS X while attempting to commit this. The unwind.h header provided on OS X hasn't upstreamed the libunwind fix from r276215, meaning __cxa_exception is still under-aligned and therefore so is the exception.

I'll commit this in the next day or two after dealing with the apple bug.

[EricWF]

Merge with master

src/cxa_exception.cpp

 static
 inline
 __cxa_exception*
 cxa_exception_from_exception_unwind_exception(_Unwind_Exception* unwind_exception)
 {
     return cxa_exception_from_thrown_object(unwind_exception + 1 );
 }
 
-static
-inline
-size_t
-cxa_exception_size_from_exception_thrown_size(size_t size)
-{
-    return size + sizeof (__cxa_exception);
+// Round s up to next multiple of a.
+static inline
+size_t aligned_allocation_size(size_t s, size_t a) {
+    return (s + a - 1) & ~(a - 1);
+}
+
+static inline
+size_t cxa_exception_size_from_exception_thrown_size(size_t size) {
+    return aligned_allocation_size(size + sizeof (__cxa_exception),
+                                   alignof(__cxa_exception));
 }
 
 static void setExceptionClass(_Unwind_Exception* unwind_exception) {
     unwind_exception->exception_class = kOurExceptionClass;
 }
 
 static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) {
     unwind_exception->exception_class = kOurDependentExceptionClass;

 //  Allocate a __cxa_exception object, and zero-fill it.
 //  Reserve "thrown_size" bytes on the end for the user's exception
 //  object. Zero-fill the object. If memory can't be allocated, call
 //  std::terminate. Return a pointer to the memory to be used for the
 //  user's exception object.
 void *__cxa_allocate_exception(size_t thrown_size) throw() {
     size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size);
     __cxa_exception *exception_header =
-        static_cast<__cxa_exception *>(__malloc_with_fallback(actual_size));
+        static_cast<__cxa_exception *>(__aligned_malloc_with_fallback(actual_size));
     if (NULL == exception_header)
         std::terminate();
     std::memset(exception_header, 0, actual_size);
     return thrown_object_from_cxa_exception(exception_header);
 }
 
 
 //  Free a __cxa_exception object allocated with __cxa_allocate_exception.
 void __cxa_free_exception(void *thrown_object) throw() {
-    __free_with_fallback(cxa_exception_from_thrown_object(thrown_object));
+    __aligned_free_with_fallback(cxa_exception_from_thrown_object(thrown_object));
 }
 
 
 //  This function shall allocate a __cxa_dependent_exception and
 //  return a pointer to it. (Really to the object, not past its' end).
 //  Otherwise, it will work like __cxa_allocate_exception.
 void * __cxa_allocate_dependent_exception () {
     size_t actual_size = sizeof(__cxa_dependent_exception);
-    void *ptr = __malloc_with_fallback(actual_size);
+    void *ptr = __aligned_malloc_with_fallback(actual_size);
     if (NULL == ptr)
         std::terminate();
     std::memset(ptr, 0, actual_size);
     return ptr;
 }
 
 
 //  This function shall free a dependent_exception.
 //  It does not affect the reference count of the primary exception.
 void __cxa_free_dependent_exception (void * dependent_exception) {
-    __free_with_fallback(dependent_exception);
+    __aligned_free_with_fallback(dependent_exception);
 }
 
 
 // 2.4.3 Throwing the Exception Object
 /*
 After constructing the exception object with the throw argument value,
 the generated code calls the __cxa_throw runtime library routine. This
 routine never returns.

src/fallback_malloc.h

 #define _FALLBACK_MALLOC_H
 
 #include "__cxxabi_config.h"
 #include <cstddef> // for size_t
 
 namespace __cxxabiv1 {
 
 // Allocate some memory from _somewhere_
-_LIBCXXABI_HIDDEN void * __malloc_with_fallback(size_t size);
+_LIBCXXABI_HIDDEN void * __aligned_malloc_with_fallback(size_t size);
 
 // Allocate and zero-initialize memory from _somewhere_
 _LIBCXXABI_HIDDEN void * __calloc_with_fallback(size_t count, size_t size);
 
+_LIBCXXABI_HIDDEN void __aligned_free_with_fallback(void *ptr);
 _LIBCXXABI_HIDDEN void __free_with_fallback(void *ptr);
 
 } // namespace __cxxabiv1
 
 #endif

src/fallback_malloc.cpp

size_t print_free_list () {
     std::cout << "Total Free space: " << total_free << std::endl;
     return total_free;
     }
 #endif
 }  // end unnamed namespace
 
 namespace __cxxabiv1 {
 
-void * __malloc_with_fallback(size_t size) {
-    void *ptr = std::malloc(size);
-    if (NULL == ptr) // if malloc fails, fall back to emergency stash
-        ptr = fallback_malloc(size);
-    return ptr;
+struct __attribute__((aligned)) __aligned_type  {};
+
+void * __aligned_malloc_with_fallback(size_t size) {
+#if defined(_WIN32)
+    if (void *dest = _aligned_malloc(size, alignof(__aligned_type)))
+      return dest;
+#elif defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
+    if (void* dest = std::malloc(size))
+      return dest;
+#else
+    if (size == 0)
+        size = 1;
+    void* dest;
+    if (::posix_memalign(&dest, alignof(__aligned_type), size) == 0)
+        return dest;
+#endif
+    return fallback_malloc(size);
 }
 
+
 void * __calloc_with_fallback(size_t count, size_t size) {
     void *ptr = std::calloc(count, size);
     if (NULL != ptr)
         return ptr;
     // if calloc fails, fall back to emergency stash
     ptr = fallback_malloc(size * count);
     if (NULL != ptr)
         std::memset(ptr, 0, size * count);
     return ptr;
 }
 
+void __aligned_free_with_fallback(void* ptr) {
+  if (is_fallback_ptr(ptr))
+        fallback_free(ptr);
+  else {
+#if defined(_WIN32)
+        ::_aligned_free(ptr);
+#else
+        std::free(ptr);
+#endif
+  }
+}
+
 void __free_with_fallback(void *ptr) {
     if (is_fallback_ptr(ptr))
         fallback_free(ptr);
     else
         std::free(ptr);
 }
 
 } // namespace __cxxabiv1

test/test_exception_address_alignment.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Test that the address of the exception object is properly aligned to the
+// largest supported alignment for the system.
+
+#include <cstdint>
+#include <cassert>
+
+struct __attribute__((aligned)) AlignedType {};
+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);
+    }
+  }
+}