[libcxxabi] Clean up macro usage

[rs]

Summary

Convention in libcxxabi is to use !defined(FOO) not !FOO.

[EricWF]

I renamed LIBCXXABI_ARM_EHABI to _LIBCXXABI_ARM_EHABI so you'll have to merge this change with that.

Other than that this LGTM.

[rs]

Thanks for reviewing. Before I commit could you tell me if I need to update any build systems e.g. buildbots ?

[rmaprath]

In D30459#689461, @rs wrote:

Thanks for reviewing. Before I commit could you tell me if I need to update any build systems e.g. buildbots ?

Those two options are not used by any of the current public builders, so I think it's safe to commit.

If something breaks, we can revert and have a look :)

[rs]

ok thanks.

CMakeLists.txt

 # the libc++abi that is being built. There are two problems with testing a
 # static libc++abi. In the case of a standalone build, the tests will link the
 # system's libc++, which might not have been built against our libc++abi. In the
 # case of an in tree build, libc++ will prefer a dynamic libc++abi from the
 # system over a static libc++abi from the output directory.
 option(LIBCXXABI_ENABLE_SHARED "Build libc++abi as a shared library." ON)
 option(LIBCXXABI_ENABLE_STATIC "Build libc++abi as a static library." ON)
 
+option(LIBCXXABI_BAREMETAL "Build libc++abi for baremetal targets." OFF)
+# The default terminate handler attempts to demangle uncaught exceptions, which
+# causes extra I/O and demangling code to be pulled in.
+option(LIBCXXABI_SILENT_TERMINATE "Set this to make the terminate handler default to a silent alternative" OFF)
+
 if (NOT LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_STATIC)
   message(FATAL_ERROR "libc++abi must be built as either a shared or static library.")
 endif()
 
 if (LLVM_EXTERNAL_LIBCXX_SOURCE_DIR)
   set(LIBCXXABI_LIBCXX_SRC_DIRS ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR})
 else()
   set(LIBCXXABI_LIBCXX_SRC_DIRS

 endif()
 
 if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Define LIBCXXABI_USE_LLVM_UNWINDER for conditional compilation.
 if (LIBCXXABI_USE_LLVM_UNWINDER)
-  add_definitions(-DLIBCXXABI_USE_LLVM_UNWINDER=1)
+  add_definitions(-DLIBCXXABI_USE_LLVM_UNWINDER)
 endif()
 
 if (LIBCXXABI_SILENT_TERMINATE)
-  add_definitions(-DLIBCXXABI_SILENT_TERMINATE=1)
+  add_definitions(-DLIBCXXABI_SILENT_TERMINATE)
+endif()
+
+if (LIBCXXABI_BAREMETAL)
+    add_definitions(-DLIBCXXABI_BAREMETAL)
 endif()
 
 string(REPLACE ";" " " LIBCXXABI_CXX_FLAGS "${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBCXXABI_C_FLAGS}")
 
 #===============================================================================
 # Setup Source Code

include/__cxxabi_config.h

 //===-------------------------- __cxxabi_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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ____CXXABI_CONFIG_H
 #define ____CXXABI_CONFIG_H
 
 #if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) &&                 \
     !defined(__ARM_DWARF_EH__)
-#define LIBCXXABI_ARM_EHABI 1
-#else
-#define LIBCXXABI_ARM_EHABI 0
+#define LIBCXXABI_ARM_EHABI
 #endif
 
 #if !defined(__has_attribute)
 #define __has_attribute(_attribute_) 0
 #endif
 
 #if defined(_WIN32)
  #if defined(_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS)

include/cxxabi.h

__cxa_throw(void *thrown_exception, std::type_info *tinfo,
             void (*dest)(void *));
 
 // 2.5.3 Exception Handlers
 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_get_exception_ptr(void *exceptionObject) throw();
 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_begin_catch(void *exceptionObject) throw();
 extern _LIBCXXABI_FUNC_VIS void __cxa_end_catch();
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
 extern _LIBCXXABI_FUNC_VIS bool
 __cxa_begin_cleanup(void *exceptionObject) throw();
 extern _LIBCXXABI_FUNC_VIS void __cxa_end_cleanup();
 #endif
 extern _LIBCXXABI_FUNC_VIS std::type_info *__cxa_current_exception_type();
 
 // 2.5.4 Rethrowing Exceptions
 extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_rethrow();

src/abort_message.cpp

 #       include <CrashReporterClient.h>
 #   endif
 #endif
 
 __attribute__((visibility("hidden"), noreturn))
 void abort_message(const char* format, ...)
 {
     // write message to stderr
-#if !defined(NDEBUG) || !LIBCXXABI_BAREMETAL
+#if !defined(NDEBUG) || !defined(LIBCXXABI_BAREMETAL)
 #ifdef __APPLE__
     fprintf(stderr, "libc++abi.dylib: ");
 #endif
     va_list list;
     va_start(list, format);
     vfprintf(stderr, format, list);
     va_end(list);
     fprintf(stderr, "\n");

src/config.h

 //===----------------------------------------------------------------------===//
 
 
 #ifndef LIBCXXABI_CONFIG_H
 #define LIBCXXABI_CONFIG_H
 
 #include <unistd.h>
 
-// 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
-
-// The default terminate handler attempts to demangle uncaught exceptions, which
-// causes extra I/O and demangling code to be pulled in.
-// Set this to make the terminate handler default to a silent alternative.
-#ifndef LIBCXXABI_SILENT_TERMINATE
-#  define LIBCXXABI_SILENT_TERMINATE 0
-#endif
-
 #endif // LIBCXXABI_CONFIG_H

src/cxa_default_handlers.cpp

 
 __attribute__((noreturn))
 static void demangling_unexpected_handler()
 {
     cause = "unexpected";
     std::terminate();
 }
 
-#if !LIBCXXABI_SILENT_TERMINATE
+#if !defined(LIBCXXABI_SILENT_TERMINATE)
 static std::terminate_handler default_terminate_handler = demangling_terminate_handler;
 static std::terminate_handler default_unexpected_handler = demangling_unexpected_handler;
 #else
 static std::terminate_handler default_terminate_handler = std::abort;
 static std::terminate_handler default_unexpected_handler = std::terminate;
 #endif
 
 //

src/cxa_exception.hpp

 
 #pragma GCC visibility push(hidden)
 
 static const uint64_t kOurExceptionClass          = 0x434C4E47432B2B00; // CLNGC++\0
 static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
 static const uint64_t get_vendor_and_language     = 0xFFFFFFFFFFFFFF00; // mask for CLNGC++
 
 struct __cxa_exception {
-#if defined(__LP64__) || LIBCXXABI_ARM_EHABI
+#if defined(__LP64__) || defined(LIBCXXABI_ARM_EHABI)
     // This is a new field to support C++ 0x exception_ptr.
     // For binary compatibility it is at the start of this
     // struct which is prepended to the object thrown in
     // __cxa_allocate_exception.
     size_t referenceCount;
 #endif
 
     //  Manage the exception object itself.
     std::type_info *exceptionType;
     void (*exceptionDestructor)(void *);
     std::unexpected_handler unexpectedHandler;
     std::terminate_handler  terminateHandler;
 
     __cxa_exception *nextException;
 
     int handlerCount;
 
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
     __cxa_exception* nextPropagatingException;
     int propagationCount;
 #else
     int handlerSwitchValue;
     const unsigned char *actionRecord;
     const unsigned char *languageSpecificData;
     void *catchTemp;
     void *adjustedPtr;
 #endif
 
-#if !defined(__LP64__) && !LIBCXXABI_ARM_EHABI
+#if !defined(__LP64__) && !defined(LIBCXXABI_ARM_EHABI)
     // This is a new field to support C++ 0x exception_ptr.
     // For binary compatibility it is placed where the compiler
     // previously adding padded to 64-bit align unwindHeader.
     size_t referenceCount;
 #endif
 
     _Unwind_Exception unwindHeader;
 };
 
 // http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html
 // The layout of this structure MUST match the layout of __cxa_exception, with
 // primaryException instead of referenceCount.
 struct __cxa_dependent_exception {
-#if defined(__LP64__) || LIBCXXABI_ARM_EHABI
+#if defined(__LP64__) || defined(LIBCXXABI_ARM_EHABI)
     void* primaryException;
 #endif
 
     std::type_info *exceptionType;
     void (*exceptionDestructor)(void *);
     std::unexpected_handler unexpectedHandler;
     std::terminate_handler terminateHandler;
 
     __cxa_exception *nextException;
 
     int handlerCount;
 
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
     __cxa_exception* nextPropagatingException;
     int propagationCount;
 #else
     int handlerSwitchValue;
     const unsigned char *actionRecord;
     const unsigned char *languageSpecificData;
     void * catchTemp;
     void *adjustedPtr;
 #endif
 
-#if !defined(__LP64__) && !LIBCXXABI_ARM_EHABI
+#if !defined(__LP64__) && !defined(LIBCXXABI_ARM_EHABI)
     void* primaryException;
 #endif
 
     _Unwind_Exception unwindHeader;
 };
 
 struct __cxa_eh_globals {
     __cxa_exception *   caughtExceptions;
     unsigned int        uncaughtExceptions;
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
     __cxa_exception* propagatingExceptions;
 #endif
 };
 
 #pragma GCC visibility pop
 #pragma GCC visibility push(default)
 
 extern "C" __cxa_eh_globals * __cxa_get_globals      ();

src/cxa_exception.cpp

 The adjusted pointer is computed by the personality routine during phase 1
   and saved in the exception header (either __cxa_exception or
   __cxa_dependent_exception).
 
   Requires:  exception is native
 */
 _LIBCXXABI_FUNC_VIS
 void *__cxa_get_exception_ptr(void *unwind_exception) throw() {
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
     return reinterpret_cast<void*>(
         static_cast<_Unwind_Control_Block*>(unwind_exception)->barrier_cache.bitpattern[0]);
 #else
     return cxa_exception_from_exception_unwind_exception(
         static_cast<_Unwind_Exception*>(unwind_exception))->adjustedPtr;
 #endif
 }
 
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
 /*
 The routine to be called before the cleanup.  This will save __cxa_exception in
 __cxa_eh_globals, so that __cxa_end_cleanup() can recover later.
 */
 _LIBCXXABI_FUNC_VIS
 bool __cxa_begin_cleanup(void *unwind_arg) throw() {
     _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
     __cxa_eh_globals* globals = __cxa_get_globals();
if (native_exception)
         //  place the exception on the top of the stack if it's not already
         //    there by a previous rethrow
         if (exception_header != globals->caughtExceptions)
         {
             exception_header->nextException = globals->caughtExceptions;
             globals->caughtExceptions = exception_header;
         }
         globals->uncaughtExceptions -= 1;   // Not atomically, since globals are thread-local
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
         return reinterpret_cast<void*>(exception_header->unwindHeader.barrier_cache.bitpattern[0]);
 #else
         return exception_header->adjustedPtr;
 #endif
     }
     // Else this is a foreign exception
     // If the caughtExceptions stack is not empty, terminate
     if (globals->caughtExceptions != 0)

src/cxa_personality.cpp

call_terminate(bool native_exception, _Unwind_Exception* unwind_exception)
     {
         // Use the stored terminate_handler if possible
         __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
         std::__terminate(exception_header->terminateHandler);
     }
     std::terminate();
 }
 
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
 static const void* read_target2_value(const void* ptr)
 {
     uintptr_t offset = *reinterpret_cast<const uintptr_t*>(ptr);
     if (!offset)
         return 0;
     // "ARM EABI provides a TARGET2 relocation to describe these typeinfo
     // pointers. The reason being it allows their precise semantics to be
     // deferred to the linker. For bare-metal they turn into absolute
     // relocations. For linux they turn into GOT-REL relocations."
     // https://gcc.gnu.org/ml/gcc-patches/2009-08/msg00264.html
-#if LIBCXXABI_BAREMETAL
+#if defined(LIBCXXABI_BAREMETAL)
     return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(ptr) +
                                          offset);
 #else
     return *reinterpret_cast<const void **>(reinterpret_cast<uintptr_t>(ptr) +
                                             offset);
 #endif
 }
 
assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
             (ttypeEncoding == (DW_EH_PE_pcrel | DW_EH_PE_indirect))) &&  // GCC 4.7 linux
            "Unexpected TTypeEncoding");
     (void)ttypeEncoding;
 
     const uint8_t* ttypePtr = classInfo - ttypeIndex * sizeof(uintptr_t);
     return reinterpret_cast<const __shim_type_info *>(
         read_target2_value(ttypePtr));
 }
-#else // !LIBCXXABI_ARM_EHABI
+#else // !defined(LIBCXXABI_ARM_EHABI
 static
 const __shim_type_info*
 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
                    uint8_t ttypeEncoding, bool native_exception,
                    _Unwind_Exception* unwind_exception)
 {
     if (classInfo == 0)
     {
case DW_EH_PE_sdata8:
         break;
     default:
         // this should not happen.   Indicates corrupted eh_table.
         call_terminate(native_exception, unwind_exception);
     }
     classInfo -= ttypeIndex;
     return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding);
 }
-#endif // !LIBCXXABI_ARM_EHABI
+#endif // !defined(LIBCXXABI_ARM_EHABI)
 
 /*
     This is checking a thrown exception type, excpType, against a possibly empty
     list of catchType's which make up an exception spec.
 
     An exception spec acts like a catch handler, but in reverse.  This "catch
     handler" will catch an excpType if and only if none of the catchType's in
     the list will catch a excpType.  If any catchType in the list can catch an
     excpType, then this exception spec does not catch the excpType.
 */
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
 static
 bool
 exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
                          uint8_t ttypeEncoding, const __shim_type_info* excpType,
                          void* adjustedPtr, _Unwind_Exception* unwind_exception)
 {
     if (classInfo == 0)
     {
Else
     
             1.  A cleanup.
 
         If a cleanup is found
             transfer control to it. return _URC_INSTALL_CONTEXT
         Else a cleanup is not found: return _URC_CONTINUE_UNWIND
 */
 
-#if !LIBCXXABI_ARM_EHABI
+#if !defined(LIBCXXABI_ARM_EHABI)
 _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
 #ifdef __USING_SJLJ_EXCEPTIONS__
 __gxx_personality_sj0
 #else
 __gxx_personality_v0
 #endif
                     (int version, _Unwind_Action actions, uint64_t exceptionClass,
                      _Unwind_Exception* unwind_exception, _Unwind_Context* context)
__cxa_call_unexpected(void* arg)
     const uint8_t* lsda;
     if (native_old_exception)
     {
         old_exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
         t_handler = old_exception_header->terminateHandler;
         u_handler = old_exception_header->unexpectedHandler;
         // If std::__unexpected(u_handler) rethrows the same exception,
         //   these values get overwritten by the rethrow.  So save them now:
-#if LIBCXXABI_ARM_EHABI
+#if defined(LIBCXXABI_ARM_EHABI)
         ttypeIndex = (int64_t)(int32_t)unwind_exception->barrier_cache.bitpattern[4];
         lsda = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[2];
 #else
         ttypeIndex = old_exception_header->handlerSwitchValue;
         lsda = old_exception_header->languageSpecificData;
 #endif
     }
     else