[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?

274

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``
 
 Upcoming Deprecations and Removals
 ----------------------------------
 
 - The ``_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED`` macro will not be honored anymore in LLVM 18.
   Please see the updated documentation about the safe libc++ mode and in particular the ``_LIBCPP_VERBOSE_ABORT``
   macro for details.
 
 API Changes
 -----------
 
 ABI Affecting Changes
 ---------------------
 
 Build System Changes
 --------------------

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>
+#  include <version>
 #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 <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

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>
 #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 <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/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

 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex type_traits
 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
-condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine limits
 coroutine version
 cstddef version
 ctgmath ccomplex

 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

 future new
 future ratio
 future system_error
 future thread
 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 initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
 map type_traits
 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 cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional type_traits
 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/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