libc++abi: mark visibility

[compnerd]

Summary

Mark functions and types with the appropriate visibility. This is particularly
useful for environments which explicitly indicate origin of functions (Windows).
This aids in ensuring libc++abi as a DSO which exposes only the public
interfaces.

[jroelofs]

include/__cxxabi_config.h

24

s/LIBCXXABI_DLL/_LIBCXXABI_DLL/

[compnerd]

include/__cxxabi_config.h

24

Sure, though the thing is that this would be different from libc++, which uses LIBCPP_DLL.

[jroelofs]

include/__cxxabi_config.h

24

Two wrongs don't make a right...

[compnerd]

Address @jroelofs' comment.

[compnerd]

ping?

[mclow.lists]

This looks fine to me.

A note - the pervasive whitespace changes obscure the substantive changes.
In an ideal world, they would be two different changes.

include/__cxxabi_config.h

24

I'm wondering where you see use of LIBCPP_DLL in libc++.

The only place I see is in __config:182, which uses _LIBCPP_DLL, and has since (at least) 2011.

(Because @jroelofs is correct)

[compnerd]

Sure, I can split it up into two changes, one for the formatting, and one for the material changes before committing.

[compnerd]

Applied the bulk of the whitespace changes in a separate commit (SVN r254690) and the annotation work in SVN r254691.

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__) && \
+#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) &&                 \
     !defined(__ARM_DWARF_EH__)
 #define LIBCXXABI_ARM_EHABI 1
 #else
 #define LIBCXXABI_ARM_EHABI 0
 #endif
 
+#if !defined(__has_attribute)
+#define __has_attribute(_attribute_) 0
+#endif
+
+#if defined(_LIBCXXABI_DLL)
+ #if defined(cxxabi_EXPORTS)
+  #define _LIBCXXABI_HIDDEN
+  #define _LIBCXXABI_FUNC_VIS __declspec(dllexport)
+  #define _LIBCXXABI_TYPE_VIS __declspec(dllexport)
+ #else
+  #define _LIBCXXABI_HIDDEN
+  #define _LIBCXXABI_FUNC_VIS __declspec(dllimport)
+  #define _LIBCXXABI_TYPE_VIS __declspec(dllimport)
+ #endif
+#else
+ #define _LIBCXXABI_HIDDEN __attribute__((__visibility__("hidden")))
+ #define _LIBCXXABI_FUNC_VIS __attribute__((__visibility__("default")))
+ #if __has_attribute(__type_visibility__)
+  #define _LIBCXXABI_TYPE_VIS __attribute__((__type_visibility__("default")))
+ #else
+  #define _LIBCXXABI_TYPE_VIS __attribute__((__visibility__("default")))
+ #endif
+#endif
+
 #endif // ____CXXABI_CONFIG_H

include/cxxabi.h

 #include <__cxxabi_config.h>
 
 #define _LIBCPPABI_VERSION 1002
 #define LIBCXXABI_NORETURN  __attribute__((noreturn))
 
 #ifdef __cplusplus
 
 namespace std {
-class type_info; // forward declaration
+class _LIBCXXABI_TYPE_VIS type_info; // forward declaration
 }
 
 
 // runtime routines use C calling conventions, but are in __cxxabiv1 namespace
 namespace __cxxabiv1 {
 extern "C"  {
 
 // 2.4.2 Allocating the Exception Object
-extern void * __cxa_allocate_exception(size_t thrown_size) throw();
-extern void __cxa_free_exception(void * thrown_exception) throw();
+extern _LIBCXXABI_FUNC_VIS void *
+__cxa_allocate_exception(size_t thrown_size) throw();
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_free_exception(void *thrown_exception) throw();
 
 // 2.4.3 Throwing the Exception Object
-extern LIBCXXABI_NORETURN void __cxa_throw(void * thrown_exception,
-        std::type_info * tinfo, void (*dest)(void *));
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void
+__cxa_throw(void *thrown_exception, std::type_info *tinfo,
+            void (*dest)(void *));
 
 // 2.5.3 Exception Handlers
-extern void * __cxa_get_exception_ptr(void * exceptionObject) throw();
-extern void * __cxa_begin_catch(void * exceptionObject) throw();
-extern void __cxa_end_catch();
+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
-extern bool __cxa_begin_cleanup(void * exceptionObject) throw();
-extern void __cxa_end_cleanup();
+extern _LIBCXXABI_FUNC_VIS bool
+__cxa_begin_cleanup(void *exceptionObject) throw();
+extern _LIBCXXABI_FUNC_VIS void __cxa_end_cleanup();
 #endif
-extern std::type_info * __cxa_current_exception_type();
+extern _LIBCXXABI_FUNC_VIS std::type_info *__cxa_current_exception_type();
 
 // 2.5.4 Rethrowing Exceptions
-extern LIBCXXABI_NORETURN void __cxa_rethrow();
-
-
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_rethrow();
 
 // 2.6 Auxiliary Runtime APIs
-extern LIBCXXABI_NORETURN void __cxa_bad_cast(void);
-extern LIBCXXABI_NORETURN void __cxa_bad_typeid(void);
-extern LIBCXXABI_NORETURN void __cxa_throw_bad_array_new_length(void);
-
-
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_cast(void);
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_typeid(void);
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void
+__cxa_throw_bad_array_new_length(void);
 
 // 3.2.6 Pure Virtual Function API
-extern LIBCXXABI_NORETURN void __cxa_pure_virtual(void);
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_pure_virtual(void);
 
 // 3.2.7 Deleted Virtual Function API
-extern LIBCXXABI_NORETURN void __cxa_deleted_virtual(void);
+extern _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_deleted_virtual(void);
 
 // 3.3.2 One-time Construction API
 #ifdef __arm__
-extern int  __cxa_guard_acquire(uint32_t*);
-extern void __cxa_guard_release(uint32_t*);
-extern void __cxa_guard_abort(uint32_t*);
+extern _LIBCXXABI_FUNC_VIS int  __cxa_guard_acquire(uint32_t*);
+extern _LIBCXXABI_FUNC_VIS void __cxa_guard_release(uint32_t*);
+extern _LIBCXXABI_FUNC_VIS void __cxa_guard_abort(uint32_t*);
 #else
-extern int  __cxa_guard_acquire(uint64_t*);
-extern void __cxa_guard_release(uint64_t*);
-extern void __cxa_guard_abort(uint64_t*);
+extern _LIBCXXABI_FUNC_VIS int  __cxa_guard_acquire(uint64_t*);
+extern _LIBCXXABI_FUNC_VIS void __cxa_guard_release(uint64_t*);
+extern _LIBCXXABI_FUNC_VIS void __cxa_guard_abort(uint64_t*);
 #endif
 
 // 3.3.3 Array Construction and Destruction API
-extern void* __cxa_vec_new(size_t element_count,
-                           size_t element_size,
-                           size_t padding_size,
-                           void (*constructor)(void*),
-                           void (*destructor)(void*));
-
-extern void* __cxa_vec_new2(size_t element_count,
-                            size_t element_size,
-                            size_t padding_size,
-                            void  (*constructor)(void*),
-                            void  (*destructor)(void*),
-                            void* (*alloc)(size_t),
-                            void  (*dealloc)(void*));
-
-extern void* __cxa_vec_new3(size_t element_count,
-                            size_t element_size,
-                            size_t padding_size,
-                            void  (*constructor)(void*),
-                            void  (*destructor)(void*),
-                            void* (*alloc)(size_t),
-                            void  (*dealloc)(void*, size_t));
-
-extern void __cxa_vec_ctor(void*  array_address,
-                           size_t element_count,
-                           size_t element_size,
-                           void (*constructor)(void*),
-                           void (*destructor)(void*));
+extern _LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new(size_t element_count, size_t element_size, size_t padding_size,
+              void (*constructor)(void *), void (*destructor)(void *));
+
+extern _LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new2(size_t element_count, size_t element_size, size_t padding_size,
+               void (*constructor)(void *), void (*destructor)(void *),
+               void *(*alloc)(size_t), void (*dealloc)(void *));
+
+extern _LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new3(size_t element_count, size_t element_size, size_t padding_size,
+               void (*constructor)(void *), void (*destructor)(void *),
+               void *(*alloc)(size_t), void (*dealloc)(void *, size_t));
+
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_vec_ctor(void *array_address, size_t element_count, size_t element_size,
+               void (*constructor)(void *), void (*destructor)(void *));
 
-extern void __cxa_vec_dtor(void*  array_address,
+extern _LIBCXXABI_FUNC_VIS void __cxa_vec_dtor(void *array_address,
                                                size_t element_count,
                                                size_t element_size,
-                           void (*destructor)(void*));
+                                               void (*destructor)(void *));
 
-extern void __cxa_vec_cleanup(void* array_address,
+extern _LIBCXXABI_FUNC_VIS void __cxa_vec_cleanup(void *array_address,
                                                   size_t element_count,
                                                   size_t element_size,
-                             void  (*destructor)(void*));
+                                                  void (*destructor)(void *));
 
-extern void __cxa_vec_delete(void*  array_address,
+extern _LIBCXXABI_FUNC_VIS void __cxa_vec_delete(void *array_address,
                                                  size_t element_size,
                                                  size_t padding_size,
-                             void  (*destructor)(void*));
+                                                 void (*destructor)(void *));
 
-extern void __cxa_vec_delete2(void* array_address,
-                             size_t element_size,
-                             size_t padding_size,
-                             void  (*destructor)(void*),
-                             void  (*dealloc)(void*));
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_vec_delete2(void *array_address, size_t element_size, size_t padding_size,
+                  void (*destructor)(void *), void (*dealloc)(void *));
 
-extern void __cxa_vec_delete3(void* __array_address,
-                             size_t element_size,
-                             size_t padding_size,
-                             void  (*destructor)(void*),
-                             void  (*dealloc)(void*, size_t));
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_vec_delete3(void *__array_address, size_t element_size,
+                  size_t padding_size, void (*destructor)(void *),
+                  void (*dealloc)(void *, size_t));
 
-extern void __cxa_vec_cctor(void*  dest_array,
-                            void*  src_array,
-                            size_t element_count,
-                            size_t element_size,
-                            void  (*constructor)(void*, void*),
-                            void  (*destructor)(void*));
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_vec_cctor(void *dest_array, void *src_array, size_t element_count,
+                size_t element_size, void (*constructor)(void *, void *),
+                void (*destructor)(void *));
 
 // 3.3.5.3 Runtime API
-extern int __cxa_atexit(void (*f)(void*), void* p, void* d);
-extern int __cxa_finalize(void*);
+extern _LIBCXXABI_FUNC_VIS int __cxa_atexit(void (*f)(void *), void *p,
+                                            void *d);
+extern _LIBCXXABI_FUNC_VIS int __cxa_finalize(void*);
 
 // 3.4 Demangler API
-extern char* __cxa_demangle(const char* mangled_name,
-                            char*       output_buffer,
-                            size_t*     length,
-                            int*        status);
+extern _LIBCXXABI_FUNC_VIS char *__cxa_demangle(const char *mangled_name,
+                                                char *output_buffer,
+                                                size_t *length, int *status);
 
 // Apple additions to support C++ 0x exception_ptr class
 // These are primitives to wrap a smart pointer around an exception object
-extern void * __cxa_current_primary_exception() throw();
-extern void __cxa_rethrow_primary_exception(void* primary_exception);
-extern void __cxa_increment_exception_refcount(void* primary_exception) throw();
-extern void __cxa_decrement_exception_refcount(void* primary_exception) throw();
+extern _LIBCXXABI_FUNC_VIS void *__cxa_current_primary_exception() throw();
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_rethrow_primary_exception(void *primary_exception);
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_increment_exception_refcount(void *primary_exception) throw();
+extern _LIBCXXABI_FUNC_VIS void
+__cxa_decrement_exception_refcount(void *primary_exception) throw();
 
 // Apple extension to support std::uncaught_exception()
-extern bool          __cxa_uncaught_exception () throw();
-extern unsigned int  __cxa_uncaught_exceptions() throw();
+extern _LIBCXXABI_FUNC_VIS bool __cxa_uncaught_exception() throw();
+extern _LIBCXXABI_FUNC_VIS unsigned int __cxa_uncaught_exceptions() throw();
 
 #ifdef __linux__
 // Linux TLS support. Not yet an official part of the Itanium ABI.
 // https://sourceware.org/glibc/wiki/Destructor%20support%20for%20thread_local%20variables
-extern int __cxa_thread_atexit(void (*)(void *), void *, void *) throw();
+extern _LIBCXXABI_FUNC_VIS int __cxa_thread_atexit(void (*)(void *), void *,
+                                                   void *) throw();
 #endif
 
-  } // extern "C"
 } // namespace __cxxabiv1
 
 namespace abi = __cxxabiv1;
 
 #endif // __cplusplus
 
 #endif // __CXXABI_H

src/cxa_aux_runtime.cpp

 //===------------------------ cxa_aux_runtime.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.
 //
 //
 // This file implements the "Auxiliary Runtime APIs"
 // http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-aux
 //===----------------------------------------------------------------------===//
 
 #include "cxxabi.h"
 #include <new>
 #include <typeinfo>
 
-namespace __cxxabiv1
-{
-
-extern "C"
-{
-
-LIBCXXABI_NORETURN
-void __cxa_bad_cast (void) {
-    throw std::bad_cast();
+namespace __cxxabiv1 {
+extern "C" {
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_cast(void) {
 }
 
-LIBCXXABI_NORETURN
-void __cxa_bad_typeid(void) {
-    throw std::bad_typeid();
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_typeid(void) {
 }
 
-LIBCXXABI_NORETURN
-void __cxa_throw_bad_array_new_length(void) {
-    throw std::bad_array_new_length();
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void
+__cxa_throw_bad_array_new_length(void) {
 }
-}  // extern "C"
-
-}  // abi
+} // extern "C"
+} // abi

src/cxa_demangle.cpp

 //===-------------------------- cxa_demangle.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.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_EXTERN_TEMPLATE(...)
 #define _LIBCPP_NO_EXCEPTIONS
 
+#include "__cxxabi_config.h"
+
 #include <vector>
 #include <algorithm>
 #include <string>
 #include <numeric>
 #include <cstdlib>
 #include <cstring>
 #include <cctype>
 

         names(ar),
         subs(0, names, ar),
         template_param(0, subs, ar)
     {}
 };
 
 }  // unnamed namespace
 
-extern "C"
-__attribute__ ((__visibility__("default")))
-char*
+extern "C" _LIBCXXABI_FUNC_VIS char*
 __cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status)
 {
     if (mangled_name == nullptr || (buf != nullptr && n == nullptr))
     {
         if (status)
             *status = invalid_args;
         return nullptr;
     }

src/cxa_exception.cpp

 
 extern "C" {
 
 //  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.
-void * __cxa_allocate_exception (size_t thrown_size) throw() {
+_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));
     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.
-void __cxa_free_exception (void * thrown_object) throw() {
+_LIBCXXABI_FUNC_VIS void __cxa_free_exception(void *thrown_object) throw() {
     do_free(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 () {

 * Call _Unwind_RaiseException in the system unwind library, Its argument is the
 pointer to the thrown exception, which __cxa_throw itself received as an argument.
 __Unwind_RaiseException begins the process of stack unwinding, described
 in Section 2.5. In special cases, such as an inability to find a
 handler, _Unwind_RaiseException may return. In that case, __cxa_throw
 will call terminate, assuming that there was no handler for the
 exception.
 */
-LIBCXXABI_NORETURN
-void 
-__cxa_throw(void* thrown_object, std::type_info* tinfo, void (*dest)(void*))
-{
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void
+__cxa_throw(void *thrown_object, std::type_info *tinfo, void (*dest)(void *)) {
     __cxa_eh_globals *globals = __cxa_get_globals();
     __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
 
     exception_header->unexpectedHandler = std::get_unexpected();
     exception_header->terminateHandler  = std::get_terminate();
     exception_header->exceptionType = tinfo;
     exception_header->exceptionDestructor = dest;
     setExceptionClass(&exception_header->unwindHeader);

 // 2.5.3 Exception Handlers
 /*
 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
 */
-void*
-__cxa_get_exception_ptr(void* unwind_exception) throw()
-{
+_LIBCXXABI_FUNC_VIS void *
+__cxa_get_exception_ptr(void *unwind_exception) throw() {
 #if 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
 /*
 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.
 */
-bool
-__cxa_begin_cleanup(void* unwind_arg) throw ()
-{
+_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();
     __cxa_exception* exception_header =
         cxa_exception_from_exception_unwind_exception(unwind_exception);
 
     if (isOurExceptionClass(unwind_exception))
     {
         if (0 == exception_header->propagationCount)
* If the handler count goes down to zero, and the exception was not re-thrown
   it's handling) and decrements its reference count. If that reference count
   goes to zero, the function destroys the exception. In any case, if the current
   exception is a dependent exception, it destroys that.
 
 For a foreign exception:
 * If it has been rethrown, there is nothing to do.
 * Otherwise delete the exception and pop the catch stack to empty.
 */
-void __cxa_end_catch()
-{
+_LIBCXXABI_FUNC_VIS void __cxa_end_catch() {
   static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception),
                 "sizeof(__cxa_exception) must be equal to "
                 "sizeof(__cxa_dependent_exception)");
   static_assert(__builtin_offsetof(__cxa_exception, referenceCount) ==
                     __builtin_offsetof(__cxa_dependent_exception,
                                        primaryException),
                 "the layout of __cxa_exception must match the layout of "
                 "__cxa_dependent_exception");
if (NULL != exception_header)
             globals->caughtExceptions = 0;
         }
     }
 }
 
 // Note:  exception_header may be masquerading as a __cxa_dependent_exception
 //        and that's ok.  exceptionType is there too.
 //        However watch out for foreign exceptions.  Return null for them.
-std::type_info * __cxa_current_exception_type() {
+_LIBCXXABI_FUNC_VIS std::type_info * __cxa_current_exception_type() {
 //  get the current exception
     __cxa_eh_globals *globals = __cxa_get_globals_fast();
     if (NULL == globals)
         return NULL;     //  If there have never been any exceptions, there are none now.
     __cxa_exception *exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
     if (!isOurExceptionClass(&exception_header->unwindHeader))
         return NULL;
     return exception_header->exceptionType;
 }
 
 // 2.5.4 Rethrowing Exceptions
 /*  This routine can rethrow native or foreign exceptions.
 If the exception is native:
 * marks the exception object on top of the caughtExceptions stack 
   (in an implementation-defined way) as being rethrown. 
 * If the caughtExceptions stack is empty, it calls terminate() 
   (see [C++FDIS] [except.throw], 15.1.8). 
 * It then calls _Unwind_RaiseException which should not return
    (terminate if it does).
   Note:  exception_header may be masquerading as a __cxa_dependent_exception
          and that's ok.
 */
-LIBCXXABI_NORETURN
-void
-__cxa_rethrow()
-{
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_rethrow() {
     __cxa_eh_globals* globals = __cxa_get_globals();
     __cxa_exception* exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         std::terminate();      // throw; called outside of a exception handler
     bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
     if (native_exception)
     {
         //  Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch)

 
 /*
     If thrown_object is not null, atomically increment the referenceCount field
     of the __cxa_exception header associated with the thrown object referred to
     by thrown_object.
 
     Requires:  If thrown_object is not NULL, it is a native exception.
 */
-void
-__cxa_increment_exception_refcount(void* thrown_object) throw()
-{
+_LIBCXXABI_FUNC_VIS void
+__cxa_increment_exception_refcount(void *thrown_object) throw() {
     if (thrown_object != NULL )
     {
         __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
         __sync_add_and_fetch(&exception_header->referenceCount, 1);
     }
 }
 
 /*
     If thrown_object is not null, atomically decrement the referenceCount field
     of the __cxa_exception header associated with the thrown object referred to
     by thrown_object.  If the referenceCount drops to zero, destroy and
     deallocate the exception.
 
     Requires:  If thrown_object is not NULL, it is a native exception.
 */
-void
-__cxa_decrement_exception_refcount(void* thrown_object) throw()
-{
+_LIBCXXABI_FUNC_VIS void
+__cxa_decrement_exception_refcount(void *thrown_object) throw() {
     if (thrown_object != NULL )
     {
         __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
         if (__sync_sub_and_fetch(&exception_header->referenceCount, size_t(1)) == 0)
         {
             if (NULL != exception_header->exceptionDestructor)
                 exception_header->exceptionDestructor(thrown_object);
             __cxa_free_exception(thrown_object);
         }
     }
 }
 
 /*
     Returns a pointer to the thrown object (if any) at the top of the
     caughtExceptions stack.  Atomically increment the exception's referenceCount.
     If there is no such thrown object or if the thrown object is foreign,
     returns null.
 
     We can use __cxa_get_globals_fast here to get the globals because if there have
     been no exceptions thrown, ever, on this thread, we can return NULL without 
     the need to allocate the exception-handling globals.
 */
-void*
-__cxa_current_primary_exception() throw()
-{
+_LIBCXXABI_FUNC_VIS void* __cxa_current_primary_exception() throw() {
 //  get the current exception
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
     if (NULL == globals)
         return NULL;        //  If there are no globals, there is no exception
     __cxa_exception* exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
     if (!isOurExceptionClass(&exception_header->unwindHeader))

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
 #  include <pthread.h>
 #endif
 #include <stdint.h>
 

 #endif  // __APPLE__
 
 }  // unnamed namespace
 
 extern "C"
 {
 
 #if LIBCXXABI_HAS_NO_THREADS
-int __cxa_guard_acquire(guard_type* guard_object)
-{
-    return !is_initialized(guard_object);
+_LIBCXXABI_FUNC_VIS int __cxa_guard_acquire(guard_type *guard_object) {
 }
 
-void __cxa_guard_release(guard_type* guard_object)
-{
-    *guard_object = 0;
-    set_initialized(guard_object);
+_LIBCXXABI_FUNC_VIS void __cxa_guard_release(guard_type *guard_object) {
 }
 
-void __cxa_guard_abort(guard_type* guard_object)
-{
-    *guard_object = 0;
+_LIBCXXABI_FUNC_VIS void __cxa_guard_abort(guard_type *guard_object) {
 }
 
 #else // !LIBCXXABI_HAS_NO_THREADS
 
-int __cxa_guard_acquire(guard_type* guard_object)
-{
+_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__)
         const lock_type id = pthread_mach_thread_np(pthread_self());
#else  // !__APPLE__ || __arm__
             set_lock(*guard_object, true);
 #endif  // !__APPLE__ || __arm__
     }
     if (pthread_mutex_unlock(&guard_mut))
         abort_message("__cxa_guard_acquire failed to release mutex");
     return result;
 }
 
-void __cxa_guard_release(guard_type* guard_object)
-{
+_LIBCXXABI_FUNC_VIS void __cxa_guard_release(guard_type* guard_object) {
     if (pthread_mutex_lock(&guard_mut))
         abort_message("__cxa_guard_release failed to acquire mutex");
     *guard_object = 0;
     set_initialized(guard_object);
     if (pthread_mutex_unlock(&guard_mut))
         abort_message("__cxa_guard_release failed to release mutex");
     if (pthread_cond_broadcast(&guard_cv))
         abort_message("__cxa_guard_release failed to broadcast condition variable");
 }
 
-void __cxa_guard_abort(guard_type* guard_object)
-{
+_LIBCXXABI_FUNC_VIS void __cxa_guard_abort(guard_type* guard_object) {
     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
 
 }  // extern "C"
 
 }  // __cxxabiv1

src/cxa_thread_atexit.cpp

 //===----------------------- cxa_thread_atexit.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.h"
 
 namespace __cxxabiv1 {
-
 extern "C" {
 
 #ifdef HAVE___CXA_THREAD_ATEXIT_IMPL
 
+_LIBCXXABI_FUNC_VIS
 int __cxa_thread_atexit(void (*dtor)(void *), void *obj,
                         void *dso_symbol) throw() {
   extern int __cxa_thread_atexit_impl(void (*)(void *), void *, void *);
   return __cxa_thread_atexit_impl(dtor, obj, dso_symbol);
 }
 
 #endif // HAVE__CXA_THREAD_ATEXIT_IMPL
 
 } // extern "C"
-
 } // namespace __cxxabiv1

src/cxa_vector.cpp

 #endif
 
 extern "C" {
 
 // Equivalent to
 // 
 //   __cxa_vec_new2(element_count, element_size, padding_size, constructor,
 //                  destructor, &::operator new[], &::operator delete[])
-void* __cxa_vec_new(
-    size_t element_count, size_t element_size, size_t padding_size, 
-        void (*constructor)(void*), void (*destructor)(void*) ) {
-
-    return __cxa_vec_new2 ( element_count, element_size, padding_size, 
-        constructor, destructor, &::operator new [], &::operator delete [] );
+_LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new(size_t element_count, size_t element_size, size_t padding_size,
+              void (*constructor)(void *), void (*destructor)(void *)) {
+  return __cxa_vec_new2(element_count, element_size, padding_size, constructor,
+                        destructor, &::operator new[], & ::operator delete[]);
 }
 
 
 
 // Given the number and size of elements for an array and the non-negative
 // size of prefix padding for a cookie, allocate space (using alloc) for
 // the array preceded by the specified padding, initialize the cookie if
 // the padding is non-zero, and call the given constructor on each element.
 // Return the address of the array proper, after the padding.
 // 
 // If alloc throws an exception, rethrow the exception. If alloc returns
 // NULL, return NULL. If the constructor throws an exception, call
 // destructor for any already constructed elements, and rethrow the
 // exception. If the destructor throws an exception, call std::terminate.
 // 
 // The constructor may be NULL, in which case it must not be called. If the
 // padding_size is zero, the destructor may be NULL; in that case it must
 // not be called.
 // 
 // Neither alloc nor dealloc may be NULL.
-void* __cxa_vec_new2(
-    size_t element_count, size_t element_size, size_t padding_size,
-        void  (*constructor)(void*), void  (*destructor)(void*),
-        void* (*alloc)(size_t), void  (*dealloc)(void*) ) {
-
+_LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new2(size_t element_count, size_t element_size, size_t padding_size,
+               void (*constructor)(void *), void (*destructor)(void *),
+               void *(*alloc)(size_t), void (*dealloc)(void *)) {
     const size_t heap_size = element_count * element_size + padding_size;
     char * const heap_block = static_cast<char *> ( alloc ( heap_size ));
     char *vec_base = heap_block;
     
     if ( NULL != vec_base ) {
         st_heap_block2 heap ( dealloc, heap_block );
 
     //  put the padding before the array elements
         if ( 0 != padding_size ) {
             vec_base += padding_size;
             __set_element_count ( vec_base, element_count );
         }
             
     //  Construct the elements
         __cxa_vec_ctor ( vec_base, element_count, element_size, constructor, destructor );
         heap.release ();    // We're good!
     }
     
     return vec_base;
 }
 
 
 // Same as __cxa_vec_new2 except that the deallocation function takes both
 // the object address and its size.
-void* __cxa_vec_new3(
-    size_t element_count, size_t element_size, size_t padding_size,
-        void  (*constructor)(void*), void  (*destructor)(void*),
-        void* (*alloc)(size_t), void  (*dealloc)(void*, size_t) ) {
-
+_LIBCXXABI_FUNC_VIS void *
+__cxa_vec_new3(size_t element_count, size_t element_size, size_t padding_size,
+               void (*constructor)(void *), void (*destructor)(void *),
+               void *(*alloc)(size_t), void (*dealloc)(void *, size_t)) {
     const size_t heap_size = element_count * element_size + padding_size;
     char * const heap_block = static_cast<char *> ( alloc ( heap_size ));
     char *vec_base = heap_block;
     
     if ( NULL != vec_base ) {
         st_heap_block3 heap ( dealloc, heap_block, heap_size );
 
     //  put the padding before the array elements

 // copy each element from the source array to the destination array. The
 // copy constructor's arguments are the destination address and source
 // address, respectively. If an exception occurs, call the given destructor
 // (if non-NULL) on each copied element and rethrow. If the destructor
 // throws an exception, call terminate(). The constructor and or destructor
 // pointers may be NULL. If either is NULL, no action is taken when it
 // would have been called.
 
-void __cxa_vec_cctor( void*  dest_array, void*  src_array, 
-    size_t element_count, size_t element_size, 
-        void  (*constructor) (void*, void*), void  (*destructor)(void*) ) {
-
+_LIBCXXABI_FUNC_VIS void __cxa_vec_cctor(void *dest_array, void *src_array,
+                                         size_t element_count,
+                                         size_t element_size,
+                                         void (*constructor)(void *, void *),
+                                         void (*destructor)(void *)) {
     if ( NULL != constructor ) {
         size_t idx = 0;
         char *src_ptr  = static_cast<char *>(src_array);
         char *dest_ptr = static_cast<char *>(dest_array);
         st_cxa_cleanup cleanup ( dest_array, idx, element_size, destructor );        
 
         for ( idx = 0; idx < element_count; 
                     ++idx, src_ptr += element_size, dest_ptr += element_size )
             constructor ( dest_ptr, src_ptr );
         cleanup.release ();     // We're good!
     }
 }
 
 
 // Given the (data) address of an array, not including any cookie padding,
 // and the number and size of its elements, call the given constructor on
 // each element. If the constructor throws an exception, call the given
 // destructor for any already-constructed elements, and rethrow the
 // exception. If the destructor throws an exception, call terminate(). The
 // constructor and/or destructor pointers may be NULL. If either is NULL,
 // no action is taken when it would have been called.
-void __cxa_vec_ctor(
-    void*  array_address, size_t element_count, size_t element_size, 
-       void (*constructor)(void*), void (*destructor)(void*) ) {
-
+_LIBCXXABI_FUNC_VIS void
+__cxa_vec_ctor(void *array_address, size_t element_count, size_t element_size,
+               void (*constructor)(void *), void (*destructor)(void *)) {
     if ( NULL != constructor ) {
         size_t idx;
         char *ptr = static_cast <char *> ( array_address );
         st_cxa_cleanup cleanup ( array_address, idx, element_size, destructor );        
         
     //  Construct the elements
         for ( idx = 0; idx < element_count; ++idx, ptr += element_size )
             constructor ( ptr );
         cleanup.release ();     // We're good!
     }
 }
 
 // Given the (data) address of an array, the number of elements, and the
 // size of its elements, call the given destructor on each element. If the
 // destructor throws an exception, rethrow after destroying the remaining
 // elements if possible. If the destructor throws a second exception, call
 // terminate(). The destructor pointer may be NULL, in which case this
 // routine does nothing.
-void __cxa_vec_dtor(
-    void*  array_address, size_t element_count, size_t element_size, 
-       void (*destructor)(void*) ) {
-    
+_LIBCXXABI_FUNC_VIS void __cxa_vec_dtor(void *array_address,
+                                        size_t element_count,
+                                        size_t element_size,
+                                        void (*destructor)(void *)) {
     if ( NULL != destructor ) {
         char *ptr = static_cast <char *> (array_address);
         size_t idx = element_count;
         st_cxa_cleanup cleanup ( array_address, idx, element_size, destructor );        
         {
             st_terminate exception_guard (__cxa_uncaught_exception ());
             ptr +=  element_count * element_size;   // one past the last element
 
             while ( idx-- > 0 ) {
                 ptr -= element_size;
                 destructor ( ptr );
             }
             exception_guard.release (); //  We're good !
         }
         cleanup.release ();     // We're still good!
     }
 }
 
 // Given the (data) address of an array, the number of elements, and the
 // size of its elements, call the given destructor on each element. If the
 // destructor throws an exception, call terminate(). The destructor pointer
 // may be NULL, in which case this routine does nothing.
-void __cxa_vec_cleanup( void* array_address, size_t element_count,
-        size_t element_size, void  (*destructor)(void*) ) {
-
+_LIBCXXABI_FUNC_VIS void __cxa_vec_cleanup(void *array_address,
+                                           size_t element_count,
+                                           size_t element_size,
+                                           void (*destructor)(void *)) {
     if ( NULL != destructor ) {
         char *ptr = static_cast <char *> (array_address);
         size_t idx = element_count;
         st_terminate exception_guard;
         
         ptr += element_count * element_size;    // one past the last element
         while ( idx-- > 0 ) {
             ptr -= element_size;

 // The intent of this function is to permit an implementation to call this
 // function when confronted with an expression of the form delete[] p in
 // the source code, provided that the default deallocation function can be
 // used. Therefore, the semantics of this function are consistent with
 // those required by the standard. The requirement that the deallocation
 // function be called even if the destructor throws an exception derives
 // from the resolution to DR 353 to the C++ standard, which was adopted in
 // April, 2003.
-void __cxa_vec_delete( void* array_address,
-        size_t element_size, size_t padding_size, void  (*destructor)(void*) ) {
-
-    __cxa_vec_delete2 ( array_address, element_size, padding_size,
-               destructor, &::operator delete [] );
+_LIBCXXABI_FUNC_VIS void __cxa_vec_delete(void *array_address,
+                                          size_t element_size,
+                                          size_t padding_size,
+                                          void (*destructor)(void *)) {
+  __cxa_vec_delete2(array_address, element_size, padding_size, destructor,
+                    &::operator delete[]);
 }
 
-
 // Same as __cxa_vec_delete, except that the given function is used for
 // deallocation instead of the default delete function. If dealloc throws
 // an exception, the result is undefined. The dealloc pointer may not be
 // NULL.
-void __cxa_vec_delete2( void* array_address,
-        size_t element_size, size_t padding_size, 
-        void  (*destructor)(void*), void  (*dealloc)(void*) ) {
-
+_LIBCXXABI_FUNC_VIS void
+__cxa_vec_delete2(void *array_address, size_t element_size, size_t padding_size,
+                  void (*destructor)(void *), void (*dealloc)(void *)) {
     if ( NULL != array_address ) {
         char *vec_base   = static_cast <char *> (array_address);
         char *heap_block = vec_base - padding_size;
         st_heap_block2 heap ( dealloc, heap_block );
         
         if ( 0 != padding_size && NULL != destructor ) // call the destructors
             __cxa_vec_dtor ( array_address, __get_element_count ( vec_base ), 
                                     element_size, destructor );
     }
 }
 
 
 // Same as __cxa_vec_delete, except that the given function is used for
 // deallocation instead of the default delete function. The deallocation
 // function takes both the object address and its size. If dealloc throws
 // an exception, the result is undefined. The dealloc pointer may not be
 // NULL.
-void __cxa_vec_delete3( void* array_address, 
-        size_t element_size, size_t padding_size, 
-        void  (*destructor)(void*), void  (*dealloc) (void*, size_t)) {
-
+_LIBCXXABI_FUNC_VIS void
+__cxa_vec_delete3(void *array_address, size_t element_size, size_t padding_size,
+                  void (*destructor)(void *), void (*dealloc)(void *, size_t)) {
     if ( NULL != array_address ) {
         char *vec_base   = static_cast <char *> (array_address);
         char *heap_block = vec_base - padding_size;
         const size_t element_count = padding_size ? __get_element_count ( vec_base ) : 0;
         const size_t heap_block_size = element_size * element_count + padding_size;
         st_heap_block3 heap ( dealloc, heap_block, heap_block_size );
 
         if ( 0 != padding_size && NULL != destructor ) // call the destructors
             __cxa_vec_dtor ( array_address, element_count, element_size, destructor );
     }
 }
 
 
 }  // extern "C"
 
 }  // abi

src/cxa_virtual.cpp

 //===-------------------------- cxa_virtual.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.h"
 #include "abort_message.h"
 
-namespace __cxxabiv1
-{
-
-extern "C"
-{
-
-LIBCXXABI_NORETURN
-void __cxa_pure_virtual(void) {
-    abort_message("Pure virtual function called!");
+namespace __cxxabiv1 {
+extern "C" {
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_pure_virtual(void) {
 }
 
-LIBCXXABI_NORETURN
-void __cxa_deleted_virtual(void) {
-    abort_message("Deleted virtual function called!");
+_LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_deleted_virtual(void) {
 }
-
-}  // extern "C"
-
-}  // abi
+} // extern "C"
+} // abi

src/private_typeinfo.h

 //===------------------------ private_typeinfo.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 __PRIVATE_TYPEINFO_H_
 #define __PRIVATE_TYPEINFO_H_
 
+#include "__cxxabi_config.h"
+
 #include <typeinfo>
 #include <cstddef>
 
-namespace __cxxabiv1
-{
+namespace __cxxabiv1 {
 
 #pragma GCC visibility push(hidden)
 
-class __attribute__ ((__visibility__("default"))) __shim_type_info
-    : public std::type_info
-{
+class _LIBCXXABI_TYPE_VIS __shim_type_info : public std::type_info {
 public:
-     __attribute__ ((__visibility__("hidden"))) virtual ~__shim_type_info();
+  _LIBCXXABI_HIDDEN virtual ~__shim_type_info();
 
-     __attribute__ ((__visibility__("hidden"))) virtual void noop1() const;
-     __attribute__ ((__visibility__("hidden"))) virtual void noop2() const;
-     __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info* thrown_type, void*& adjustedPtr) const = 0;
+  _LIBCXXABI_HIDDEN virtual void noop1() const;
+  _LIBCXXABI_HIDDEN virtual void noop2() const;
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *thrown_type,
+                                           void *&adjustedPtr) const = 0;
 };
 
-class __attribute__ ((__visibility__("default"))) __fundamental_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __fundamental_type_info : public __shim_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__fundamental_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+  _LIBCXXABI_HIDDEN virtual ~__fundamental_type_info();
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                           void *&) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __array_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __array_type_info : public __shim_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__array_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+  _LIBCXXABI_HIDDEN virtual ~__array_type_info();
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                           void *&) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __function_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __function_type_info : public __shim_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__function_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+  _LIBCXXABI_HIDDEN virtual ~__function_type_info();
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                           void *&) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __enum_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __enum_type_info : public __shim_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__enum_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+  _LIBCXXABI_HIDDEN virtual ~__enum_type_info();
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                           void *&) const;
 };
 
 enum
 {
     unknown = 0,
     public_path,
     not_public_path,
     yes,
     no
 };
 
-class __attribute__ ((__visibility__("default"))) __class_type_info;
+class _LIBCXXABI_TYPE_VIS __class_type_info;
 
 struct __dynamic_cast_info
 {
 // const data supplied to the search:
 
     const __class_type_info* dst_type;
     const void* static_ptr;
     const __class_type_info* static_type;
// Data that helps stop the search before the entire tree is searched:
     // communicates to a dst_type node that a static_type was found
     //    above it, but it wasn't (static_ptr, static_type)
     bool found_any_static_type;
     // Set whenever a search can be stopped
     bool search_done;
 };
 
 // Has no base class
-class __attribute__ ((__visibility__("default"))) __class_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __class_type_info : public __shim_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__class_type_info();
+  _LIBCXXABI_HIDDEN virtual ~__class_type_info();
 
-    __attribute__ ((__visibility__("hidden")))
-        void process_static_type_above_dst(__dynamic_cast_info*, const void*, const void*, int) const;
-    __attribute__ ((__visibility__("hidden")))
-        void process_static_type_below_dst(__dynamic_cast_info*, const void*, int) const;
-    __attribute__ ((__visibility__("hidden")))
-        void process_found_base_class(__dynamic_cast_info*, void*, int) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_above_dst(__dynamic_cast_info*, const void*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_below_dst(__dynamic_cast_info*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual bool can_catch(const __shim_type_info*, void*&) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void has_unambiguous_public_base(__dynamic_cast_info*, void*, int) const;
+  _LIBCXXABI_HIDDEN
+  void process_static_type_above_dst(__dynamic_cast_info *, const void *,
+                                     const void *, int) const;
+  _LIBCXXABI_HIDDEN
+  void process_static_type_below_dst(__dynamic_cast_info *, const void *,
+                                     int) const;
+  _LIBCXXABI_HIDDEN
+  void process_found_base_class(__dynamic_cast_info *, void *, int) const;
+  _LIBCXXABI_HIDDEN
+  virtual void search_above_dst(__dynamic_cast_info *, const void *,
+                                const void *, int, bool) const;
+  _LIBCXXABI_HIDDEN
+  virtual void search_below_dst(__dynamic_cast_info *, const void *, int,
+                                bool) const;
+  _LIBCXXABI_HIDDEN
+  virtual bool can_catch(const __shim_type_info *, void *&) const;
+  _LIBCXXABI_HIDDEN
+  virtual void has_unambiguous_public_base(__dynamic_cast_info *, void *,
+                                           int) const;
 };
 
 // Has one non-virtual public base class at offset zero
-class __attribute__ ((__visibility__("default"))) __si_class_type_info
-    : public __class_type_info
-{
+class _LIBCXXABI_TYPE_VIS __si_class_type_info : public __class_type_info {
 public:
-    const __class_type_info* __base_type;
+  const __class_type_info *__base_type;
 
-    __attribute__ ((__visibility__("hidden"))) virtual ~__si_class_type_info();
+  _LIBCXXABI_HIDDEN virtual ~__si_class_type_info();
 
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_above_dst(__dynamic_cast_info*, const void*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_below_dst(__dynamic_cast_info*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void has_unambiguous_public_base(__dynamic_cast_info*, void*, int) const;
+  _LIBCXXABI_HIDDEN
+  virtual void search_above_dst(__dynamic_cast_info *, const void *,
+                                const void *, int, bool) const;
+  _LIBCXXABI_HIDDEN
+  virtual void search_below_dst(__dynamic_cast_info *, const void *, int,
+                                bool) const;
+  _LIBCXXABI_HIDDEN
+  virtual void has_unambiguous_public_base(__dynamic_cast_info *, void *,
+                                           int) const;
 };
 
 struct __base_class_type_info
 {
 public:
     const __class_type_info* __base_type;
     long __offset_flags;
 
     enum __offset_flags_masks
     {
         __virtual_mask = 0x1,
         __public_mask  = 0x2, // base is public
         __offset_shift = 8
     };
 
     void search_above_dst(__dynamic_cast_info*, const void*, const void*, int, bool) const;
     void search_below_dst(__dynamic_cast_info*, const void*, int, bool) const;
     void has_unambiguous_public_base(__dynamic_cast_info*, void*, int) const;
 };
 
 // Has one or more base classes
-class __attribute__ ((__visibility__("default"))) __vmi_class_type_info
-    : public __class_type_info
-{
+class _LIBCXXABI_TYPE_VIS __vmi_class_type_info : public __class_type_info {
 public:
     unsigned int __flags;
     unsigned int __base_count;
     __base_class_type_info __base_info[1];
 
     enum __flags_masks
     {
         __non_diamond_repeat_mask = 0x1,  // has two or more distinct base class
                                           //    objects of the same type
         __diamond_shaped_mask     = 0x2   // has base class object with two or
                                           //    more derived objects
     };
 
-    __attribute__ ((__visibility__("hidden"))) virtual ~__vmi_class_type_info();
+    _LIBCXXABI_HIDDEN virtual ~__vmi_class_type_info();
 
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_above_dst(__dynamic_cast_info*, const void*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void search_below_dst(__dynamic_cast_info*, const void*, int, bool) const;
-    __attribute__ ((__visibility__("hidden")))
-        virtual void has_unambiguous_public_base(__dynamic_cast_info*, void*, int) const;
+    _LIBCXXABI_HIDDEN
+    virtual void search_above_dst(__dynamic_cast_info *, const void *,
+                                  const void *, int, bool) const;
+    _LIBCXXABI_HIDDEN
+    virtual void search_below_dst(__dynamic_cast_info *, const void *, int,
+                                  bool) const;
+    _LIBCXXABI_HIDDEN
+    virtual void has_unambiguous_public_base(__dynamic_cast_info *, void *,
+                                             int) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __pbase_type_info
-    : public __shim_type_info
-{
+class _LIBCXXABI_TYPE_VIS __pbase_type_info : public __shim_type_info {
 public:
     unsigned int __flags;
     const __shim_type_info* __pointee;
 
     enum __masks
     {
         __const_mask            = 0x1,
         __volatile_mask         = 0x2,
         __restrict_mask         = 0x4,
         __incomplete_mask       = 0x8,
         __incomplete_class_mask = 0x10
     };
 
-    __attribute__ ((__visibility__("hidden"))) virtual ~__pbase_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
+    _LIBCXXABI_HIDDEN virtual ~__pbase_type_info();
+    _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                             void *&) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __pointer_type_info
-    : public __pbase_type_info
-{
+class _LIBCXXABI_TYPE_VIS __pointer_type_info : public __pbase_type_info {
 public:
-    __attribute__ ((__visibility__("hidden"))) virtual ~__pointer_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
-    __attribute__ ((__visibility__("hidden"))) bool can_catch_nested(const __shim_type_info*) const;
+  _LIBCXXABI_HIDDEN virtual ~__pointer_type_info();
+  _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                           void *&) const;
+  _LIBCXXABI_HIDDEN bool can_catch_nested(const __shim_type_info *) const;
 };
 
-class __attribute__ ((__visibility__("default"))) __pointer_to_member_type_info
-    : public __pbase_type_info
-{
+class _LIBCXXABI_TYPE_VIS __pointer_to_member_type_info
+    : public __pbase_type_info {
 public:
     const __class_type_info* __context;
 
-    __attribute__ ((__visibility__("hidden"))) virtual ~__pointer_to_member_type_info();
-    __attribute__ ((__visibility__("hidden"))) virtual bool can_catch(const __shim_type_info*, void*&) const;
-    __attribute__ ((__visibility__("hidden"))) bool can_catch_nested(const __shim_type_info*) const;
+    _LIBCXXABI_HIDDEN virtual ~__pointer_to_member_type_info();
+    _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *,
+                                             void *&) const;
+    _LIBCXXABI_HIDDEN bool can_catch_nested(const __shim_type_info *) const;
 };
 
 #pragma GCC visibility pop
 
 }  // __cxxabiv1
 
 #endif  // __PRIVATE_TYPEINFO_H_