[libc++abi] Clean up visibility

[smeenai]

Summary

Use the libc++abi visibility macros instead of pragmas or using
visibility attributes directly. Clean up redundant attributes on
definitions (where the declarations already have visibility attributes
applied, from either libc++ or libc++abi headers).

Introduce _LIBCXXABI_WEAK as a drive-by cleanup, which matches the
semantics of _LIBCPP_WEAK.

No functional change. Tested by building on Linux before and after this
change and verifying that the list of exported symbols is identical.

[smeenai]

Ping.

Lmk if there's any other tests I should run on this to ensure there's no functional difference.

[compnerd]

I really like the clean up this does. It removes the unnecessary usage of the GCC pragmas and cleans up the definitions by using the headers more properly.

src/abort_message.h

19 ↗

(On Diff #78807)

Please clang-format this declaration.

src/private_typeinfo.cpp

61 ↗

(On Diff #78807)

I think that if you are making this static inline, we should hoist this out into a standalone helper outside of the __cxxabiv1 namespace.

[smeenai]

Addressing @compnerd's comments

[smeenai]

Ping.

[smeenai]

Ping.

[smeenai]

Ping.

[EricWF]

src/abort_message.cpp

25 ↗

(On Diff #80361)

Is this really redundant? There is an #include <CrashReporterClient.h> after it. Is this not going to affect those symbols?

src/cxa_handlers.hpp

23 ↗

(On Diff #80361)

_LIBCXXABI_HIDDEN LIBCXXABI_NORETURN?

27 ↗

(On Diff #80361)

_LIBCXXABI_HIDDEN LIBCXXABI_NORETURN?

src/cxa_new_delete.cpp

34 ↗

(On Diff #80361)

Can we abstract this away to a _LIBCXXABI_NEW_DELETE_VIS macro?

[compnerd]

src/cxa_new_delete.cpp

34 ↗

(On Diff #80361)

Are operator new and operator delete the only functions that will ever need weak linkage? I think that using a more generic macro would be nicer. _LIBCXXABI_WEAK_LINKAGE perhaps?

[smeenai]

Addressing comments

[smeenai]

src/abort_message.cpp

25 ↗

(On Diff #80361)

That's a fair point. I think it's kinda unusual to wrap a header file this way (we don't do it for any other system headers, for example), and the header file in question appears to be Apple-internal, so I don't know if it's necessary. I can leave it in place for just the header file inclusion if you prefer, however.

[smeenai]

Rebase

[EricWF]

LGTM minus inline comments.

@smeenai confirmed that this patch doesn't change the ABI list for libc++abi.dylib using sym_check.py.

src/abort_message.h

19 ↗

(On Diff #87362)

LIBCXXABI_NORETURN?

[smeenai]

src/abort_message.h

19 ↗

(On Diff #87362)

That would also require changing the __cxxabi_config.h include to a cxxabi.h include (since that's where _LIBCXXABI_NORETURN is defined). Is that acceptable?

[smeenai]

Addressing inline comment

libcxxabi/trunk/include/__cxxabi_config.h

  #else
   #define _LIBCXXABI_HIDDEN
   #define _LIBCXXABI_DATA_VIS
   #define _LIBCXXABI_FUNC_VIS
   #define _LIBCXXABI_TYPE_VIS
  #endif
 #endif
 
+#if defined(_WIN32)
+#define _LIBCXXABI_WEAK
+#else
+#define _LIBCXXABI_WEAK __attribute__((__weak__))
+#endif
+
 #endif // ____CXXABI_CONFIG_H

libcxxabi/trunk/src/abort_message.h

 //===-------------------------- abort_message.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 __ABORT_MESSAGE_H_
 #define __ABORT_MESSAGE_H_
 
-#include <stdio.h>
-
-#pragma GCC visibility push(hidden)
+#include "cxxabi.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-__attribute__((visibility("hidden"), noreturn))
-       void abort_message(const char* format, ...) 
-            __attribute__((format(printf, 1, 2)));
-
+_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN void
+abort_message(const char *format, ...) __attribute__((format(printf, 1, 2)));
 
 #ifdef __cplusplus
 }
 #endif
 
-#pragma GCC visibility pop
-
 #endif
 

libcxxabi/trunk/src/abort_message.cpp

 #if __ANDROID_API__ >= 21
 #include <syslog.h>
 extern "C" void android_set_abort_message(const char* msg);
 #else
 #include <assert.h>
 #endif // __ANDROID_API__ >= 21
 #endif // __BIONIC__
 
-#pragma GCC visibility push(hidden)
-
 #ifdef __APPLE__
 #   if defined(__has_include) && __has_include(<CrashReporterClient.h>)
 #       define HAVE_CRASHREPORTERCLIENT_H
 #       include <CrashReporterClient.h>
 #   endif
 #endif
 
-__attribute__((visibility("hidden"), noreturn))
 void abort_message(const char* format, ...)
 {
     // write message to stderr
 #if !defined(NDEBUG) || !LIBCXXABI_BAREMETAL
 #ifdef __APPLE__
     fprintf(stderr, "libc++abi.dylib: ");
 #endif
     va_list list;
#else
     // about to abort anyway, just call __assert2, which will log _somewhere_
     // (tombstone and/or logcat) in older releases.
     __assert2(__FILE__, __LINE__, __func__, buffer);
 #endif // __ANDROID_API__ >= 21
 #endif // __BIONIC__
 
     abort();
 }
-
-#pragma GCC visibility pop

libcxxabi/trunk/src/cxa_exception.hpp

 #define _CXA_EXCEPTION_H
 
 #include <exception> // for std::unexpected_handler and std::terminate_handler
 #include <cxxabi.h>
 #include "unwind.h"
 
 namespace __cxxabiv1 {
 
-#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 {
+struct _LIBCXXABI_HIDDEN __cxa_exception {
 #if defined(__LP64__) || _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
 

 #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 {
+struct _LIBCXXABI_HIDDEN __cxa_dependent_exception {
 #if defined(__LP64__) || _LIBCXXABI_ARM_EHABI
     void* primaryException;
 #endif
 
     std::type_info *exceptionType;
     void (*exceptionDestructor)(void *);
     std::unexpected_handler unexpectedHandler;
     std::terminate_handler terminateHandler;

 
 #if !defined(__LP64__) && !_LIBCXXABI_ARM_EHABI
     void* primaryException;
 #endif
 
     _Unwind_Exception unwindHeader;
 };
 
-struct __cxa_eh_globals {
+struct _LIBCXXABI_HIDDEN __cxa_eh_globals {
     __cxa_exception *   caughtExceptions;
     unsigned int        uncaughtExceptions;
 #if _LIBCXXABI_ARM_EHABI
     __cxa_exception* propagatingExceptions;
 #endif
 };
 
-#pragma GCC visibility pop
-#pragma GCC visibility push(default)
-
-extern "C" __cxa_eh_globals * __cxa_get_globals      ();
-extern "C" __cxa_eh_globals * __cxa_get_globals_fast ();
-
-extern "C" void * __cxa_allocate_dependent_exception ();
-extern "C" void __cxa_free_dependent_exception (void * dependent_exception);
+extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals      ();
+extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals_fast ();
 
-#pragma GCC visibility pop
+extern "C" _LIBCXXABI_FUNC_VIS void * __cxa_allocate_dependent_exception ();
+extern "C" _LIBCXXABI_FUNC_VIS void __cxa_free_dependent_exception (void * dependent_exception);
 
 }  // namespace __cxxabiv1
 
 #endif  // _CXA_EXCEPTION_H

libcxxabi/trunk/src/cxa_exception.cpp

 //   +-------------------------------------------------------+
 //   |
 // +---------------------------+-----------------------------+
 // | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 |
 // +---------------------------+-----------------------------+
 
 namespace __cxxabiv1 {
 
-#pragma GCC visibility push(default)
-
 //  Utility routines
 static
 inline
 __cxa_exception*
 cxa_exception_from_thrown_object(void* thrown_object)
 {
     return static_cast<__cxa_exception*>(thrown_object) - 1;
 }

 
 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.
-_LIBCXXABI_FUNC_VIS void *__cxa_allocate_exception(size_t thrown_size) throw() {
+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 *>(__malloc_with_fallback(actual_size));
     if (NULL == exception_header)
         std::terminate();
     std::memset(exception_header, 0, actual_size);
     return thrown_object_from_cxa_exception(exception_header);
 }
 
 
 //  Free a __cxa_exception object allocated with __cxa_allocate_exception.
-_LIBCXXABI_FUNC_VIS void __cxa_free_exception(void *thrown_object) throw() {
+void __cxa_free_exception(void *thrown_object) throw() {
     __free_with_fallback(cxa_exception_from_thrown_object(thrown_object));
 }
 
 
 //  This function shall allocate a __cxa_dependent_exception and
 //  return a pointer to it. (Really to the object, not past its' end).
 //  Otherwise, it will work like __cxa_allocate_exception.
 void * __cxa_allocate_dependent_exception () {

 * 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_FUNC_VIS _LIBCXXABI_NORETURN void
+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;

 // 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
 */
-_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.
 */
-_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 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.
 */
-_LIBCXXABI_FUNC_VIS void __cxa_end_catch() {
+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.
-_LIBCXXABI_FUNC_VIS std::type_info *__cxa_current_exception_type() {
+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_FUNC_VIS _LIBCXXABI_NORETURN void __cxa_rethrow() {
+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.
 */
-_LIBCXXABI_FUNC_VIS void
+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.
 */
-_LIBCXXABI_FUNC_VIS void
+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.
 */
-_LIBCXXABI_FUNC_VIS void *__cxa_current_primary_exception() throw() {
+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))
__cxa_uncaught_exceptions() throw()
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
     if (globals == 0)
         return 0;
     return globals->uncaughtExceptions;
 }
 
 }  // extern "C"
 
-#pragma GCC visibility pop
-
 }  // abi

libcxxabi/trunk/src/cxa_handlers.hpp

 
 #include <__cxxabi_config.h>
 
 #include <exception>
 
 namespace std
 {
 
-__attribute__((visibility("hidden"), noreturn))
+_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
 void
 __unexpected(unexpected_handler func);
 
-__attribute__((visibility("hidden"), noreturn))
+_LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN
 void
 __terminate(terminate_handler func) _NOEXCEPT;
 
 }  // std
 
 extern "C"
 {
 

libcxxabi/trunk/src/cxa_handlers.cpp

 get_unexpected() _NOEXCEPT
 {
     return __sync_fetch_and_add(&__cxa_unexpected_handler, (unexpected_handler)0);
 //  The above is safe but overkill on x86
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_unexpected_handler.load(memory_order_acq);
 }
 
-__attribute__((visibility("hidden"), noreturn))
 void
 __unexpected(unexpected_handler func)
 {
     func();
     // unexpected handler should not return
     abort_message("unexpected_handler unexpectedly returned");
 }
 
 __attribute__((noreturn))
 void
 unexpected()
 {
     __unexpected(get_unexpected());
 }
 
 terminate_handler
 get_terminate() _NOEXCEPT
 {
     return __sync_fetch_and_add(&__cxa_terminate_handler, (terminate_handler)0);
 //  The above is safe but overkill on x86
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_terminate_handler.load(memory_order_acq);
 }
 
-__attribute__((visibility("hidden"), noreturn))
 void
 __terminate(terminate_handler func) _NOEXCEPT
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCXXABI_NO_EXCEPTIONS
         func();
if (globals)
         }
     }
     __terminate(get_terminate());
 }
 
 // In the future this will become:
 // std::atomic<std::new_handler>  __cxa_new_handler(0);
 extern "C" {
-_LIBCXXABI_DATA_VIS new_handler __cxa_new_handler = 0;
+new_handler __cxa_new_handler = 0;
 }
 
 new_handler
 set_new_handler(new_handler handler) _NOEXCEPT
 {
     return __atomic_exchange_n(&__cxa_new_handler, handler, __ATOMIC_ACQ_REL);
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_new_handler.exchange(handler, memory_order_acq_rel);

libcxxabi/trunk/src/cxa_new_delete.cpp

 //===------------------------ cxa_new_delete.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 new and delete operators.
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_NEW
 
+#include "__cxxabi_config.h"
 #include <new>
 #include <cstdlib>
 
 #if !defined(_THROW_BAD_ALLOC) || !defined(_NOEXCEPT)
 #error _THROW_BAD_ALLOC and _NOEXCEPT libc++ macros must already be defined \
        by libc++.
 #endif
 
* Returns a pointer to the allocated storage if the attempt is successful.
   throws bad_alloc.
 
 * Otherwise, the function calls the current new_handler function (18.6.2.3).
   If the called function returns, the loop repeats.
 
 * The loop terminates when an attempt to allocate the requested storage is
   successful or when a called new_handler function does not return.
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC
 {
     if (size == 0)
         size = 1;
     void* p;
     while ((p = std::malloc(size)) == 0)
     {

 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2158.html
 */
 /*
 [new.delete.single]
 
 Calls operator new(size). If the call returns normally, returns the result of
 that call. Otherwise, returns a null pointer.
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void*
 operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 {
     void* p = 0;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif
         p = ::operator new(size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif
     return p;
 }
 
 /*
 [new.delete.array]
 
 Returns operator new(size).
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void*
 operator new[](size_t size) _THROW_BAD_ALLOC
 {
     return ::operator new(size);
 }
 
 /*
 [new.delete.array]
 
 Calls operator new[](size). If the call returns normally, returns the result
 of that call. Otherwise, returns a null pointer.
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void*
 operator new[](size_t size, const std::nothrow_t&) _NOEXCEPT
 {
     void* p = 0;
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif
         p = ::operator new[](size);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
 #endif
     return p;
 }
 
 /*
 [new.delete.single]
 
 If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the
 earlier call to operator new.
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void
 operator delete(void* ptr) _NOEXCEPT
 {
     if (ptr)
         std::free(ptr);
 }
 
 /*
 [new.delete.single]
 
 calls operator delete(ptr)
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void
 operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
 /*
 [new.delete.array]
 
 Calls operator delete(ptr)
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void
 operator delete[] (void* ptr) _NOEXCEPT
 {
     ::operator delete(ptr);
 }
 
 /*
 [new.delete.array]
 
 calls operator delete[](ptr)
 */
-__attribute__((__weak__, __visibility__("default")))
+_LIBCXXABI_WEAK
 void
 operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
 {
     ::operator delete[](ptr);
 }
 
 namespace std
 {

libcxxabi/trunk/src/cxa_noexception.cpp

 #include "cxxabi.h"
 
 #include <exception>        // for std::terminate
 #include "cxa_exception.hpp"
 #include "cxa_handlers.hpp"
 
 namespace __cxxabiv1 {
 
-#pragma GCC visibility push(default)
-
 extern "C" {
 
 void
 __cxa_increment_exception_refcount(void *thrown_object) throw() {
     if (thrown_object != nullptr)
         std::terminate();
 }
 

 bool
 __cxa_uncaught_exception() throw() { return false; }
 
 unsigned int
 __cxa_uncaught_exceptions() throw() { return 0; }
 
 }  // extern "C"
 
-#pragma GCC visibility pop
-
 }  // abi

libcxxabi/trunk/src/cxa_thread_atexit.cpp

 namespace __cxxabiv1 {
 
   using Dtor = void(*)(void*);
 
   extern "C"
 #ifndef HAVE___CXA_THREAD_ATEXIT_IMPL
   // A weak symbol is used to detect this function's presence in the C library
   // at runtime, even if libc++ is built against an older libc
-  __attribute__((__weak__))
+  _LIBCXXABI_WEAK
 #endif
   int __cxa_thread_atexit_impl(Dtor, void*, void*);
 
 #ifndef HAVE___CXA_THREAD_ATEXIT_IMPL
 
 namespace {
   // This implementation is used if the C library does not provide
   // __cxa_thread_atexit_impl() for us.  It has a number of limitations that are

libcxxabi/trunk/src/cxa_unexpected.cpp

 //===------------------------- cxa_unexpected.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 <exception>
 #include <cxxabi.h>
 #include "cxa_exception.hpp"
 
 namespace __cxxabiv1
 {
 
-#pragma GCC visibility push(default)
-
 extern "C"
 {
 
 }
 
-#pragma GCC visibility pop
-
 }  // namespace __cxxabiv1
 

libcxxabi/trunk/src/fallback_malloc.h

 //===------------------------- fallback_malloc.h --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _FALLBACK_MALLOC_H
 #define _FALLBACK_MALLOC_H
 
+#include "__cxxabi_config.h"
 #include <cstddef> // for size_t
 
 namespace __cxxabiv1 {
 
-#pragma GCC visibility push(hidden)
-
 // Allocate some memory from _somewhere_
-void * __malloc_with_fallback(size_t size);
+_LIBCXXABI_HIDDEN void * __malloc_with_fallback(size_t size);
 
 // Allocate and zero-initialize memory from _somewhere_
-void * __calloc_with_fallback(size_t count, size_t size);
-
-void __free_with_fallback(void *ptr);
+_LIBCXXABI_HIDDEN void * __calloc_with_fallback(size_t count, size_t size);
 
-#pragma GCC visibility pop
+_LIBCXXABI_HIDDEN void __free_with_fallback(void *ptr);
 
 } // namespace __cxxabiv1
 
 #endif

libcxxabi/trunk/src/fallback_malloc.cpp

size_t print_free_list () {
     std::cout << "Total Free space: " << total_free << std::endl;
     return total_free;
     }
 #endif
 }  // end unnamed namespace
 
 namespace __cxxabiv1 {
 
-#pragma GCC visibility push(hidden)
-
 void * __malloc_with_fallback(size_t size) {
     void *ptr = std::malloc(size);
     if (NULL == ptr) // if malloc fails, fall back to emergency stash
         ptr = fallback_malloc(size);
     return ptr;
 }
 
 void * __calloc_with_fallback(size_t count, size_t size) {

 
 void __free_with_fallback(void *ptr) {
     if (is_fallback_ptr(ptr))
         fallback_free(ptr);
     else
         std::free(ptr);
 }
 
-#pragma GCC visibility pop
-
 } // namespace __cxxabiv1

libcxxabi/trunk/src/private_typeinfo.h

 #define __PRIVATE_TYPEINFO_H_
 
 #include "__cxxabi_config.h"
 
 #include <typeinfo>
 #include <cstddef>
 
 namespace __cxxabiv1 {
-#pragma GCC visibility push(hidden)
 
 class _LIBCXXABI_TYPE_VIS __shim_type_info : public std::type_info {
 public:
   _LIBCXXABI_HIDDEN virtual ~__shim_type_info();
 
   _LIBCXXABI_HIDDEN virtual void noop1() const;
   _LIBCXXABI_HIDDEN virtual void noop2() const;
   _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *thrown_type,
enum
     public_path,
     not_public_path,
     yes,
     no
 };
 
 class _LIBCXXABI_TYPE_VIS __class_type_info;
 
-struct __dynamic_cast_info
+struct _LIBCXXABI_HIDDEN __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;
     std::ptrdiff_t src2dst_offset;
 
_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
+struct _LIBCXXABI_HIDDEN __base_class_type_info
 {
 public:
     const __class_type_info* __base_type;
     long __offset_flags;
 
     enum __offset_flags_masks
     {
         __virtual_mask = 0x1,
public:
   const __class_type_info *__context;
 
   _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_

libcxxabi/trunk/src/private_typeinfo.cpp

 //
 // Defining _LIBCXX_DYNAMIC_FALLBACK does not help since can_catch() calls 
 // is_equal() with use_strcmp=false so the string names are not compared.
 
 #ifdef _WIN32
 #include <string.h>
 #endif
 
-namespace __cxxabiv1
-{
-
-#pragma GCC visibility push(hidden)
-
-inline
+static inline
 bool
 is_equal(const std::type_info* x, const std::type_info* y, bool use_strcmp)
 {
 #ifndef _WIN32
     if (!use_strcmp)
         return x == y;
     return strcmp(x->name(), y->name()) == 0;
 #else
     return (x == y) || (strcmp(x->name(), y->name()) == 0);
 #endif
 }
 
+namespace __cxxabiv1
+{
 
 // __shim_type_info
 
 __shim_type_info::~__shim_type_info()
 {
 }
 
 void __shim_type_info::noop1() const {}
if (!is_equal(__context, thrown_member_ptr_type->__context, false))
         return false;
     return true;
 }
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-#pragma GCC visibility pop
-#pragma GCC visibility push(default)
-
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
 #endif
 
 // __dynamic_cast
 
 // static_ptr: pointer to an object of type static_type; nonnull, and since the
#endif  // _LIBCXX_DYNAMIC_FALLBACK
     }
     return const_cast<void*>(dst_ptr);
 }
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-#pragma GCC visibility pop
-#pragma GCC visibility push(hidden)
-
 // Call this function when you hit a static_type which is a base (above) a dst_type.
 // Let caller know you hit a static_type.  But only start recording details if
 // this is (static_ptr, static_type) -- the node we are casting from.
 // If this is (static_ptr, static_type)
 //   Record the path (public or not) from the dst_type to here.  There may be
 //   multiple paths from the same dst_type to here, record the "most public" one.
 //   Record the dst_ptr as pointing to (static_ptr, static_type).
 //   If more than one (dst_ptr, dst_type) points to (static_ptr, static_type),
__base_class_type_info::search_below_dst(__dynamic_cast_info* info,
     __base_type->search_below_dst(info,
                                   static_cast<const char*>(current_ptr) + offset_to_base,
                                   (__offset_flags & __public_mask) ?
                                       path_below :
                                       not_public_path,
                                   use_strcmp);
 }
 
-#pragma GCC visibility pop
-
 }  // __cxxabiv1

libcxxabi/trunk/src/stdlib_exception.cpp

 //===---------------------------- exception.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 <exception>
 
-#pragma GCC visibility push(default)
-
 namespace std
 {
 
 // exception
 
 exception::~exception() _NOEXCEPT
 {
 }

 }
 
 const char* bad_exception::what() const _NOEXCEPT
 {
   return "std::bad_exception";
 }
 
 }  // std
-
-#pragma GCC visibility pop