[libc++] Granularize <atomic> includes

[philnik]

Try to fix CI

[Mordante]

In general I like this, but I would like to see it again after the CI is green.

libcxx/include/atomic

543

Is this header still provided by one of the granularized headers?

[philnik]

Try to fix CI

libcxx/include/atomic

543

Yes.

[ldionne]

LGTM w/ passing CI.

libcxx/include/condition_variable

114

Why did you remove this one?

275

And this.

libcxx/include/ios

232

Let's keep the for __xindex_ comment, since it seems like this is only used in 1 place

[philnik]

Address comments

libcxx/include/condition_variable

114

I'm not sure what happened here. Reverted.

[Mordante]

LGTM too, I assume the final CI fixes are minor (or the current run passes).

[philnik]

Fix transitive includes

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Rebased

[philnik]

Try to fix CI

libcxx/docs/ReleaseNotes.rst

 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive
   inclusions of the following headers have been removed:
 
-  - C++2b: ``bit``, ``cstring``, ``type_traits``
+  - C++2b: ``atomic``, ``bit``, ``cstring``, ``type_traits``
 
 - The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
   have been implemented in namespace ``std`` for at least two releases.
 
 - The formatter specialization ``template<size_t N> struct formatter<const charT[N], charT>``
   has been removed. Since libc++'s format library was marked experimental there
   is no backwards compatibility option. This specialization has been removed
   from the Standard since it was never used, the proper specialization to use

libcxx/include/__memory/shared_ptr.h

 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
-#  include <atomic>
+#  include <__atomic/memory_order.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/atomic

 #include <__atomic/check_memory_order.h>
 #include <__atomic/contention_t.h>
 #include <__atomic/cxx_atomic_impl.h>
 #include <__atomic/fence.h>
 #include <__atomic/is_always_lock_free.h>
 #include <__atomic/kill_dependency.h>
 #include <__atomic/memory_order.h>
 #include <__config>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
 #include <version>
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-# include <__threading_support>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER
-# error <atomic> is not implemented
+#  error <atomic> is not implemented
 #endif
+
 #ifdef kill_dependency
-# error <atomic> is incompatible with <stdatomic.h> before C++23. Please compile with -std=c++23.
+#  error <atomic> is incompatible with <stdatomic.h> before C++23. Please compile with -std=c++23.
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cmath>
 #  include <compare>
+#  include <cstring>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_ATOMIC

libcxx/include/barrier

private:
     CompletionFunction completion; // exposition only
   };
 
 }
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__atomic/atomic_base.h>
+#include <__atomic/memory_order.h>
 #include <__availability>
 #include <__config>
 #include <__memory/unique_ptr.h>
+#include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__utility/move.h>
-#include <atomic>
+#include <cstddef>
+#include <cstdint>
 #include <limits>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error "<barrier> is not supported since libc++ has been configured without support for threads."
 #endif

 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <iterator>
 #  include <memory>
 #  include <stdexcept>
 #  include <variant>
 #endif
 
 #endif //_LIBCPP_BARRIER

libcxx/include/condition_variable

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex_base>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 _LIBCPP_FUNC_VIS
 void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_CONDITION_VARIABLE

libcxx/include/functional

 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <tuple>
 #  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#endif
+
 #endif // _LIBCPP_FUTURE

libcxx/include/ios

 #include <version>
 
 // standard-mandated includes
 
 // [ios.syn]
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
-#include <atomic>     // for __xindex_
+#  include <__atomic/atomic.h> // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 {
     __str.unsetf(ios_base::floatfield);
     return __str;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #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 <new>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_IOS

libcxx/include/latch

private:
     ptrdiff_t __counter; // exposition only
   };
 
 }
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__atomic/atomic_base.h>
+#include <__atomic/atomic_sync.h>
+#include <__atomic/memory_order.h>
 #include <__availability>
 #include <__config>
-#include <atomic>
+#include <cstddef>
 #include <limits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS

 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#endif
+
 #endif //_LIBCPP_LATCH

libcxx/include/memory

 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <cstddef>
 #  include <cstdint>
 #  include <cstring>
 #  include <iosfwd>
 #  include <iterator>
 #  include <new>
 #  include <stdexcept>
 #  include <tuple>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/module.modulemap.in

module array {
 
     module array_fwd { private header "__fwd/array.h" }
   }
   module atomic {
     header "atomic"
     export *
 
     module __atomic {
-      module aliases             { private header "__atomic/aliases.h" }
+      module aliases             {
+        private header "__atomic/aliases.h"
+        export atomic
+      }
       module atomic              { private header "__atomic/atomic.h" }
       module atomic_base         { private header "__atomic/atomic_base.h" }
       module atomic_flag         { private header "__atomic/atomic_flag.h" }
       module atomic_init         { private header "__atomic/atomic_init.h" }
       module atomic_lock_free    { private header "__atomic/atomic_lock_free.h" }
       module atomic_sync         { private header "__atomic/atomic_sync.h" }
       module check_memory_order  { private header "__atomic/check_memory_order.h" }
       module contention_t        { private header "__atomic/contention_t.h" }

libcxx/include/mutex

 
 #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 <ctime>
 #  include <functional>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_MUTEX

libcxx/include/ostream

 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <iterator>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_OSTREAM

libcxx/include/semaphore

 
 using binary_semaphore = counting_semaphore<1>;
 
 }
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__atomic/atomic_base.h>
+#include <__atomic/atomic_sync.h>
+#include <__atomic/memory_order.h>
 #include <__availability>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
-#include <atomic>
+#include <cstddef>
 #include <limits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS

 using binary_semaphore = counting_semaphore<1>;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#endif
+
 #endif //_LIBCPP_SEMAPHORE

libcxx/test/libcxx/atomics/atomics.align/align.pass.cpp

 // lock-free. This can't be observed through the atomic<T> API. It is
 // nonetheless required for correctness of the implementation: lock-free implies
 // that ISA instructions are used, and these instructions assume "suitable
 // alignment". Supported architectures all require natural alignment for
 // lock-freedom (e.g. load-linked / store-conditional, or cmpxchg).
 
 #include <atomic>
 #include <cassert>
+#include <cstddef>
 
 template <typename T>
 struct atomic_test : public std::__atomic_base<T> {
   atomic_test() {
     if (this->is_lock_free()) {
       using AtomicImpl = decltype(this->__a_);
       assert(alignof(AtomicImpl) >= sizeof(AtomicImpl) &&
              "expected natural alignment for lock-free type");

libcxx/test/libcxx/transitive_includes/cxx03.csv

 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
+barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd
 bit limits
 bit type_traits
 bit version
 bitset climits
 bitset concepts

 concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable type_traits

 iterator limits
 iterator new
 iterator type_traits
 iterator typeinfo
 iterator utility
 iterator variant
 iterator version
 latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
+latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic
 list compare
 list concepts
 list cstddef

 memory_resource tuple
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error

 scoped_allocator ratio
 scoped_allocator stdexcept
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts

libcxx/test/libcxx/transitive_includes/cxx11.csv

 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
+barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd
 bit limits
 bit type_traits
 bit version
 bitset climits
 bitset concepts

 concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable type_traits

 iterator limits
 iterator new
 iterator type_traits
 iterator typeinfo
 iterator utility
 iterator variant
 iterator version
 latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
+latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic
 list compare
 list concepts
 list cstddef

 memory_resource tuple
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error

 scoped_allocator ratio
 scoped_allocator stdexcept
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts

libcxx/test/libcxx/transitive_includes/cxx14.csv

 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
+barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd
 bit limits
 bit type_traits
 bit version
 bitset climits
 bitset concepts

 concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable type_traits

 iterator limits
 iterator new
 iterator type_traits
 iterator typeinfo
 iterator utility
 iterator variant
 iterator version
 latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
+latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic
 list compare
 list concepts
 list cstddef

 memory_resource tuple
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error

 scoped_allocator ratio
 scoped_allocator stdexcept
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts

libcxx/test/libcxx/transitive_includes/cxx17.csv

 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
+barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd
 bit limits
 bit type_traits
 bit version
 bitset climits
 bitset concepts

 concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable type_traits

 iterator limits
 iterator new
 iterator type_traits
 iterator typeinfo
 iterator utility
 iterator variant
 iterator version
 latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
+latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic
 list compare
 list concepts
 list cstddef

 memory_resource tuple
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error

 scoped_allocator ratio
 scoped_allocator stdexcept
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts

libcxx/test/libcxx/transitive_includes/cxx20.csv

 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
+barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd
 bit limits
 bit type_traits
 bit version
 bitset climits
 bitset concepts

 concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable type_traits

 iterator limits
 iterator new
 iterator type_traits
 iterator typeinfo
 iterator utility
 iterator variant
 iterator version
 latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
+latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic
 list compare
 list concepts
 list cstddef

 memory_resource tuple
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error

 scoped_allocator ratio
 scoped_allocator stdexcept
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
 atomic iosfwd
 atomic limits
 atomic ratio
 atomic version
-barrier atomic
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier limits
 barrier new
 barrier ratio
+barrier version
 bit cstdint
 bit cstdlib
 bit limits
 bit version
 bitset climits
 bitset cstddef
 bitset cstdint
 bitset cstdlib

 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
-condition_variable atomic
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
+condition_variable ctime
 condition_variable initializer_list
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable system_error
 condition_variable typeinfo

 fstream initializer_list
 fstream istream
 fstream mutex
 fstream ostream
 fstream string
 fstream typeinfo
 fstream version
 functional array
-functional atomic
 functional cstddef
 functional cstdint
 functional cstdlib
 functional cstring
 functional exception
 functional initializer_list
 functional iosfwd
 functional limits
 functional memory
 functional new
 functional stdexcept
 functional tuple
 functional typeinfo
 functional unordered_map
 functional vector
 functional version
-future atomic
 future cstddef
 future cstdint
 future cstdlib
 future cstring
 future exception
 future initializer_list
 future iosfwd
 future limits
 future mutex
 future new
 future ratio
 future stdexcept
 future system_error
 future thread
 future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
-ios atomic
 ios cctype
 ios cstddef
 ios cstdint
 ios cstring
 ios iosfwd
 ios mutex
 ios string
 ios system_error

 iterator concepts
 iterator cstddef
 iterator cstdlib
 iterator initializer_list
 iterator iosfwd
 iterator limits
 iterator variant
 iterator version
-latch atomic
+latch cstddef
+latch cstdint
+latch cstring
+latch ctime
+latch iosfwd
 latch limits
+latch ratio
 latch version
 limits version
 list compare
 list cstddef
 list cstdint
 list cstdlib
 list cstring
 list initializer_list

 map cstdlib
 map initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
 map version
-memory atomic
 memory compare
 memory cstddef
 memory cstdint
 memory cstdlib
 memory cstring
 memory initializer_list
 memory iosfwd
 memory limits
 memory new
 memory stdexcept
 memory tuple
 memory typeinfo
 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
-mutex atomic
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
+mutex ctime
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
 mutex system_error
 mutex tuple

 optional cstddef
 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional version
-ostream atomic
 ostream bitset
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd

 regex string
 regex vector
 regex version
 scoped_allocator cstddef
 scoped_allocator limits
 scoped_allocator new
 scoped_allocator tuple
 scoped_allocator version
-semaphore atomic
 semaphore cstddef
+semaphore cstdint
+semaphore cstring
 semaphore ctime
 semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
 set cstdlib

libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <atomic>
 
 // static constexpr bool is_always_lock_free;
 
 #include <atomic>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 template <typename T>
 void checkAlwaysLockFree() {
   if (std::atomic<T>::is_always_lock_free) {
     LIBCPP_ASSERT(sizeof(std::atomic<T>) == sizeof(T)); // technically not required, but libc++ does it that way
     assert(std::atomic<T>().is_lock_free());

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

 //     integral operator&=(integral op);
 //     integral operator|=(integral op) volatile;
 //     integral operator|=(integral op);
 //     integral operator^=(integral op) volatile;
 //     integral operator^=(integral op);
 // };
 
 #include <atomic>
-#include <new>
 #include <cassert>
+#include <cstdint>
+#include <new>
 
 #include <cmpxchg_loop.h>
 
 #include "test_macros.h"
 
 template <class A, class T>
 void
 do_test()

libcxx/test/support/atomic_helpers.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 ATOMIC_HELPERS_H
 #define ATOMIC_HELPERS_H
 
 #include <cassert>
+#include <cstdint>
 
 #include "test_macros.h"
 
 struct UserAtomicType {
   int i;
 
   explicit UserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
 

libcxx/utils/data/ignore_format.txt

 libcxx/include/__algorithm/swap_ranges.h
 libcxx/include/__algorithm/transform.h
 libcxx/include/__algorithm/uniform_random_bit_generator_adaptor.h
 libcxx/include/__algorithm/unwrap_iter.h
 libcxx/include/__algorithm/unwrap_range.h
 libcxx/include/__algorithm/upper_bound.h
 libcxx/include/any
 libcxx/include/array
-libcxx/include/atomic
 libcxx/include/__atomic/atomic_base.h
 libcxx/include/__atomic/atomic_flag.h
 libcxx/include/__atomic/atomic.h
 libcxx/include/__atomic/atomic_init.h
 libcxx/include/__atomic/atomic_lock_free.h
 libcxx/include/__atomic/atomic_sync.h
 libcxx/include/__atomic/check_memory_order.h
 libcxx/include/__atomic/contention_t.h