[libcxxabi] cleanup the use of LIBCXXABI_HAS_NO_THREADS macro (NFC)

[rmaprath]

Summary

Align the naming / use of the macro LIBCXXABI_HAS_NO_THREADS to follow what we have in libcxx.

This change is mostly NFC, thought of putting it up for review as it involves a change in naming, and sometimes that can cause disagreements.

Will commit if there isn't much interest.

[jroelofs]

LGTM

[rmaprath]

In D24770#547701, @jroelofs wrote:

LGTM

Thanks!

Committed as r282062.

/ Asiri

CMakeLists.txt

 endif()
 
 if (NOT LIBCXXABI_ENABLE_THREADS)
   if (LIBCXXABI_HAS_PTHREAD_API)
     message(FATAL_ERROR "LIBCXXABI_HAS_PTHREAD_API can only"
                         " be set to ON when LIBCXXABI_ENABLE_THREADS"
                         " is also set to ON.")
   endif()
-  add_definitions(-DLIBCXXABI_HAS_NO_THREADS=1)
+  add_definitions(-D_LIBCXXABI_HAS_NO_THREADS)
 endif()
 
 if (LIBCXXABI_HAS_PTHREAD_API)
   add_definitions(-D_LIBCPP_HAS_THREAD_API_PTHREAD)
 endif()
 
 # This is the _ONLY_ place where add_definitions is called.
 if (MSVC)

src/config.h

 //===----------------------------------------------------------------------===//
 
 
 #ifndef LIBCXXABI_CONFIG_H
 #define LIBCXXABI_CONFIG_H
 
 #include <unistd.h>
 
-// Set this in the CXXFLAGS when you need it
-#if !defined(LIBCXXABI_HAS_NO_THREADS)
-#  define LIBCXXABI_HAS_NO_THREADS 0
-#endif
-
 // Set this in the CXXFLAGS when you need it, because otherwise we'd have to
 // #if !defined(__linux__) && !defined(__APPLE__) && ...
 // and so-on for *every* platform.
 #ifndef LIBCXXABI_BAREMETAL
 #  define LIBCXXABI_BAREMETAL 0
 #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
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 #  include <pthread.h>      // for fallback_malloc.ipp's mutexes
 #endif
 #include "cxa_exception.hpp"
 #include "cxa_handlers.hpp"
 
 // +---------------------------+-----------------------------+---------------+
 // | __cxa_exception           | _Unwind_Exception CLNGC++\0 | thrown object |
 // +---------------------------+-----------------------------+---------------+

src/cxa_exception_storage.cpp

 //  http://mentorembedded.github.io/cxx-abi/abi-eh.html (section 2.2.2)
 //  
 //===----------------------------------------------------------------------===//
 
 #include "cxa_exception.hpp"
 
 #include "config.h"
 
-#if LIBCXXABI_HAS_NO_THREADS
+#if defined(_LIBCXXABI_HAS_NO_THREADS)
 
 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; }
     }
 }

src/cxa_guard.cpp

 //===---------------------------- cxa_guard.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 "__cxxabi_config.h"
 
 #include "abort_message.h"
 #include "config.h"
 
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 #  include <pthread.h>
 #endif
 #include <stdint.h>
 
 /*
     This implementation must be careful to not call code external to this file
     which will turn around and try to call __cxa_guard_acquire reentrantly.
     For this reason, the headers of this file are as restricted as possible.

 typedef uint64_t guard_type;
 
 void set_initialized(guard_type* guard_object) {
     char* initialized = (char*)guard_object;
     *initialized = 1;
 }
 #endif
 
-#if LIBCXXABI_HAS_NO_THREADS || (defined(__APPLE__) && !defined(__arm__))
+#if defined(_LIBCXXABI_HAS_NO_THREADS) || (defined(__APPLE__) && !defined(__arm__))
 #ifdef __arm__
 
 // Test the lowest bit.
 inline bool is_initialized(guard_type* guard_object) {
     return (*guard_object) & 1;
 }
 
 #else
 
 bool is_initialized(guard_type* guard_object) {
     char* initialized = (char*)guard_object;
     return *initialized;
 }
 
 #endif
 #endif
 
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 pthread_mutex_t guard_mut = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t  guard_cv  = PTHREAD_COND_INITIALIZER;
 #endif
 
 #if defined(__APPLE__) && !defined(__arm__)
 
 typedef uint32_t lock_type;
 

 
 #endif  // __APPLE__
 
 }  // unnamed namespace
 
 extern "C"
 {
 
-#if LIBCXXABI_HAS_NO_THREADS
-_LIBCXXABI_FUNC_VIS int __cxa_guard_acquire(guard_type *guard_object) {
-    return !is_initialized(guard_object);
-}
-
-_LIBCXXABI_FUNC_VIS void __cxa_guard_release(guard_type *guard_object) {
-    *guard_object = 0;
-    set_initialized(guard_object);
-}
-
-_LIBCXXABI_FUNC_VIS void __cxa_guard_abort(guard_type *guard_object) {
-    *guard_object = 0;
-}
-
-#else // !LIBCXXABI_HAS_NO_THREADS
-
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 _LIBCXXABI_FUNC_VIS int __cxa_guard_acquire(guard_type *guard_object) {
     char* initialized = (char*)guard_object;
     if (pthread_mutex_lock(&guard_mut))
         abort_message("__cxa_guard_acquire failed to acquire mutex");
     int result = *initialized == 0;
     if (result)
     {
 #if defined(__APPLE__) && !defined(__arm__)
if (pthread_mutex_lock(&guard_mut))
         abort_message("__cxa_guard_abort failed to acquire mutex");
     *guard_object = 0;
     if (pthread_mutex_unlock(&guard_mut))
         abort_message("__cxa_guard_abort failed to release mutex");
     if (pthread_cond_broadcast(&guard_cv))
         abort_message("__cxa_guard_abort failed to broadcast condition variable");
 }
 
-#endif // !LIBCXXABI_HAS_NO_THREADS
+#else // _LIBCXXABI_HAS_NO_THREADS
+
+_LIBCXXABI_FUNC_VIS int __cxa_guard_acquire(guard_type *guard_object) {
+    return !is_initialized(guard_object);
+}
+
+_LIBCXXABI_FUNC_VIS void __cxa_guard_release(guard_type *guard_object) {
+    *guard_object = 0;
+    set_initialized(guard_object);
+}
+
+_LIBCXXABI_FUNC_VIS void __cxa_guard_abort(guard_type *guard_object) {
+    *guard_object = 0;
+}
+
+#endif // !_LIBCXXABI_HAS_NO_THREADS
 
 }  // extern "C"
 
 }  // __cxxabiv1

src/fallback_malloc.ipp

 //
 //  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
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 static pthread_mutex_t heap_mutex = PTHREAD_MUTEX_INITIALIZER;
+#else
+static void * heap_mutex = 0;
 #endif
 
 class mutexor {
 public:
-#if LIBCXXABI_HAS_NO_THREADS
-    mutexor ( void * ) {}
-    ~mutexor () {}
-#else
+#ifndef _LIBCXXABI_HAS_NO_THREADS
     mutexor ( pthread_mutex_t *m ) : mtx_(m) { pthread_mutex_lock ( mtx_ ); }
     ~mutexor () { pthread_mutex_unlock ( mtx_ ); }
+#else
+    mutexor ( void * ) {}
+    ~mutexor () {}
 #endif
 private:
     mutexor ( const mutexor &rhs );
     mutexor & operator = ( const mutexor &rhs );
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
     pthread_mutex_t *mtx_;
 #endif
     };
 
         
 #define HEAP_SIZE   512
 char heap [ HEAP_SIZE ];
 

test/libcxxabi/test/config.py

class Configuration(LibcxxConfiguration):
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += ['-DLIBCXXABI_NO_TIMER']
         if self.get_lit_bool('enable_exceptions', True):
             self.cxx.compile_flags += ['-funwind-tables']
         else:
             self.cxx.compile_flags += ['-fno-exceptions', '-DLIBCXXABI_HAS_NO_EXCEPTIONS']
         if not self.get_lit_bool('enable_threads', True):
-            self.cxx.compile_flags += ['-DLIBCXXABI_HAS_NO_THREADS=1']
+            self.cxx.compile_flags += ['-D_LIBCXXABI_HAS_NO_THREADS']
         super(Configuration, self).configure_compile_flags()    
     
     def configure_compile_flags_header_includes(self):
         self.configure_config_site_header()
         cxx_headers = self.get_lit_conf(
             'cxx_headers',
             os.path.join(self.libcxx_src_root, '/include'))
         if not os.path.isdir(cxx_headers):

test/test_exception_storage.pass.cpp

 //===-------------------- test_exception_storage.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 "../src/config.h"
 
 #include <cstdlib>
 #include <algorithm>
 #include <iostream>
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 #  include <pthread.h>
 #endif
 #include <unistd.h>
 
 #include "../src/cxa_exception.hpp"
 
 typedef __cxxabiv1::__cxa_eh_globals globals_t ;
 
void *thread_code (void *parm) {
     if ( glob1 != glob2 )
         std::cerr << "Got different globals!" << std::endl;
     
     *result = (size_t) glob1;
     sleep ( 1 );
     return parm;
     }
 
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 #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;
-    for ( size_t *iter = first; iter != last; ++iter )
-        std::cout << *iter << " ";
-    std::cout << "}" << std::dec << std::endl;
-    }
-
 int main ( int argc, char *argv [] ) {
     int retVal = 0;
 
-#if LIBCXXABI_HAS_NO_THREADS
-    size_t thread_globals;
-    // Check that __cxa_get_globals() is not NULL.
-    if (thread_code(&thread_globals) == 0) {
-        retVal = 1;
-    }
-#else
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 //  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));
     for ( int i = 0; i < NUMTHREADS; ++i )
         pthread_join ( threads [ i ], NULL );
 
     for ( int i = 0; i < NUMTHREADS; ++i )
         if ( 0 == thread_globals [ i ] ) {
             std::cerr << "Thread #" << i << " had a zero global" << std::endl;
             retVal = 1;
             }
         
-//  print_sizes ( thread_globals, thread_globals + NUMTHREADS );
     std::sort ( thread_globals, thread_globals + NUMTHREADS );
     for ( int i = 1; i < NUMTHREADS; ++i )
         if ( thread_globals [ i - 1 ] == thread_globals [ i ] ) {
             std::cerr << "Duplicate thread globals (" << i-1 << " and " << i << ")" << std::endl;
             retVal = 2;
             }
-//  print_sizes ( thread_globals, thread_globals + NUMTHREADS );
-
-#endif
+#else // _LIBCXXABI_HAS_NO_THREADS
+    size_t thread_globals;
+    // Check that __cxa_get_globals() is not NULL.
+    if (thread_code(&thread_globals) == 0) {
+        retVal = 1;
+    }
+#endif // !_LIBCXXABI_HAS_NO_THREADS
     return retVal;
-    }

test/test_guard.pass.cpp

 //===----------------------------- test_guard.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 "../src/config.h"
 #include "cxxabi.h"
 
 #include <cassert>
 
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 #include <thread>
 #endif
 
 // Ensure that we initialize each variable once and only once.
 namespace test1 {
     static int run_count = 0;
     int increment() {
         ++run_count;
int one() {
         return 0;
     }
 
     void test() {
         static int a = one();
     }
 }
 
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
 // A simple thread test of two threads racing to initialize a variable. This
 // isn't guaranteed to catch any particular threading problems.
 namespace test4 {
     static int run_count = 0;
     int increment() {
         ++run_count;
         return 0;
     }
namespace test5 {
     }
 
     void test() {
         std::thread t(helper);
         t.join();
         assert(run_count == 1);
     }
 }
-#endif /* LIBCXXABI_HAS_NO_THREADS */
+#endif /* _LIBCXXABI_HAS_NO_THREADS */
 
 int main()
 {
     test1::test();
     test2::test();
     test3::test();
-#if !LIBCXXABI_HAS_NO_THREADS
+#ifndef _LIBCXXABI_HAS_NO_THREADS
     test4::test();
     test5::test();
 #endif
 }