[libc++] Move once_flag outside of <mutex>

[ldionne]

Summary

This allows including once_flag directly from <__locale> instead of
depending on all of <mutex>, which requires threading. In turn, this
makes it easier to support locales on platforms without threading.

Drive-by change: clang-format once_flag.h and use _LIBCPP_HIDE_FROM_ABI

[philnik]

Is there a reason you want to remove the dependency?

libcxx/include/__mutex/once_flag.h

33

As a follow-up, maybe remove the C++03 code? It looks like the C++11 code should work just fine in C++03.

[ldionne]

In D155487#4507021, @philnik wrote:

Is there a reason you want to remove the dependency?

This was originally prompted by trying to unblock D144322. I'm not sure it's necessary anymore but it still seems like a good thing.

[ldionne]

Rebase.

[ldionne]

Fix transitive includes.

libcxx/include/CMakeLists.txt

set(files
   __memory_resource/memory_resource.h
   __memory_resource/monotonic_buffer_resource.h
   __memory_resource/polymorphic_allocator.h
   __memory_resource/pool_options.h
   __memory_resource/synchronized_pool_resource.h
   __memory_resource/unsynchronized_pool_resource.h
   __mutex/lock_guard.h
   __mutex/mutex.h
+  __mutex/once_flag.h
   __mutex/tag_types.h
   __mutex/unique_lock.h
   __node_handle
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
   __numeric/gcd_lcm.h
   __numeric/inclusive_scan.h

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__availability>
 #include <__config>
 #include <__memory/shared_ptr.h> // __shared_count
+#include <__mutex/once_flag.h>
 #include <__type_traits/make_unsigned.h>
 #include <cctype>
 #include <clocale>
 #include <cstdint>
 #include <cstdlib>
-#include <mutex>
 #include <string>
 
 // Some platforms require more includes than others. Keep the includes on all plaforms for now.
 #include <cstddef>
 #include <cstring>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>

libcxx/include/__mutex/once_flag.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_ONCE_FLAG_H
+#define _LIBCPP___MUTEX_ONCE_FLAG_H
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__memory/shared_ptr.h> // __libcpp_acquire_load
+#include <__tuple/tuple_indices.h>
+#include <__tuple/tuple_size.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <cstdint>
+#ifndef _LIBCPP_CXX03_LANG
+#  include <tuple>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct _LIBCPP_TEMPLATE_VIS once_flag;
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Callable, class... _Args>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, _Callable&&, _Args&&...);
+
+#else // _LIBCPP_CXX03_LANG
+
+template <class _Callable>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, _Callable&);
+
+template <class _Callable>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, const _Callable&);
+
+#endif // _LIBCPP_CXX03_LANG
+
+struct _LIBCPP_TEMPLATE_VIS once_flag {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR once_flag() _NOEXCEPT : __state_(0) {}
+  once_flag(const once_flag&)            = delete;
+  once_flag& operator=(const once_flag&) = delete;
+
+#if defined(_LIBCPP_ABI_MICROSOFT)
+  typedef uintptr_t _State_type;
+#else
+  typedef unsigned long _State_type;
+#endif
+
+private:
+  _State_type __state_;
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class _Callable, class... _Args>
+  friend void call_once(once_flag&, _Callable&&, _Args&&...);
+#else  // _LIBCPP_CXX03_LANG
+  template <class _Callable>
+  friend void call_once(once_flag&, _Callable&);
+
+  template <class _Callable>
+  friend void call_once(once_flag&, const _Callable&);
+#endif // _LIBCPP_CXX03_LANG
+};
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Fp>
+class __call_once_param {
+  _Fp& __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __call_once_param(_Fp& __f) : __f_(__f) {}
+
+  _LIBCPP_HIDE_FROM_ABI void operator()() {
+    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
+    __execute(_Index());
+  }
+
+private:
+  template <size_t... _Indices>
+  _LIBCPP_HIDE_FROM_ABI void __execute(__tuple_indices<_Indices...>) {
+    _VSTD::__invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...);
+  }
+};
+
+#else
+
+template <class _Fp>
+class __call_once_param {
+  _Fp& __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __call_once_param(_Fp& __f) : __f_(__f) {}
+
+  _LIBCPP_HIDE_FROM_ABI void operator()() { __f_(); }
+};
+
+#endif
+
+template <class _Fp>
+void _LIBCPP_HIDE_FROM_ABI __call_once_proxy(void* __vp) {
+  __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
+  (*__p)();
+}
+
+_LIBCPP_EXPORTED_FROM_ABI void __call_once(volatile once_flag::_State_type&, void*, void (*)(void*));
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Callable, class... _Args>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args) {
+  if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0)) {
+    typedef tuple<_Callable&&, _Args&&...> _Gp;
+    _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
+    __call_once_param<_Gp> __p(__f);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
+  }
+}
+
+#else // _LIBCPP_CXX03_LANG
+
+template <class _Callable>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, _Callable& __func) {
+  if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0)) {
+    __call_once_param<_Callable> __p(__func);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
+  }
+}
+
+template <class _Callable>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, const _Callable& __func) {
+  if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0)) {
+    __call_once_param<const _Callable> __p(__func);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
+  }
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MUTEX_ONCE_FLAG_H

libcxx/include/codecvt

 #  include <atomic>
 #  include <concepts>
 #  include <cstddef>
 #  include <cstdlib>
 #  include <cstring>
 #  include <initializer_list>
 #  include <iosfwd>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_CODECVT

libcxx/include/fstream

 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/ios

 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstddef>
 #  include <cstdlib>
 #  include <cstring>
 #  include <initializer_list>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <system_error>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_IOS

libcxx/include/locale

 
 // NOLINTEND(libcpp-robust-against-adl)
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdarg>
 #  include <iterator>
+#  include <mutex>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LOCALE

libcxx/include/module.modulemap.in

 module std_private_memory_resource_synchronized_pool_resource   [system] {
   header "__memory_resource/synchronized_pool_resource.h"
   export *
 }
 module std_private_memory_resource_unsynchronized_pool_resource [system] { header "__memory_resource/unsynchronized_pool_resource.h" }
 
 module std_private_mutex_lock_guard  [system] { header "__mutex/lock_guard.h" }
 module std_private_mutex_mutex       [system] { header "__mutex/mutex.h" }
+module std_private_mutex_once_flag  [system]  { header "__mutex/once_flag.h" }
 module std_private_mutex_tag_types   [system] { header "__mutex/tag_types.h" }
 module std_private_mutex_unique_lock [system] { header "__mutex/unique_lock.h" }
 
 module std_private_numeric_accumulate               [system] { header "__numeric/accumulate.h" }
 module std_private_numeric_adjacent_difference      [system] { header "__numeric/adjacent_difference.h" }
 module std_private_numeric_exclusive_scan           [system] { header "__numeric/exclusive_scan.h" }
 module std_private_numeric_gcd_lcm                  [system] { header "__numeric/gcd_lcm.h" }
 module std_private_numeric_inclusive_scan           [system] { header "__numeric/inclusive_scan.h" }

libcxx/include/mutex

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
+#include <__mutex/once_flag.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
 #include <__thread/id.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstdint>
 #include <limits>
 #ifndef _LIBCPP_CXX03_LANG
private:
 
     _MutexTuple __t_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
 
 #endif // _LIBCPP_STD_VER >= 17
 #endif // !_LIBCPP_HAS_NO_THREADS
 
-struct _LIBCPP_TEMPLATE_VIS once_flag;
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _Callable, class... _Args>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, _Callable&&, _Args&&...);
-
-#else  // _LIBCPP_CXX03_LANG
-
-template<class _Callable>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, _Callable&);
-
-template<class _Callable>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, const _Callable&);
-
-#endif // _LIBCPP_CXX03_LANG
-
-struct _LIBCPP_TEMPLATE_VIS once_flag
-{
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR
-        once_flag() _NOEXCEPT : __state_(0) {}
-    once_flag(const once_flag&) = delete;
-    once_flag& operator=(const once_flag&) = delete;
-
-#if defined(_LIBCPP_ABI_MICROSOFT)
-   typedef uintptr_t _State_type;
-#else
-   typedef unsigned long _State_type;
-#endif
-
-private:
-    _State_type __state_;
-
-#ifndef _LIBCPP_CXX03_LANG
-    template<class _Callable, class... _Args>
-    friend
-    void call_once(once_flag&, _Callable&&, _Args&&...);
-#else  // _LIBCPP_CXX03_LANG
-    template<class _Callable>
-    friend
-    void call_once(once_flag&, _Callable&);
-
-    template<class _Callable>
-    friend
-    void call_once(once_flag&, const _Callable&);
-#endif // _LIBCPP_CXX03_LANG
-};
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Fp>
-class __call_once_param
-{
-    _Fp& __f_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_Fp& __f) : __f_(__f) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()()
-    {
-        typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
-        __execute(_Index());
-    }
-
-private:
-    template <size_t ..._Indices>
-    _LIBCPP_INLINE_VISIBILITY
-    void __execute(__tuple_indices<_Indices...>)
-    {
-        _VSTD::__invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...);
-    }
-};
-
-#else
-
-template <class _Fp>
-class __call_once_param
-{
-    _Fp& __f_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_Fp& __f) : __f_(__f) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()()
-    {
-        __f_();
-    }
-};
-
-#endif
-
-template <class _Fp>
-void _LIBCPP_INLINE_VISIBILITY
-__call_once_proxy(void* __vp)
-{
-    __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
-    (*__p)();
-}
-
-_LIBCPP_EXPORTED_FROM_ABI void __call_once(volatile once_flag::_State_type&, void*, void (*)(void*));
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _Callable, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        typedef tuple<_Callable&&, _Args&&...> _Gp;
-        _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
-        __call_once_param<_Gp> __p(__f);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
-    }
-}
-
-#else  // _LIBCPP_CXX03_LANG
-
-template<class _Callable>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, _Callable& __func)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        __call_once_param<_Callable> __p(__func);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
-    }
-}
-
-template<class _Callable>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, const _Callable& __func)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        __call_once_param<const _Callable> __p(__func);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
-    }
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>

libcxx/include/regex

 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
 #  include <iosfwd>
 #  include <iterator>
+#  include <mutex>
 #  include <new>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX