[libc++abi] Fix fallback allocator alignment issue

[miyuki]

Summary

Currently, the libc++abi fallback memory allocator only guarantees
4-byte alignment even on 64-bit systems. This causes failures
(hardware exceptions due to misalignment) on bare-metal AArch64.

The patch fixes the issue by increasing the heap block size to 8
bytes on 64-bit systems.

[ldionne]

Just to confirm my understanding, basically this only triggers when malloc(...) returns nullptr, i.e. when memory is exhausted, right?

libcxxabi/src/fallback_malloc.cpp

76–77

This is perhaps silly, but I'm not sure I understand why changing the representation of the offset and size is what we want to do here. Shouldn't we instead be adjusting the pointer we are returning when we allocate memory to have the proper alignment?

In other words, this patch has the side effect that we'll return properly aligned memory, however we could technically keep the same representation as before and also return aligned memory, right?

[miyuki]

In D123511#3442895, @ldionne wrote:

Just to confirm my understanding, basically this only triggers when malloc(...) returns nullptr, i.e. when memory is exhausted, right?

Yes, that's correct.

[miyuki]

libcxxabi/src/fallback_malloc.cpp

76–77

Right. I found an existing patch that seems to do the right thing: https://reviews.llvm.org/D12669. Should we revive it?

[ldionne]

libcxxabi/src/fallback_malloc.cpp

76–77

Very interesting! Yes, I would definitely support reviving that patch!

[simon_tatham]

I've just uploaded D129842, an updated version of D12669.

[miyuki]

Abandoning in favor of D129842.

libcxxabi/src/fallback_malloc.cpp

 #ifndef _LIBCXXABI_HAS_NO_THREADS
   std::__libcpp_mutex_t* mtx_;
 #endif
 };
 
 static const size_t HEAP_SIZE = 512;
 char heap[HEAP_SIZE] __attribute__((aligned));
 
-typedef unsigned short heap_offset;
-typedef unsigned short heap_size;
+template<size_t S>
+struct half_size_uint;
+
+template<>
+struct half_size_uint<8> {
+  typedef unsigned int type;
+};
+
+template<>
+struct half_size_uint<4> {
+  typedef unsigned short type;
+};
+
+typedef half_size_uint<sizeof(void*)>::type heap_offset;
+typedef half_size_uint<sizeof(void*)>::type heap_size;
 
 struct heap_node {
   heap_offset next_node; // offset into heap
   heap_size len;         // size in units of "sizeof(heap_node)"
 };
 
 static const heap_node* list_end =
     (heap_node*)(&heap[HEAP_SIZE]); // one past the end of the heap

libcxxabi/test/test_fallback_malloc.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
 //
 //===----------------------------------------------------------------------===//
 
+#include <cassert>
 #include <cstdio>
 #include <deque>
 
 #include <__threading_support>
 
 typedef std::deque<void *> container;
 
 // #define  DEBUG_FALLBACK_MALLOC
int main () {
     char *p = (char *) fallback_malloc ( 1024 );    // too big!
     std::printf("fallback_malloc ( 1024 ) --> %lu\n", (unsigned long ) p);
     print_free_list ();
 
     p = (char *) fallback_malloc ( 32 );
     std::printf("fallback_malloc ( 32 ) --> %lu\n", (unsigned long) (p - heap));
     if ( !is_fallback_ptr ( p ))
         std::printf("### p is not a fallback pointer!!\n");
+    assert(((intptr_t)p % sizeof(void *) == 0)
+           && "p must be aligned as sizeof(void*)");
 
     print_free_list ();
     fallback_free ( p );
     print_free_list ();
 
     exhaustion_test1();
     exhaustion_test2();
     exhaustion_test3();
     return 0;
 }