[libc++] Replace __sync_* functions with __libcpp_atomic_* functions

[weimingz]

Summary

include/atomic_support.h already handles case for _LIBCPP_HAS_NO_THREADS.
This patch reverts r307595, changes sync_* to libcpp_atomic_*, and adds a wrapper function for __atomic_exchange.

[weimingz]

rebased after reverting r307595 and moving __refstring header

[weimingz]

ping?

[weimingz]

rebased. Please review. Thanks

[weimingz]

ping @EricWF

[efriedma]

Ping.

[compnerd]

Why the additional inclusion of the support in the files which are not modified to use functions? (e.g. src/stdexcept.cpp). LG otherwise.

src/include/atomic_support.h

150 ↗

(On Diff #110041)

Really annoying that you can't immediately tell that this is in the _LIBCPP_NO_THREADS case, and thus the atomicity is not required.

[weimingz]

Moved the inclusion from stdexcept.cpp into refstring.h

For exception.cpp and new.cpp, I think it's better to keep the inclusion there. Those files include new_handler_fallback.ipp, exception_fallback.ipp, which need the header file. Including it in those .ipp requires relative path as "../../include/atomic_support.h" and I tried to avoid that.

[EricWF]

src/include/atomic_support.h

153 ↗

(On Diff #115891)

Initialize old on the same line it's declared on.

[weimingz]

minor change

libcxx/trunk/src/exception.cpp

 #include "support/runtime/exception_pointer_cxxabi.ipp"
 #elif defined(LIBCXXRT)
 #include "support/runtime/exception_libcxxrt.ipp"
 #include "support/runtime/exception_pointer_cxxabi.ipp"
 #elif defined(__GLIBCXX__)
 #include "support/runtime/exception_glibcxx.ipp"
 #include "support/runtime/exception_pointer_glibcxx.ipp"
 #else
+#include "include/atomic_support.h"
 #include "support/runtime/exception_fallback.ipp"
 #include "support/runtime/exception_pointer_unimplemented.ipp"
 #endif

libcxx/trunk/src/include/atomic_support.h

 #define ATOMIC_SUPPORT_H
 
 #include "__config"
 #include "memory" // for __libcpp_relaxed_load
 
 #if defined(__clang__) && __has_builtin(__atomic_load_n)             \
                        && __has_builtin(__atomic_store_n)            \
                        && __has_builtin(__atomic_add_fetch)          \
+                       && __has_builtin(__atomic_exchange_n)         \
                        && __has_builtin(__atomic_compare_exchange_n) \
                        && defined(__ATOMIC_RELAXED)                  \
                        && defined(__ATOMIC_CONSUME)                  \
                        && defined(__ATOMIC_ACQUIRE)                  \
                        && defined(__ATOMIC_RELEASE)                  \
                        && defined(__ATOMIC_ACQ_REL)                  \
                        && defined(__ATOMIC_SEQ_CST)
 #   define _LIBCPP_HAS_ATOMIC_BUILTINS

 _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
                                int __order = _AO_Seq)
 {
     return __atomic_add_fetch(__val, __a, __order);
 }
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+                                    _ValueType __value, int __order = _AO_Seq)
+{
+    return __atomic_exchange_n(__target, __value, __order);
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
 bool __libcpp_atomic_compare_exchange(_ValueType* __val,
     _ValueType* __expected, _ValueType __after,
     int __success_order = _AO_Seq,
     int __fail_order = _AO_Seq)
 {
     return __atomic_compare_exchange_n(__val, __expected, __after, true,
                                        __success_order, __fail_order);
 }

 _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
                                int = 0)
 {
     return *__val += __a;
 }
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+                                    _ValueType __value, int __order = _AO_Seq)
+{
+    _ValueType old = *__target;
+    *__target = __value;
+    return old;
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
 bool __libcpp_atomic_compare_exchange(_ValueType* __val,
     _ValueType* __expected, _ValueType __after,
     int = 0, int = 0)
 {
     if (*__val == *__expected) {
         *__val = __after;
         return true;
     }

libcxx/trunk/src/include/refstring.h

 #include <__config>
 #include <stdexcept>
 #include <cstddef>
 #include <cstring>
 #ifdef __APPLE__
 #include <dlfcn.h>
 #include <mach-o/dyld.h>
 #endif
+#include "atomic_support.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __refstring_imp { namespace {
 typedef int count_t;
 
 struct _Rep_base {
     std::size_t len;
__libcpp_refstring::__libcpp_refstring(const char* msg) {
     __imp_ = data;
 }
 
 inline
 __libcpp_refstring::__libcpp_refstring(const __libcpp_refstring &s) _NOEXCEPT
     : __imp_(s.__imp_)
 {
     if (__uses_refcount())
-        __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
 }
 
 inline
 __libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) _NOEXCEPT {
     bool adjust_old_count = __uses_refcount();
     struct _Rep_base *old_rep = rep_from_data(__imp_);
     __imp_ = s.__imp_;
     if (__uses_refcount())
-        __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
     if (adjust_old_count)
     {
-        if (__sync_add_and_fetch(&old_rep->count, count_t(-1)) < 0)
+        if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0)
         {
             ::operator delete(old_rep);
         }
     }
     return *this;
 }
 
 inline
 __libcpp_refstring::~__libcpp_refstring() {
     if (__uses_refcount()) {
         _Rep_base* rep = rep_from_data(__imp_);
-        if (__sync_add_and_fetch(&rep->count, count_t(-1)) < 0) {
+        if (__libcpp_atomic_add(&rep->count, count_t(-1)) < 0) {
             ::operator delete(rep);
         }
     }
 }
 
 inline
 bool __libcpp_refstring::__uses_refcount() const {
 #ifdef __APPLE__

libcxx/trunk/src/locale.cpp

 #include "__sso_allocator"
 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 #include "support/win32/locale_win32.h"
 #elif !defined(__BIONIC__)
 #include <langinfo.h>
 #endif
 #include <stdlib.h>
 #include <stdio.h>
+#include "include/atomic_support.h"
 #include "__undef_macros"
 
 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
 // lots of noise in the build log, but no bugs that I know of. 
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wsign-conversion"
 #endif
 

 {
     call_once(__flag_, __fake_bind(&locale::id::__init, this));
     return __id_ - 1;
 }
 
 void
 locale::id::__init()
 {
-    __id_ = __sync_add_and_fetch(&__next_id, 1);
+    __id_ = __libcpp_atomic_add(&__next_id, 1);
 }
 
 // template <> class collate_byname<char>
 
 collate_byname<char>::collate_byname(const char* n, size_t refs)
     : collate<char>(refs),
       __l(newlocale(LC_ALL_MASK, n, 0))
 {

libcxx/trunk/src/new.cpp

 //===--------------------------- new.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_BUILDING_NEW
 
 #include <stdlib.h>
 
 #include "new"
+#include "include/atomic_support.h"
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
 // nothing todo
 #elif defined(LIBCXX_BUILDING_LIBCXXABI)
 #include <cxxabi.h>
 #elif defined(LIBCXXRT)
 #include <cxxabi.h>
 #include "support/runtime/new_handler_fallback.ipp"

libcxx/trunk/src/support/runtime/exception_fallback.ipp

 _LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
 _LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
 
 
 // libcxxrt provides implementations of these functions itself.
 unexpected_handler
 set_unexpected(unexpected_handler func) _NOEXCEPT
 {
-  return __sync_lock_test_and_set(&__unexpected_handler, func);
+  return __libcpp_atomic_exchange(&__unexpected_handler, func);
 }
 
 unexpected_handler
 get_unexpected() _NOEXCEPT
 {
-  return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
+  return __libcpp_atomic_load(&__unexpected_handler);
 
 }
 
 _LIBCPP_NORETURN
 void unexpected()
 {
     (*get_unexpected())();
     // unexpected handler should not return
     terminate();
 }
 
 terminate_handler
 set_terminate(terminate_handler func) _NOEXCEPT
 {
-  return __sync_lock_test_and_set(&__terminate_handler, func);
+  return __libcpp_atomic_exchange(&__terminate_handler, func);
 }
 
 terminate_handler
 get_terminate() _NOEXCEPT
 {
-  return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
-
+  return __libcpp_atomic_load(&__terminate_handler);
 }
 
 #ifndef __EMSCRIPTEN__ // We provide this in JS
 _LIBCPP_NORETURN
 void
 terminate() _NOEXCEPT
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS

libcxx/trunk/src/support/runtime/new_handler_fallback.ipp

 
 namespace std {
 
 _LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
 
 new_handler
 set_new_handler(new_handler handler) _NOEXCEPT
 {
-    return __sync_lock_test_and_set(&__new_handler, handler);
+    return __libcpp_atomic_exchange(&__new_handler, handler);
 }
 
 new_handler
 get_new_handler() _NOEXCEPT
 {
-    return __sync_fetch_and_add(&__new_handler, nullptr);
+    return __libcpp_atomic_load(&__new_handler);
 }
 
 } // namespace std