[libc++abi] Use fallback_malloc to allocate __cxa_eh_globals in case of dynamic memory exhaustion.

[ikudrin]

Summary

Throwing an exception for the first time may lead to calling calloc to allocate memory for __cxa_eh_globals. If the memory pool is exhausted at that moment, it results in abnormal termination of the program.

This patch addresses the issue by using fallback_malloc in that case.

[ikudrin]

Ping.

[ikudrin]

Ping?..

[bcraig]

LGTM. I don't know if that's good enough for a submit though :)

In my opinion, requiring heap allocation during an exception is one of the worst parts of the Itanium ABI. At least this particular path isn't triggered for platforms with true thread_local support.

[EricWF]

By including fallback_malloc.ipp in a new C++ file we now have 2 different OOM emergancy buffers. I think it would be preferable to use only one. This would require a fairly large restructuring of fallback_malloc.ipp though.

[ikudrin]

Thanks! I'll see what I can do about it.

[ikudrin]

Make cxa_exception.cpp and cxa_exception_storage.cpp to use the same emergency memory pool.

[ikudrin]

Ping...

[ikudrin]

Ping...

[ikudrin]

Ping! Could anyone check this patch, please?

[EricWF]

Could you generate a diff against the normal directory layout? Your's is against "libcxxabi/trunk/" where 'trunk' is the actual libcxxabi directory.

[ikudrin]

Regenerated the patch against project's root.

[EricWF]

It's almost there.

Please move "fallback_malloc.ipp" into "fallback_malloc.cpp" and then delete it all together. We can't have other files trying to include it.

src/fallback_malloc.cpp

24

I think we should have the pragma GCC visibility push(hidden) in this file as well, but I'm not 100% sure.

test/test_exception_storage_nodynmem.pass.cpp

14

Let's check that we actually replace calloc here and assert that our replacement has been called at the end of main.

17

Let's perform this test a couple of times so we're testing

• The memory get's returned properly
• The returned memory can be reused.

[ikudrin]

• Moved the content of fallback_malloc.ipp into falback_malloc.cpp.
• Removed fallback_malloc.ipp.
• Added pragma GCC visibility push(hidden) for the function's definitions.
• Added a check that the overwritten calloc is called to the test.
• Added a loop to run the test several times.

Please note that test_fallback_malloc.pass.cpp now has to #include fallback_malloc.cpp, because fallback_malloc.ipp was removed. I'd considered some other options, including declaring additional functions especially for testing purpose and even moving all fallback_malloc functionality into a separate class which could be tested independently. However, eventually, I found them more difficult and even much worse than the presented approach.

[ikudrin]

Ping...

[ikudrin]

Ping?..

[ikudrin]

Ping.

[ikudrin]

Ping...

This patch is under review for more than two months, and I believe I've addressed all the comments. Could someone take a look at it, please?

[ikudrin]

Hi,

Ping.

The issue in the current implementation of the libc++abi library looks like a time bomb. Even though its probability could be considered as very low, in fact, it depends on the type of an application. At least, we ran into it in our environment.

I'd guess that no one would expect their program to terminate when a legal exception is thrown, or when memory is allocated. I'd like this issue to be fixed in one or another way.

@EricWF, can you look at the patch again, please?

[ikudrin]

Ping...

[ikudrin]

Hi,

Ping.

The patch is under review for a long time and the described problem is still here. As we've seen the issue in practice, I'm sure that others may also run into it, and I do believe it should be fixed, one way or another.

@EricWF, can I improve the patch somehow to pass the review? Or maybe you prefer it to be fixed in some other way?

[EricWF]

LGTM after addressing the inline comments.

src/fallback_malloc.cpp

58

A static const variable would be better here.

59

This should have __attribute__((aligned)) on it.

src/fallback_malloc.h

20

Please don't use the __cxa prefix on these functions. It makes it seem like they are part of the Itanium spec but they're really internal details.

[rmaprath]

@ikudrin: Looks like you've reverted this soon after. I'm just about to commit D24864, which will affect this slightly. D24864 basically refactors all pthread dependencies behind a separate API. It would be pretty straightforward for you to update this patch though, just replacing pthread calls with ones in thread_support.h (perhaps adding anything missing).

Hope you don't mind me going first? If you are going to commit this soon, I can hold off D24864. Let me know.

Cheers,

/ Asiri

[ikudrin]

@rmaprath: There are some issues in the test which upset build bots and I need some time to fix them. You don't need to wait for me, I'll put my patch on the top of yours when my fix is ready.

src/CMakeLists.txt

 # Get sources
 set(LIBCXXABI_SOURCES
   abort_message.cpp
   cxa_aux_runtime.cpp
   cxa_default_handlers.cpp
   cxa_demangle.cpp
   cxa_exception.cpp
   cxa_exception_storage.cpp
   cxa_guard.cpp
   cxa_handlers.cpp
   cxa_new_delete.cpp
   cxa_personality.cpp
   cxa_unexpected.cpp
   cxa_vector.cpp
   cxa_virtual.cpp
   exception.cpp
+  fallback_malloc.cpp
   private_typeinfo.cpp
   stdexcept.cpp
   typeinfo.cpp
 )
 
 if (UNIX AND NOT (APPLE OR CYGWIN))
   list(APPEND LIBCXXABI_SOURCES cxa_thread_atexit.cpp)
 endif()

src/cxa_exception.cpp

 //  http://mentorembedded.github.io/cxx-abi/abi-eh.html
 //  
 //===----------------------------------------------------------------------===//
 
 #include "config.h"
 #include "cxxabi.h"
 
 #include <exception>        // for std::terminate
-#include <cstdlib>          // for malloc, free
 #include <cstring>          // for memset
-#if !LIBCXXABI_HAS_NO_THREADS
-#  include <pthread.h>      // for fallback_malloc.ipp's mutexes
-#endif
 #include "cxa_exception.hpp"
 #include "cxa_handlers.hpp"
+#include "fallback_malloc.h"
 
 // +---------------------------+-----------------------------+---------------+
 // | __cxa_exception           | _Unwind_Exception CLNGC++\0 | thrown object |
 // +---------------------------+-----------------------------+---------------+
 //                                                           ^
 //                                                           |
 //   +-------------------------------------------------------+
 //   |
static inline int incrementHandlerCount(__cxa_exception *exception) {
     return ++exception->handlerCount;
 }
 
 //  This does not need to be atomic
 static inline  int decrementHandlerCount(__cxa_exception *exception) {
     return --exception->handlerCount;
 }
 
-#include "fallback_malloc.ipp"
-
-//  Allocate some memory from _somewhere_
-static void *do_malloc(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;
-}
-
-static void do_free(void *ptr) {
-    is_fallback_ptr(ptr) ? fallback_free(ptr) : std::free(ptr);
-}
-
 /*
     If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
     stored in exc is called.  Otherwise the exceptionDestructor stored in 
     exc is called, and then the memory for the exception is deallocated.
 
     This is never called for a __cxa_dependent_exception.
 */
 static

 
 //  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.
 _LIBCXXABI_FUNC_VIS 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*>(do_malloc(actual_size));
+    __cxa_exception *exception_header =
+        static_cast<__cxa_exception *>(__cxa_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.
 _LIBCXXABI_FUNC_VIS void __cxa_free_exception(void *thrown_object) throw() {
-    do_free(cxa_exception_from_thrown_object(thrown_object));
+    __cxa_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 = do_malloc(actual_size);
+    void *ptr = __cxa_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) {
-    do_free(dependent_exception);
+    __cxa_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/cxa_exception_storage.cpp

extern "C" {
     __cxa_eh_globals * __cxa_get_globals      () { return __globals (); }
     __cxa_eh_globals * __cxa_get_globals_fast () { return __globals (); }
     }
 }
 
 #else
 
 #include <pthread.h>
-#include <cstdlib>          // for calloc, free
 #include "abort_message.h"
+#include "fallback_malloc.h"
 
 //  In general, we treat all pthread errors as fatal.
 //  We cannot call std::terminate() because that will in turn
 //  call __cxa_get_globals() and cause infinite recursion.
 
 namespace __cxxabiv1 {
 namespace {
     pthread_key_t  key_;
     pthread_once_t flag_ = PTHREAD_ONCE_INIT;
 
     void destruct_ (void *p) {
-        std::free ( p );
+        __cxa_free_with_fallback ( p );
         if ( 0 != ::pthread_setspecific ( key_, NULL ) ) 
             abort_message("cannot zero out thread value for __cxa_get_globals()");
         }
 
     void construct_ () {
         if ( 0 != pthread_key_create ( &key_, destruct_ ) )
             abort_message("cannot create pthread key for __cxa_get_globals()");
         }
 }   
 
 extern "C" {
     __cxa_eh_globals * __cxa_get_globals () {
     //  Try to get the globals for this thread
         __cxa_eh_globals* retVal = __cxa_get_globals_fast ();
     
     //  If this is the first time we've been asked for these globals, create them
         if ( NULL == retVal ) {
             retVal = static_cast<__cxa_eh_globals*>
-                        (std::calloc (1, sizeof (__cxa_eh_globals)));
+                        (__cxa_calloc_with_fallback (1, sizeof (__cxa_eh_globals)));
             if ( NULL == retVal )
                 abort_message("cannot allocate __cxa_eh_globals");
             if ( 0 != pthread_setspecific ( key_, retVal ) )
                abort_message("pthread_setspecific failure in __cxa_get_globals()");
            }
         return retVal;
         }
 

src/fallback_malloc.h

+//===------------------------- fallback_malloc.h --------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _FALLBACK_MALLOC_H
+#define _FALLBACK_MALLOC_H
+
+#include <cstddef> // for size_t
+
+namespace __cxxabiv1 {
+
+#pragma GCC visibility push(hidden)
+
+// Allocate some memory from _somewhere_
+void * __cxa_malloc_with_fallback(size_t size);
+
+// Allocate and zero-initialize memory from _somewhere_
+void * __cxa_calloc_with_fallback(size_t count, size_t size);
+
+void __cxa_free_with_fallback(void *ptr);
+
+#pragma GCC visibility pop
+
+} // namespace __cxxabiv1
+
+#endif

src/fallback_malloc.cpp

+//===------------------------ fallback_malloc.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "fallback_malloc.h"
+
+#include "config.h"
+
+#include <cstdlib> // for malloc, calloc, free
+#include <cstring> // for memset
+
+#if !LIBCXXABI_HAS_NO_THREADS
+#include <pthread.h> // for fallback_malloc.ipp's mutexes
+#endif
+
+//  A small, simple heap manager based (loosely) on
+//  the startup heap manager from FreeBSD, optimized for space.
+//
+//  Manages a fixed-size memory pool, supports malloc and free only.
+//  No support for realloc.
+//
+//  Allocates chunks in multiples of four bytes, with a four byte header
+//  for each chunk. The overhead of each chunk is kept low by keeping pointers
+//  as two byte offsets within the heap, rather than (4 or 8 byte) pointers.
+
+namespace {
+
+// When POSIX threads are not available, make the mutex operations a nop
+#if LIBCXXABI_HAS_NO_THREADS
+static void * heap_mutex = 0;
+#else
+static pthread_mutex_t heap_mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+class mutexor {
+public:
+#if LIBCXXABI_HAS_NO_THREADS
+    mutexor ( void * ) {}
+    ~mutexor () {}
+#else
+    mutexor ( pthread_mutex_t *m ) : mtx_(m) { pthread_mutex_lock ( mtx_ ); }
+    ~mutexor () { pthread_mutex_unlock ( mtx_ ); }
+#endif
+private:
+    mutexor ( const mutexor &rhs );
+    mutexor & operator = ( const mutexor &rhs );
+#if !LIBCXXABI_HAS_NO_THREADS
+    pthread_mutex_t *mtx_;
+#endif
+    };
+
+
+#define HEAP_SIZE   512
+char heap [ HEAP_SIZE ];
+
+typedef unsigned short heap_offset;
+typedef unsigned short 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
+static heap_node *freelist = NULL;
+
+heap_node *node_from_offset ( const heap_offset offset )
+    { return (heap_node *) ( heap + ( offset * sizeof (heap_node))); }
+
+heap_offset offset_from_node ( const heap_node *ptr )
+    { return static_cast<heap_offset>(static_cast<size_t>(reinterpret_cast<const char *>(ptr) - heap)  / sizeof (heap_node)); }
+
+void init_heap () {
+    freelist = (heap_node *) heap;
+    freelist->next_node = offset_from_node ( list_end );
+    freelist->len = HEAP_SIZE / sizeof (heap_node);
+    }
+
+//  How big a chunk we allocate
+size_t alloc_size (size_t len)
+    { return (len + sizeof(heap_node) - 1) / sizeof(heap_node) + 1; }
+
+bool is_fallback_ptr ( void *ptr )
+    { return ptr >= heap && ptr < ( heap + HEAP_SIZE ); }
+
+void *fallback_malloc(size_t len) {
+    heap_node *p, *prev;
+    const size_t nelems = alloc_size ( len );
+    mutexor mtx ( &heap_mutex );
+
+    if ( NULL == freelist )
+        init_heap ();
+
+//  Walk the free list, looking for a "big enough" chunk
+    for (p = freelist, prev = 0;
+            p && p != list_end;     prev = p, p = node_from_offset ( p->next_node)) {
+
+        if (p->len > nelems) {  //  chunk is larger, shorten, and return the tail
+            heap_node *q;
+
+            p->len = static_cast<heap_size>(p->len - nelems);
+            q = p + p->len;
+            q->next_node = 0;
+            q->len = static_cast<heap_size>(nelems);
+            return (void *) (q + 1);
+        }
+
+        if (p->len == nelems) { // exact size match
+            if (prev == 0)
+                freelist = node_from_offset(p->next_node);
+            else
+                prev->next_node = p->next_node;
+            p->next_node = 0;
+            return (void *) (p + 1);
+        }
+    }
+    return NULL;    // couldn't find a spot big enough
+}
+
+//  Return the start of the next block
+heap_node *after ( struct heap_node *p ) { return p + p->len; }
+
+void fallback_free (void *ptr) {
+    struct heap_node *cp = ((struct heap_node *) ptr) - 1;      // retrieve the chunk
+    struct heap_node *p, *prev;
+
+    mutexor mtx ( &heap_mutex );
+
+#ifdef DEBUG_FALLBACK_MALLOC
+        std::cout << "Freeing item at " << offset_from_node ( cp ) << " of size " << cp->len << std::endl;
+#endif
+
+    for (p = freelist, prev = 0;
+            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
+#ifdef DEBUG_FALLBACK_MALLOC
+        std::cout << "  p, cp, after (p), after(cp) "
+            << offset_from_node ( p ) << ' '
+            << offset_from_node ( cp ) << ' '
+            << offset_from_node ( after ( p )) << ' '
+            << offset_from_node ( after ( cp )) << std::endl;
+#endif
+        if ( after ( p ) == cp ) {
+#ifdef DEBUG_FALLBACK_MALLOC
+            std::cout << "  Appending onto chunk at " << offset_from_node ( p ) << std::endl;
+#endif
+            p->len = static_cast<heap_size>(p->len + cp->len);  // make the free heap_node larger
+            return;
+            }
+        else if ( after ( cp ) == p ) { // there's a free heap_node right after
+#ifdef DEBUG_FALLBACK_MALLOC
+            std::cout << "  Appending free chunk at " << offset_from_node ( p ) << std::endl;
+#endif
+            cp->len = static_cast<heap_size>(cp->len + p->len);
+            if ( prev == 0 ) {
+                freelist = cp;
+                cp->next_node = p->next_node;
+                }
+            else
+                prev->next_node = offset_from_node(cp);
+            return;
+            }
+        }
+//  Nothing to merge with, add it to the start of the free list
+#ifdef DEBUG_FALLBACK_MALLOC
+            std::cout << "  Making new free list entry " << offset_from_node ( cp ) << std::endl;
+#endif
+    cp->next_node = offset_from_node ( freelist );
+    freelist = cp;
+}
+
+#ifdef INSTRUMENT_FALLBACK_MALLOC
+size_t print_free_list () {
+    struct heap_node *p, *prev;
+    heap_size total_free = 0;
+    if ( NULL == freelist )
+        init_heap ();
+
+    for (p = freelist, prev = 0;
+            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
+        std::cout << ( prev == 0 ? "" : "  ")  << "Offset: " << offset_from_node ( p )
+                << "\tsize: " << p->len << " Next: " << p->next_node << std::endl;
+        total_free += p->len;
+        }
+    std::cout << "Total Free space: " << total_free << std::endl;
+    return total_free;
+    }
+#endif
+}  // end unnamed namespace
+
+namespace __cxxabiv1 {
+
+#pragma GCC visibility push(hidden)
+
+void * __cxa_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;
+}
+
+void * __cxa_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 __cxa_free_with_fallback(void *ptr) {
+    if (is_fallback_ptr(ptr))
+        fallback_free(ptr);
+    else
+        std::free(ptr);
+}
+
+#pragma GCC visibility pop
+
+} // namespace __cxxabiv1

src/fallback_malloc.ipp

-//===------------------------ fallback_malloc.ipp -------------------------===//
-//
-//                     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.
-//
-//  
-//  This file implements the "Exception Handling APIs"
-//  http://mentorembedded.github.io/cxx-abi/abi-eh.html
-//  
-//===----------------------------------------------------------------------===//
-
-#include "config.h"
-
-//  A small, simple heap manager based (loosely) on 
-//  the startup heap manager from FreeBSD, optimized for space.
-//
-//  Manages a fixed-size memory pool, supports malloc and free only.
-//  No support for realloc.
-//
-//  Allocates chunks in multiples of four bytes, with a four byte header
-//  for each chunk. The overhead of each chunk is kept low by keeping pointers
-//  as two byte offsets within the heap, rather than (4 or 8 byte) pointers.
-
-namespace {
-
-// When POSIX threads are not available, make the mutex operations a nop
-#if LIBCXXABI_HAS_NO_THREADS
-static void * heap_mutex = 0;
-#else
-static pthread_mutex_t heap_mutex = PTHREAD_MUTEX_INITIALIZER;
-#endif
-
-class mutexor {
-public:
-#if LIBCXXABI_HAS_NO_THREADS
-    mutexor ( void * ) {}
-    ~mutexor () {}
-#else
-    mutexor ( pthread_mutex_t *m ) : mtx_(m) { pthread_mutex_lock ( mtx_ ); }
-    ~mutexor () { pthread_mutex_unlock ( mtx_ ); }
-#endif
-private:
-    mutexor ( const mutexor &rhs );
-    mutexor & operator = ( const mutexor &rhs );
-#if !LIBCXXABI_HAS_NO_THREADS
-    pthread_mutex_t *mtx_;
-#endif
-    };
-
-        
-#define HEAP_SIZE   512
-char heap [ HEAP_SIZE ];
-
-typedef unsigned short heap_offset;
-typedef unsigned short 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
-static heap_node *freelist = NULL;
-
-heap_node *node_from_offset ( const heap_offset offset )
-    { return (heap_node *) ( heap + ( offset * sizeof (heap_node))); }
-
-heap_offset offset_from_node ( const heap_node *ptr )
-    { return static_cast<heap_offset>(static_cast<size_t>(reinterpret_cast<const char *>(ptr) - heap)  / sizeof (heap_node)); }
- 
-void init_heap () {
-    freelist = (heap_node *) heap;
-    freelist->next_node = offset_from_node ( list_end );
-    freelist->len = HEAP_SIZE / sizeof (heap_node);
-    }
-    
-//  How big a chunk we allocate
-size_t alloc_size (size_t len)
-    { return (len + sizeof(heap_node) - 1) / sizeof(heap_node) + 1; }
-
-bool is_fallback_ptr ( void *ptr )
-    { return ptr >= heap && ptr < ( heap + HEAP_SIZE ); }
-
-void *fallback_malloc(size_t len) {
-    heap_node *p, *prev;
-    const size_t nelems = alloc_size ( len );
-    mutexor mtx ( &heap_mutex );
-    
-    if ( NULL == freelist )
-        init_heap ();
-
-//  Walk the free list, looking for a "big enough" chunk
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset ( p->next_node)) {
-
-        if (p->len > nelems) {  //  chunk is larger, shorten, and return the tail
-            heap_node *q;
-
-            p->len = static_cast<heap_size>(p->len - nelems);
-            q = p + p->len;
-            q->next_node = 0;
-            q->len = static_cast<heap_size>(nelems);
-            return (void *) (q + 1);
-        }
-        
-        if (p->len == nelems) { // exact size match
-            if (prev == 0)
-                freelist = node_from_offset(p->next_node);
-            else
-                prev->next_node = p->next_node;
-            p->next_node = 0;
-            return (void *) (p + 1);
-        }
-    }
-    return NULL;    // couldn't find a spot big enough
-}
-
-//  Return the start of the next block
-heap_node *after ( struct heap_node *p ) { return p + p->len; }
-
-void fallback_free (void *ptr) {
-    struct heap_node *cp = ((struct heap_node *) ptr) - 1;      // retrieve the chunk
-    struct heap_node *p, *prev;
-
-    mutexor mtx ( &heap_mutex );
-
-#ifdef DEBUG_FALLBACK_MALLOC
-        std::cout << "Freeing item at " << offset_from_node ( cp ) << " of size " << cp->len << std::endl;
-#endif
-
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
-#ifdef DEBUG_FALLBACK_MALLOC
-        std::cout << "  p, cp, after (p), after(cp) "
-            << offset_from_node ( p ) << ' '
-            << offset_from_node ( cp ) << ' '
-            << offset_from_node ( after ( p )) << ' '
-            << offset_from_node ( after ( cp )) << std::endl;
-#endif
-        if ( after ( p ) == cp ) {
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Appending onto chunk at " << offset_from_node ( p ) << std::endl;
-#endif
-            p->len = static_cast<heap_size>(p->len + cp->len);  // make the free heap_node larger
-            return;
-            }
-        else if ( after ( cp ) == p ) { // there's a free heap_node right after
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Appending free chunk at " << offset_from_node ( p ) << std::endl;
-#endif
-            cp->len = static_cast<heap_size>(cp->len + p->len);
-            if ( prev == 0 ) {
-                freelist = cp;
-                cp->next_node = p->next_node;
-                }
-            else
-                prev->next_node = offset_from_node(cp);
-            return;
-            }
-        }
-//  Nothing to merge with, add it to the start of the free list
-#ifdef DEBUG_FALLBACK_MALLOC
-            std::cout << "  Making new free list entry " << offset_from_node ( cp ) << std::endl;
-#endif
-    cp->next_node = offset_from_node ( freelist );
-    freelist = cp;
-}
-
-#ifdef INSTRUMENT_FALLBACK_MALLOC
-size_t print_free_list () {
-    struct heap_node *p, *prev;
-    heap_size total_free = 0;
-    if ( NULL == freelist )
-        init_heap ();
-    
-    for (p = freelist, prev = 0; 
-            p && p != list_end;     prev = p, p = node_from_offset (p->next_node)) {
-        std::cout << ( prev == 0 ? "" : "  ")  << "Offset: " << offset_from_node ( p ) 
-                << "\tsize: " << p->len << " Next: " << p->next_node << std::endl;
-        total_free += p->len;
-        }
-    std::cout << "Total Free space: " << total_free << std::endl;
-    return total_free;
-    }
-#endif
-}  // end unnamed namespace

test/test_exception_storage_nodynmem.pass.cpp

+//===--------------- test_exception_storage_nodynmem.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <assert.h>
+#include <cstdlib>
+
+static bool OverwrittenCallocCalled = false;
+
+// Override calloc to simulate exhaustion of dynamic memory
+void *calloc(size_t, size_t) {
+    OverwrittenCallocCalled = true;
+    return 0;
+}
+
+int main(int argc, char *argv[]) {
+    // Run the test a couple of times
+    // to ensure that fallback memory doesn't leak.
+    for (int I = 0; I < 1000; ++I)
+        try {
+            throw 42;
+        } catch (...) {
+        }
+
+    assert(OverwrittenCallocCalled);
+    return 0;
+}

test/test_fallback_malloc.pass.cpp

 #include <deque>
 
 #include <pthread.h>
 
 typedef std::deque<void *> container;
 
 // #define  DEBUG_FALLBACK_MALLOC
 #define INSTRUMENT_FALLBACK_MALLOC
-#include "../src/fallback_malloc.ipp"
+#include "../src/fallback_malloc.cpp"
 
 container alloc_series ( size_t sz ) {
     container ptrs;
     void *p;
     
     while ( NULL != ( p = fallback_malloc ( sz )))
         ptrs.push_back ( p );
     return ptrs;