Use __atomic_exchange_n with GCC instead of Clang's __sync_swap

[rnk]

Summary

This allows building libcxxabi with GCC on my system.

[rnk]

Alternatively, I could do what the comment says and use C++11 atomics. Do we know if we can do that yet?

[majnemer]

src/cxa_default_handlers.cpp

109–110 ↗

(On Diff #14390)

How about we just use __atomic_exchange_n instead of #ifdefing between the two?

Also, I'm pretty sure we can just use __ATOMIC_ACQ_REL here.

124–125 ↗

(On Diff #14390)

Ditto.

[rnk]

Look ma, no ifdefs!

[majnemer]

src/cxa_handlers.cpp

105 ↗

(On Diff #14396)

Why is the extern "C" removed from here? Looks unrelated.

[rnk]

src/cxa_handlers.cpp

105 ↗

(On Diff #14396)

I forgot to mention in the description that this was also necessary to silence this warning:
../projects/libcxxabi/src/cxa_handlers.cpp:105:24: warning: ‘cxa_new_handler’ initialized and declared ‘extern’
extern "C" new_handler cxa_new_handler = 0;

[majnemer]

LGTM

[rnk]

Closed by commit rL219012 (authored by @rnk).

[• jeremyhu]

The removal of the extern "C" introduced a binary compatibility regression as mentioned here:

https://llvm.org/bugs/show_bug.cgi?id=23238

libcxxabi/trunk/src/cxa_default_handlers.cpp

 // std::atomic<std::unexpected_handler> __cxa_unexpected_handler(default_unexpected_handler);
 
 namespace std
 {
 
 unexpected_handler
 set_unexpected(unexpected_handler func) _NOEXCEPT
 {
-  if (func == 0)
-    func = default_unexpected_handler;
-  return __sync_swap(&__cxa_unexpected_handler, func);
+    if (func == 0)
+        func = default_unexpected_handler;
+    return __atomic_exchange_n(&__cxa_unexpected_handler, func,
+                               __ATOMIC_ACQ_REL);
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_unexpected_handler.exchange(func, memory_order_acq_rel);
 }
 
 terminate_handler
 set_terminate(terminate_handler func) _NOEXCEPT
 {
-  if (func == 0)
-    func = default_terminate_handler;
-  return __sync_swap(&__cxa_terminate_handler, func);
+    if (func == 0)
+        func = default_terminate_handler;
+    return __atomic_exchange_n(&__cxa_terminate_handler, func,
+                               __ATOMIC_ACQ_REL);
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_terminate_handler.exchange(func, memory_order_acq_rel);
 }
 
 }

libcxxabi/trunk/src/cxa_handlers.cpp

if (globals)
                                (kOurExceptionClass & get_vendor_and_language);
             if (native_exception)
                 __terminate(exception_header->terminateHandler);
         }
     }
     __terminate(get_terminate());
 }
 
-extern "C" new_handler __cxa_new_handler = 0;
+new_handler __cxa_new_handler = 0;
 // In the future these will become:
 // std::atomic<std::new_handler>  __cxa_new_handler(0);
 
 new_handler
 set_new_handler(new_handler handler) _NOEXCEPT
 {
-    return __sync_swap(&__cxa_new_handler, handler);
+    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);
 }
 
 new_handler
 get_new_handler() _NOEXCEPT
 {
     return __sync_fetch_and_add(&__cxa_new_handler, (new_handler)0);
 //  The above is safe but overkill on x86
 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_new_handler.load(memory_order_acq);
 }
 
 }  // std