[libcxxabi] On single threaded systems, turn mutexes into nops

[jroelofs]

Summary

This is one of several pieces needed for bare-metal ARM support.

[joerg]

Please introduce a switch in __config instead. There are valid reasons for wanting single threaded code independent of whether pthread is supported or not.

[kledzik]

src/cxa_exception_storage.cpp

35

Should this be:

#include <unistd.h>
#ifdef _POSIX_THREADS
#include <pthread.h>
#endif

so that this will also compile on a system without pthread.h?

[jroelofs]

Joerg, you may be thinking of the __config in libc++. libc++abi doesn't have one, but I'd be happy to create it. Should it go in src/, or in include/ ?

src/cxa_exception_storage.cpp

35

ok, sounds good.

[jroelofs]

Added a config.h to src/, and put all of the pthread things under LIBCXXABI_SINGLE_THREADED. Also gave test/test_exception_storage.cpp the same treatment (which I forgot to attach to the previous diff).

[jroelofs]

Ping.

[kledzik]

src/cxa_exception_storage.cpp

48

Why is eh_globals_ being allocated with calloc() in the single threaded case?

This would be much simpler to have a block (like the #if HAS_THREAD_LOCAL) that just has:

#elif LIBCXXABI_SINGLE_THREADED
   static __cxa_eh_globals eh_globals;
   __cxa_eh_globals *_cxa_get_globals() { return &eh_globals; }
   __cxa_eh_globals *_cxa_get_globals_fast() { return &eh_globals; }
 #else

and the rest of the file stays the same.

[jroelofs]

src/cxa_exception_storage.cpp

48

There's a comment above cxa_get_globals_fast() saying that it has to return 0 if cxa_get_globals() wasn't called first (which might be a bug in the HAS_THREAD_LOCAL side?).

Good point though, structuring it like that will make it cleaner.

[kledzik]

That comment is in the context when _cxa_get_globals() and _cxa_get_globals_fast() are different. In the single threaded and thread local case, they are the same.

Background: there was originally just _cxa_get_globals(). But it had to always check if the global had been allocated for the current thread. Someone realized extra check was a waste of performance, given the way it was used in the unwinder. The only way to get into the bowels of the unwinder was to pass through some code that already called _cxa_get_globals(). Therefore, there were uses that did not need the allocation check. So, _cxa_get_globals_fast() was created which was exactly the same, except did not check for allocation. Then someone said, what if someone refactors the unwinder and forgets to make sure _cxa_get_globals() was called before _cxa_get_globals()? Adding an assert in _cxa_get_globals_fast would slow down the unwinder in the case that is supposed to be fast. So, instead they decided to return NULL which should immediately cause a bus error on use.

None of that applies to the single threaded and thread local cases.

[jroelofs]

Restructure cxa_exception_storage.cpp changes per kledzik's review comments.
Restructure cxa_guard.cpp similarly to make things tidier there too.

Nick, thanks for the helpful explanation on __cxa_get_globals_fast() behavior & history!

[kledzik]

LGTM. Thanks for simplifying the guard stuff too.

[jroelofs]

Committed r208135.

src/config.h

+//===----------------------------- config.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.
+//
+//
+//  Defines macros used within the libc++abi project.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef LIBCXXABI_CONFIG_H
+#define LIBCXXABI_CONFIG_H
+
+#include <unistd.h>
+
+#if defined(_POSIX_THREADS) && _POSIX_THREADS > 0
+#  define LIBCXXABI_SINGLE_THREADED 0
+#else
+#  define LIBCXXABI_SINGLE_THREADED 1
+#endif
+
+#endif // LIBCXXABI_CONFIG_H

src/cxa_exception.cpp

 //  
 //===----------------------------------------------------------------------===//
 
+#include "config.h"
 #include "cxxabi.h"
 
 #include <exception>        // for std::terminate
 #include <cstdlib>          // for malloc, free
 #include <cstring>          // for memset
-#include <pthread.h>
-
+#if !LIBCXXABI_SINGLE_THREADED
+#  include <pthread.h>      // for fallback_malloc.ipp's mutexes
+#endif
 #include "cxa_exception.hpp"
 #include "cxa_handlers.hpp"
 

src/cxa_exception_storage.cpp

 
 #include "cxa_exception.hpp"
 
-#ifdef HAS_THREAD_LOCAL
+#include "config.h"
 
+#if LIBCXXABI_SINGLE_THREADED
+
 namespace __cxxabiv1 {
+extern "C" {
+    static __cxa_eh_globals eh_globals;
+    __cxa_eh_globals *__cxa_get_globals() { return &eh_globals; }
+    __cxa_eh_globals *__cxa_get_globals_fast() { return &eh_globals; }
+    }
+}
 
+#elif defined(HAS_THREAD_LOCAL)
+
+namespace __cxxabiv1 {
+
 namespace {
     __cxa_eh_globals * __globals () {
         static thread_local __cxa_eh_globals eh_globals;

src/cxa_guard.cpp

 //===----------------------------------------------------------------------===//
 
 #include "abort_message.h"
+#include "config.h"
 
-#include <pthread.h>
+#if !LIBCXXABI_SINGLE_THREADED
+#  include <pthread.h>
+#endif
 #include <stdint.h>
 
 /*

 
 #endif
 
+#if !LIBCXXABI_SINGLE_THREADED
 pthread_mutex_t guard_mut = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t  guard_cv  = PTHREAD_COND_INITIALIZER;
+#endif
 
 #if defined(__APPLE__) && !defined(__arm__)
 

 extern "C"
 {
 
+#if LIBCXXABI_SINGLE_THREADED
 int __cxa_guard_acquire(guard_type* guard_object)
 {
-    char* initialized = (char*)guard_object;
+    return !is_initialized(guard_object);
+}
+
+void __cxa_guard_release(guard_type* guard_object)
+{
+    *guard_object = 0;
+    set_initialized(guard_object);
+}
+
+void __cxa_guard_abort(guard_type* guard_object)
+{
+    *guard_object = 0;
+}
+
+#else // !LIBCXXABI_SINGLE_THREADED
+
+int __cxa_guard_acquire(guard_type* guard_object)
+{
     if (pthread_mutex_lock(&guard_mut))
         abort_message("__cxa_guard_acquire failed to acquire mutex");
     int result = *initialized == 0;

         abort_message("__cxa_guard_abort failed to broadcast condition variable");
 }
 
+#endif // !LIBCXXABI_SINGLE_THREADED
+
 }  // extern "C"
 
 }  // __cxxabiv1

src/fallback_malloc.ipp

 //  
 //===----------------------------------------------------------------------===//
 
+#include "config.h"
+
 //  A small, simple heap manager based (loosely) on 
 //  the startup heap manager from FreeBSD, optimized for space.
 //

 
 namespace {
 
+// When POSIX threads are not available, make the mutex operations a nop
+#if LIBCXXABI_SINGLE_THREADED
+static void * heap_mutex = 0;
+#else
 static pthread_mutex_t heap_mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
 
 class mutexor {
 public:
+#if LIBCXXABI_SINGLE_THREADED
+    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_SINGLE_THREADED
     pthread_mutex_t *mtx_;
+#endif
     };
 
         

test/test_exception_storage.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "../src/config.h"
+
 #include <cstdlib>
 #include <algorithm>
 #include <iostream>
-#include <pthread.h>
+#if !LIBCXXABI_SINGLE_THREADED
+#  include <pthread.h>
+#endif
 #include <unistd.h>
 
 #include "../src/cxa_exception.hpp"

     return parm;
     }
 
-
+#if !LIBCXXABI_SINGLE_THREADED
 #define NUMTHREADS  10
 size_t      thread_globals [ NUMTHREADS ] = { 0 };
 pthread_t   threads        [ NUMTHREADS ];
+#endif
 
 void print_sizes ( size_t *first, size_t *last ) {
     std::cout << "{ " << std::hex;

 int main ( int argc, char *argv [] ) {
     int retVal = 0;
 
+#if LIBCXXABI_SINGLE_THREADED
+    size_t thread_globals;
+    retVal = thread_code(&thread_globals) != 0;
+#else
 //  Make the threads, let them run, and wait for them to finish
     for ( int i = 0; i < NUMTHREADS; ++i )
         pthread_create( threads + i, NULL, thread_code, (void *) (thread_globals + i));

             retVal = 2;
             }
 //  print_sizes ( thread_globals, thread_globals + NUMTHREADS );
-    
+#endif
     return retVal;
     }