[libc++][libc++abi] Make libc++ includes more compatible with its own modulemap

[ayzhao]

Summary

Currently, libc++ itself cannot be built with its own modulemap file.
This patch fixes includes in the implementation source files as follows:

• Replace includes of private headers with their public counterparts.
• Fix several missing imports.
• Move __std_stream out of the modulemap and into a header file in src/include as it's only used in iostream.cpp

Note that this patch isn't sufficient to allow compiling libc++ with
it's own modulemap - right now, clang still complains that iostream.cpp
is redefining several symbols in the iostream header with different
types.

[ayzhao]

fix up the history a little bit so (hopefully) git will recognize the rename

[philnik]

Thanks for working on this! I think it would be quite nice to be able to build libc++ with modules enabled, but I'm not sure it will actually be possible, since we define some classes differently in the source files to provide old symbols.

libcxx/src/filesystem/operations.cpp

17

I don't think we want to do this. In fact, we should go the other way and use private headers instead IMO. Instead, we should pass -fmodule-name=std to let clang know that these files implement the module.

libcxx/test/libcxx/transitive_includes/cxx2b.csv

165

This seems wrong. Maybe a broken rebase?

[Mordante]

libcxx/src/filesystem/operations.cpp

17

+1 I think we either need to add the missing granularized headers or the module map is misses exports for the granularized headers. I've seen the latter several times while using granularized headers in <format>.

[ayzhao]

libcxx/src/filesystem/operations.cpp

17

I'm not sure what the justification is for including internal private header files in source files.

The original reason for splitting up the header files was to decouple the entities within each header to prevent cyclic dependencies and transitive includes. However, source files don't suffer from this problem because users don't include them.

As an aside, I tried @philnik's suggestion to use -fmodule-name=absl and I ended up with some bizarre failures - for example

/path/to/llvm-project/build/bin/clang++ -DLIBCXXABI_SILENT_TERMINATE -DDCHECK_ALWAYS_ON=1  -D_LIBCPP_ENABLE_ASSERTIONS=1 -D_LIBCPP_BUILDING_LIBRARY -I../../buildtools/third_party/libc++/trunk/src -I../.. -Igen -I../../buildtools/third_party/libc++  -fmodules -fbuiltin-module-map -fmodules-cache-path=module_cache -Xclang -fmodules-local-submodule-visibility -O2 -fmodule-name=std -fvisibility=default -std=c++20 -nostdinc++ -isystem../../buildtools/third_party/libc++/trunk/include -isystem../../buildtools/third_party/libc++abi/trunk/include -std=c++20 -c ../../buildtools/third_party/libc++abi/trunk/src/cxa_exception.cpp -o obj/buildtools/third_party/libc++abi/libc++abi/cxa_exception.o
../../buildtools/third_party/libc++abi/trunk/src/cxa_exception.cpp:655:14: error: no member named '__libcpp_atomic_add' in namespace 'std'
        std::__libcpp_atomic_add(&exception_header->referenceCount, size_t(1));
        ~~~~~^
../../buildtools/third_party/libc++abi/trunk/src/cxa_exception.cpp:672:18: error: no member named '__libcpp_atomic_add' in namespace 'std'
        if (std::__libcpp_atomic_add(&exception_header->referenceCount, size_t(-1)) == 0)
            ~~~~~^
2 errors generated.

cxa_exception.cpp includes atomic_support.h, which defines the missing symbols in question (albeit in an anonymous namespace). The above compile command runs without error if I either remove -fmodule-name=std or the anonymous namespace in atomic_support.h.

(note: I was hacking in Chrome's source tree, and buildtools/third_party/libc++/trunk and buildtools/third_party/libc++/trunk corresponds to llvm-project/libcxx and llvm-project/libcxxabi respectively. There are no patches to libc++, and we follow upstream very closely)

libcxx/test/libcxx/transitive_includes/cxx2b.csv

165

Everything seems to be clean, and the test did pass:

commit 1e1e4cab167a179ee5218f056bbafb017f9b4180 (HEAD -> bugfix/libcpp-includes)
Author: Alan Zhao <[e-mail]>
Date:   Tue Feb 28 14:56:01 2023 -0800

    [libc++][libc++abi] Make libc++ includes more compatible with its own modulemap

    Currently, libc++ itself cannot be built with its own modulemap file.
    This patch fixes includes in the implementation source files as follows:
    * Replace includes of private headers with their public counterparts.
    * Fix several missing imports.
    * Move __std_stream out of the modulemap and into a header file in
      src/include as it's only used in iostream.cpp

    Note that this patch isn't sufficient to allow compiling libc++ with
    it's own modulemap - right now, clang still complains that iostream.cpp
    is redefining several symbols in the iostream header with different
    types.

    Differential Revision: https://reviews.llvm.org/D145017

commit 0963833a194331a8b8d6775dcd1c3025a8154751 (origin/main, origin/HEAD, main)
Author: Lang Hames <[e-mail]>
Date:   Wed Mar 1 15:34:23 2023 -0800

    [ExecutionEngine] Silence warnings about sprintf use in interpreter.

    We should review memory safety in the interpreter
    (https://github.com/llvm/llvm-project/issues/58086), but for now just silence
    the warnings to reduce noise.

    rdar://100555195

[philnik]

libcxx/src/filesystem/operations.cpp

17

My justification would be that the source files wouldn't have to be rebuilt nearly as often as they have to be right now. Currently it's almost always rebuilding, even if you didn't change anything near the source files.

I think the right way to fix the problem is to remove the inline namespace. We build with -fvisibility=hidden anyways, so they should never be exported from the dylib. I'd suggest moving that to it's own patch, since it's a good idea either way. I suspect that clang just doesn't emit them, since the functions are never used inside atomic_support.h.

libcxx/test/libcxx/transitive_includes/cxx2b.csv

165

experimental/functional and experimental/algorithm don't exist anymore. The CI is currently failing for unrelated reasons though (you have to add the moved file to libcxx/utils/data/ignore_format.txt).

[Mordante]

libcxx/src/filesystem/operations.cpp

17

My reasoning is, when they don't work properly when included in our dylib, there might be errors in our module map that users might be able to trigger. This entire module map is handcrafted, and I don't believe it's free of errors. So any error we can fix would be a win.

[ayzhao]

libcxx/src/filesystem/operations.cpp

17

My justification would be that the source files wouldn't have to be rebuilt nearly as often as they have to be right now. Currently it's almost always rebuilding, even if you didn't change anything near the source files.

I'm not sure why increased rebuilding is a problem. libc++ builds relatively quickly, especially compared to, for example, Clang. On my machine, if I restrict parallelism to -j2, a clean build of cxx, cxxabi, and unwind takes under 50 seconds:

$ perf stat ninja -j2 cxx cxxabi unwind
[1040/1040] Linking CXX static library lib/libc++.a

 Performance counter stats for 'ninja -j2 cxx cxxabi unwind':

         98,579.13 msec task-clock:u              #    1.973 CPUs utilized
                 0      context-switches:u        #    0.000 /sec
                 0      cpu-migrations:u          #    0.000 /sec
         2,850,617      page-faults:u             #   28.917 K/sec
   345,837,832,337      cycles:u                  #    3.508 GHz                      (83.68%)
    22,625,691,029      stalled-cycles-frontend:u #    6.54% frontend cycles idle     (83.41%)
    30,348,580,219      stalled-cycles-backend:u  #    8.78% backend cycles idle      (83.28%)
   401,110,951,625      instructions:u            #    1.16  insn per cycle
                                                  #    0.08  stalled cycles per insn  (83.76%)
    78,341,920,950      branches:u                #  794.711 M/sec                    (84.00%)
     2,727,072,658      branch-misses:u           #    3.48% of all branches          (83.67%)

      49.964402208 seconds time elapsed

      87.267475000 seconds user
      11.334668000 seconds sys

Also, compiling with -fmodule-name=std continues to add a glut of weird error messages - for example

$ /path/to/llvm-project/build/bin/clang++ -DLIBCXXABI_SILENT_TERMINATE -DDCHECK_ALWAYS_ON=1  -D_LIBCPP_ENABLE_ASSERTIONS=1 -D_LIBCPP_BUILDING_LIBRARY -I../../buildtools/third_party/libc++/trunk/src -I../.. -I../../buildtools/third_party/libc++  -fmodules -fbuiltin-module-map -fmodules-cache-path=module_cache -Xclang -fmodules-local-submodule-visibility -O2 -fmodule-name=std -fvisibility=default -std=c++20 -nostdinc++ -isystem../../buildtools/third_party/libc++/trunk/include -c ../../buildtools/third_party/libc++/trunk/src/memory.cpp -o obj/buildtools/third_party/libc++/libc++/memory.o 2>&1 | zpastebin
In file included from ../../buildtools/third_party/libc++/trunk/src/memory.cpp:17:
In file included from ../../buildtools/third_party/libc++/trunk/include/mutex:192:
In file included from ../../buildtools/third_party/libc++/trunk/include/__mutex_base:20:
In file included from ../../buildtools/third_party/libc++/trunk/include/system_error:153:
In file included from ../../buildtools/third_party/libc++/trunk/include/ios:221:
../../buildtools/third_party/libc++/trunk/include/__locale:206:5: error: unknown type name 'once_flag'; did you mean '__once_flag'?
    once_flag      __flag_;

# more random errors

I imported ios into system_error because Clang was complaining that io_errc must be imported from std.ios. The missing once_flag symbol in __locale is defined in mutex, so in this case, we end up with circular includes. For some reason, this isn't an issue without -fmodule-name=std.

I should also add that for some reason -fmodule-name=std seems to completely break resolution of symbols inside anonymous namespaces, even within the same file:

$ /path/to/llvm-project/build/bin/clang++ -DLIBCXXABI_SILENT_TERMINATE -DDCHECK_ALWAYS_ON=1  -D_LIBCPP_ENABLE_ASSERTIONS=1 -D_LIBCPP_BUILDING_LIBRARY -I../../buildtools/third_party/libc++/trunk/src -I../.. -I../../buildtools/third_party/libc++  -fmodules -fbuiltin-module-map -fmodules-cache-path=module_cache -Xclang -fmodules-local-submodule-visibility -O2 -fmodule-name=std -fvisibility=default -std=c++20 -nostdinc++ -isystem../../buildtools/third_party/libc++/trunk/include -c ../../buildtools/third_party/libc++/trunk/src/string.cpp -o obj/buildtools/third_party/libc++/libc++/string.o
../../buildtools/third_party/libc++/trunk/src/string.cpp:226:12: error: use of undeclared identifier 'as_integer'
    return as_integer<int>("stoi", str, idx, base);
           ^
../../buildtools/third_party/libc++/trunk/src/string.cpp:230:12: error: use of undeclared identifier 'as_integer'
    return as_integer<long>("stol", str, idx, base);
           ^
../../buildtools/third_party/libc++/trunk/src/string.cpp:234:12: error: use of undeclared identifier 'as_integer'
    return as_integer<unsigned long>("stoul", str, idx, base);

# plus more of the same error

[ayzhao]

Abandoning this revision as right now we're working on

libcxx/include/CMakeLists.txt

set(files
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/take_while_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
-  __std_stream
   __string/char_traits.h
   __string/constexpr_c_functions.h
   __string/extern_template_lists.h
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/locale_mgmt_zos.h
   __support/ibm/nanosleep.h

libcxx/include/libcxx.imp

 [
   { include: [ "<__hash_table>", "private", "<unordered_map>", "public" ] },
   { include: [ "<__hash_table>", "private", "<unordered_set>", "public" ] },
   { include: [ "<__locale>", "private", "<locale>", "public" ] },
   { include: [ "<__node_handle>", "private", "<map>", "public" ] },
   { include: [ "<__node_handle>", "private", "<set>", "public" ] },
   { include: [ "<__node_handle>", "private", "<unordered_map>", "public" ] },
   { include: [ "<__node_handle>", "private", "<unordered_set>", "public" ] },
   { include: [ "<__split_buffer>", "private", "<deque>", "public" ] },
   { include: [ "<__split_buffer>", "private", "<vector>", "public" ] },
-  { include: [ "<__std_stream>", "private", "<iostream>", "public" ] },
   { include: [ "<__threading_support>", "private", "<atomic>", "public" ] },
   { include: [ "<__threading_support>", "private", "<mutex>", "public" ] },
   { include: [ "<__threading_support>", "private", "<semaphore>", "public" ] },
   { include: [ "<__threading_support>", "private", "<thread>", "public" ] },
   { include: [ "<__tree>", "private", "<map>", "public" ] },
   { include: [ "<__tree>", "private", "<set>", "public" ] },
   { include: [ "@<__algorithm/.*>", "private", "<algorithm>", "public" ] },
   { include: [ "@<__atomic/.*>", "private", "<atomic>", "public" ] },

libcxx/include/memory

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/align.h>
+#include <__memory/aligned_alloc.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/assume_aligned.h>
 #include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>

libcxx/include/module.modulemap.in

   module __locale            {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     private header "__locale" export *
   }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
   module __mutex_base        { private header "__mutex_base"        export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __split_buffer      { private header "__split_buffer"      export * }
-  module __std_stream        {
-    @requires_LIBCXX_ENABLE_LOCALIZATION@
-    private header "__std_stream" export *
-  }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
   module __undef_macros      {         header "__undef_macros"      export * }
   module __verbose_abort     {         header "__verbose_abort"     export * }
 
   module experimental {
     requires cplusplus11
 

libcxx/src/filesystem/operations.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__assert>
-#include <__utility/unreachable.h>
 #include <array>
 #include <climits>
 #include <cstdlib>
 #include <filesystem>
 #include <iterator>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "filesystem_common.h"
 
 #include "posix_compat.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN

libcxx/src/include/ryu/digit_table.h

 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
 #define _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
 
-#include <__charconv/tables.h>
 #include <__config>
+#include <charconv>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // A table of all two-digit numbers. This is used to speed up decimal digit
 // generation by copying pairs of digits into the final output.
 //
 // In order to minimize the diff in the Ryu code between MSVC STL and libc++
 // the code uses the name __DIGIT_TABLE. In order to avoid code duplication it
 // reuses the table already available in libc++.
 inline constexpr auto& __DIGIT_TABLE = __itoa::__digits_base_10;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H

libcxx/src/include/ryu/ryu.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_RYU_H
 #define _LIBCPP_SRC_INCLUDE_RYU_RYU_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include <__charconv/chars_format.h>
-#include <__charconv/to_chars_result.h>
 #include <__config>
 #include <__debug>
-#include <__errc>
+#include <charconv>
 #include <cstdint>
 #include <cstring>
+#include <system_error>
 #include <type_traits>
 
 #include "include/ryu/f2s.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2fixed.h"
 
 #if defined(_MSC_VER)
 #include <intrin.h> // for _umul128(), __shiftright128(), _BitScanForward{,64}

libcxx/src/include/std_stream.h

 // -*- 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___STD_STREAM
 #define _LIBCPP___STD_STREAM
 
 #include <__config>
 #include <__locale>
 #include <cstdio>
 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 static const int __limit = 8;
 
 // __stdinbuf
 
 template <class _CharT>
 class _LIBCPP_HIDDEN __stdinbuf
     : public basic_streambuf<_CharT, char_traits<_CharT> >
 {
 public:
     typedef _CharT                           char_type;
     typedef char_traits<char_type>           traits_type;
     typedef typename traits_type::int_type   int_type;
     typedef typename traits_type::pos_type   pos_type;
     typedef typename traits_type::off_type   off_type;
     typedef typename traits_type::state_type state_type;
 
     __stdinbuf(FILE* __fp, state_type* __st);
 
 protected:
     virtual int_type underflow();
     virtual int_type uflow();
     virtual int_type pbackfail(int_type __c = traits_type::eof());
     virtual void imbue(const locale& __loc);
 
 private:
 
     FILE* __file_;
     const codecvt<char_type, char, state_type>* __cv_;
     state_type* __st_;
     int __encoding_;
     int_type __last_consumed_;
     bool __last_consumed_is_next_;
     bool __always_noconv_;
 
     __stdinbuf(const __stdinbuf&);
     __stdinbuf& operator=(const __stdinbuf&);
 
     int_type __getchar(bool __consume);
 };
 
 template <class _CharT>
 __stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
     : __file_(__fp),
       __st_(__st),
       __last_consumed_(traits_type::eof()),
       __last_consumed_is_next_(false)
 {
     imbue(this->getloc());
 }
 
 template <class _CharT>
 void
 __stdinbuf<_CharT>::imbue(const locale& __loc)
 {
     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
     __encoding_ = __cv_->encoding();
     __always_noconv_ = __cv_->always_noconv();
     if (__encoding_ > __limit)
         __throw_runtime_error("unsupported locale for standard input");
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::underflow()
 {
     return __getchar(false);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::uflow()
 {
     return __getchar(true);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
     if (__last_consumed_is_next_)
     {
         int_type __result = __last_consumed_;
         if (__consume)
         {
             __last_consumed_ = traits_type::eof();
             __last_consumed_is_next_ = false;
         }
         return __result;
     }
     char __extbuf[__limit];
     int __nread = _VSTD::max(1, __encoding_);
     for (int __i = 0; __i < __nread; ++__i)
     {
         int __c = getc(__file_);
         if (__c == EOF)
             return traits_type::eof();
         __extbuf[__i] = static_cast<char>(__c);
     }
     char_type __1buf;
     if (__always_noconv_)
         __1buf = static_cast<char_type>(__extbuf[0]);
     else
     {
         const char* __enxt;
         char_type* __inxt;
         codecvt_base::result __r;
         do
         {
             state_type __sv_st = *__st_;
             __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
                                    &__1buf, &__1buf + 1, __inxt);
             switch (__r)
             {
             case _VSTD::codecvt_base::ok:
                 break;
             case codecvt_base::partial:
                 *__st_ = __sv_st;
                 if (__nread == sizeof(__extbuf))
                     return traits_type::eof();
                 {
                     int __c = getc(__file_);
                     if (__c == EOF)
                         return traits_type::eof();
                     __extbuf[__nread] = static_cast<char>(__c);
                 }
                 ++__nread;
                 break;
             case codecvt_base::error:
                 return traits_type::eof();
             case _VSTD::codecvt_base::noconv:
                 __1buf = static_cast<char_type>(__extbuf[0]);
                 break;
             }
         } while (__r == _VSTD::codecvt_base::partial);
     }
     if (!__consume)
     {
         for (int __i = __nread; __i > 0;)
         {
             if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
                 return traits_type::eof();
         }
     }
     else
         __last_consumed_ = traits_type::to_int_type(__1buf);
     return traits_type::to_int_type(__1buf);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::pbackfail(int_type __c)
 {
     if (traits_type::eq_int_type(__c, traits_type::eof()))
     {
         if (!__last_consumed_is_next_)
         {
             __c = __last_consumed_;
             __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
                                                                  traits_type::eof());
         }
         return __c;
     }
     if (__last_consumed_is_next_)
     {
         char __extbuf[__limit];
         char* __enxt;
         const char_type __ci = traits_type::to_char_type(__last_consumed_);
         const char_type* __inxt;
         switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
                                   __extbuf, __extbuf + sizeof(__extbuf), __enxt))
         {
         case _VSTD::codecvt_base::ok:
             break;
         case _VSTD::codecvt_base::noconv:
             __extbuf[0] = static_cast<char>(__last_consumed_);
             __enxt = __extbuf + 1;
             break;
         case codecvt_base::partial:
         case codecvt_base::error:
             return traits_type::eof();
         }
         while (__enxt > __extbuf)
             if (ungetc(*--__enxt, __file_) == EOF)
                 return traits_type::eof();
     }
     __last_consumed_ = __c;
     __last_consumed_is_next_ = true;
     return __c;
 }
 
 // __stdoutbuf
 
 template <class _CharT>
 class _LIBCPP_HIDDEN __stdoutbuf
     : public basic_streambuf<_CharT, char_traits<_CharT> >
 {
 public:
     typedef _CharT                           char_type;
     typedef char_traits<char_type>           traits_type;
     typedef typename traits_type::int_type   int_type;
     typedef typename traits_type::pos_type   pos_type;
     typedef typename traits_type::off_type   off_type;
     typedef typename traits_type::state_type state_type;
 
     __stdoutbuf(FILE* __fp, state_type* __st);
 
 protected:
     virtual int_type overflow (int_type __c = traits_type::eof());
     virtual streamsize xsputn(const char_type* __s, streamsize __n);
     virtual int sync();
     virtual void imbue(const locale& __loc);
 
 private:
     FILE* __file_;
     const codecvt<char_type, char, state_type>* __cv_;
     state_type* __st_;
     bool __always_noconv_;
 
     __stdoutbuf(const __stdoutbuf&);
     __stdoutbuf& operator=(const __stdoutbuf&);
 };
 
 template <class _CharT>
 __stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
     : __file_(__fp),
       __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
       __st_(__st),
       __always_noconv_(__cv_->always_noconv())
 {
 }
 
 template <class _CharT>
 typename __stdoutbuf<_CharT>::int_type
 __stdoutbuf<_CharT>::overflow(int_type __c)
 {
     char __extbuf[__limit];
     char_type __1buf;
     if (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
         __1buf = traits_type::to_char_type(__c);
         if (__always_noconv_)
         {
             if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
                 return traits_type::eof();
         }
         else
         {
             char* __extbe = __extbuf;
             codecvt_base::result __r;
             char_type* pbase = &__1buf;
             char_type* pptr = pbase + 1;
             do
             {
                 const char_type* __e;
                 __r = __cv_->out(*__st_, pbase, pptr, __e,
                                         __extbuf,
                                         __extbuf + sizeof(__extbuf),
                                         __extbe);
                 if (__e == pbase)
                     return traits_type::eof();
                 if (__r == codecvt_base::noconv)
                 {
                     if (fwrite(pbase, 1, 1, __file_) != 1)
                         return traits_type::eof();
                 }
                 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
                 {
                     size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
                     if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
                         return traits_type::eof();
                     if (__r == codecvt_base::partial)
                     {
                         pbase = const_cast<char_type*>(__e);
                     }
                 }
                 else
                     return traits_type::eof();
             } while (__r == codecvt_base::partial);
         }
     }
     return traits_type::not_eof(__c);
 }
 
 template <class _CharT>
 streamsize
 __stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
 {
     if (__always_noconv_)
         return fwrite(__s, sizeof(char_type), __n, __file_);
     streamsize __i = 0;
     for (; __i < __n; ++__i, ++__s)
         if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
             break;
     return __i;
 }
 
 template <class _CharT>
 int
 __stdoutbuf<_CharT>::sync()
 {
     char __extbuf[__limit];
     codecvt_base::result __r;
     do
     {
         char* __extbe;
         __r = __cv_->unshift(*__st_, __extbuf,
                                     __extbuf + sizeof(__extbuf),
                                     __extbe);
         size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
         if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
             return -1;
     } while (__r == codecvt_base::partial);
     if (__r == codecvt_base::error)
         return -1;
     if (fflush(__file_))
         return -1;
     return 0;
 }
 
 template <class _CharT>
 void
 __stdoutbuf<_CharT>::imbue(const locale& __loc)
 {
     sync();
     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
     __always_noconv_ = __cv_->always_noconv();
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___STD_STREAM

libcxx/src/include/to_chars_floating_point.h

 // This implementation is dedicated to the memory of Mary and Thavatchai.
 
 #ifndef _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
 #define _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include <__algorithm/find.h>
-#include <__algorithm/find_if.h>
-#include <__algorithm/lower_bound.h>
-#include <__algorithm/min.h>
+#include <algorithm>
 #include <__assert>
 #include <__config>
-#include <__functional/operations.h>
-#include <__iterator/access.h>
-#include <__iterator/size.h>
 #include <bit>
 #include <cfloat>
 #include <climits>
+#include <functional>
+#include <iterator>
 
 #include "include/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __itoa {
 inline constexpr char _Charconv_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
     'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

libcxx/src/ios.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
-#include <__locale>
 #include <algorithm>
 #include <ios>
 #include <limits>
 #include <memory>
 #include <new>
 #include <stdlib.h>
 #include <string>
 

libcxx/src/iostream.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
 //
 //===----------------------------------------------------------------------===//
 
-#include <__locale>
-#include <__std_stream>
 #include <new>
 #include <string>
 
+#include "include/std_stream.h"
+
 #define _str(s) #s
 #define str(s) _str(s)
 #define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)

libcxx/src/legacy_pointer_safety.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
+#include <cstddef>
 #include <memory>
 
 // Support for garbage collection was removed in C++23 by https://wg21.link/P2186R2. Libc++ implements
 // that removal as an extension in all Standard versions. However, we still define the functions that
 // were once part of the library's ABI for backwards compatibility.
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_FUNC_VIS void declare_reachable(void*) {}
 _LIBCPP_FUNC_VIS void declare_no_pointers(char*, size_t) {}
 _LIBCPP_FUNC_VIS void undeclare_no_pointers(char*, size_t) {}
 _LIBCPP_FUNC_VIS void* __undeclare_reachable(void* p) { return p; }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/locale.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
 //
 //===----------------------------------------------------------------------===//
 
 // On Solaris, we need to define something to make the C99 parts of localeconv
 // visible.
 #ifdef __sun__
 #define _LCONV_C99
 #endif
 
-#include <__utility/unreachable.h>
+#include <utility>
 #include <algorithm>
 #include <clocale>
 #include <codecvt>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <locale>
 #include <string>

libcxx/src/memory.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 #ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
 #   define _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
 #endif
 
 #include <memory>
+#include <typeinfo>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 #  include <mutex>
 #  include <thread>
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif

libcxx/src/new.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
 //
 //===----------------------------------------------------------------------===//
 
-#include <__memory/aligned_alloc.h>
+#include <memory>
 #include <new>
 #include <stdlib.h>
 
 #include "include/atomic_support.h"
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
 #   if !defined(_LIBCPP_ABI_VCRUNTIME)
 #       include "support/runtime/new_handler_fallback.ipp"

libcxx/src/optional.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
 //
 //===----------------------------------------------------------------------===//
 
-#include <__availability>
 #include <optional>
 
 namespace std
 {
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
 const char* bad_optional_access::what() const noexcept {

libcxx/src/strstream.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__assert>
-#include <__utility/unreachable.h>
 #include <algorithm>
 #include <climits>
 #include <cstdlib>
 #include <cstring>
 #include <strstream>
+#include <utility>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 strstreambuf::strstreambuf(streamsize __alsize)
     : __strmode_(__dynamic),

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
 #include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
 #include <__ranges/take_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_while_view.h'}}
 #include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
-#include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
 #include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
 #include <__string/constexpr_c_functions.h> // expected-error@*:* {{use of private header from outside its module: '__string/constexpr_c_functions.h'}}
 #include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple_dir/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/apply_cv.h'}}
 #include <__tuple_dir/make_tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/make_tuple_types.h'}}
 #include <__tuple_dir/pair_like.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/pair_like.h'}}

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 exception version
 execution version
 expected cstddef
 expected cstdlib
 expected exception
 expected initializer_list
 expected new
 expected version
+experimental/algorithm algorithm
+experimental/algorithm cstddef
+experimental/algorithm type_traits
 experimental/deque deque
 experimental/deque experimental/memory_resource
 experimental/forward_list experimental/memory_resource
 experimental/forward_list forward_list
+experimental/functional array
+experimental/functional cstddef
+experimental/functional functional
+experimental/functional type_traits
+experimental/functional unordered_map
+experimental/functional vector
 experimental/iterator cstddef
 experimental/iterator iosfwd
 experimental/iterator iterator
 experimental/list experimental/memory_resource
 experimental/list list
 experimental/map experimental/memory_resource
 experimental/map map
 experimental/memory_resource cstddef

libcxx/utils/data/ignore_format.txt

 libcxx/include/stack
 libcxx/include/stdatomic.h
 libcxx/include/stdbool.h
 libcxx/include/stddef.h
 libcxx/include/stdexcept
 libcxx/include/stdint.h
 libcxx/include/stdio.h
 libcxx/include/stdlib.h
-libcxx/include/__std_stream
 libcxx/include/streambuf
 libcxx/include/string
 libcxx/include/__string/char_traits.h
 libcxx/include/__string/extern_template_lists.h
 libcxx/include/string.h
 libcxx/include/string_view
 libcxx/include/strstream
 libcxx/include/__support/android/locale_bionic.h

libcxx/utils/generate_iwyu_mapping.py

for i in detail_files:
         elif i == '__debug': continue
         elif i == '__errc': continue
         elif i == '__hash_table': public = ['unordered_map', 'unordered_set']
         elif i == '__locale': public = ['locale']
         elif i == '__mbstate_t.h': continue
         elif i == '__mutex_base': continue
         elif i == '__node_handle': public = ['map', 'set', 'unordered_map', 'unordered_set']
         elif i == '__split_buffer': public = ['deque', 'vector']
-        elif i == '__std_stream': public = ['iostream']
         elif i == '__threading_support': public = ['atomic', 'mutex', 'semaphore', 'thread']
         elif i == '__tree': public = ['map', 'set']
         elif i == '__undef_macros': continue
         elif i == '__verbose_abort': continue
         else: panic()
 
         for p in public:
             result.append(f'{generate(f"<{i}>", p)},')

libcxxabi/src/cxa_default_handlers.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
 //
 //
 // This file implements the default terminate_handler, unexpected_handler and
 // new_handler.
 //===----------------------------------------------------------------------===//
 
 #include <exception>
 #include <memory>
+#include <new>
 #include <stdlib.h>
 #include "abort_message.h"
 #include "cxxabi.h"
 #include "cxa_handlers.h"
 #include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h" // from libc++
 

libcxxabi/src/fallback_malloc.cpp

 
 #include <__threading_support>
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
 #pragma comment(lib, "pthread")
 #endif
 #endif
 
-#include <__memory/aligned_alloc.h>
 #include <assert.h>
+#include <atomic>
+#include <memory>
 #include <stdlib.h> // for malloc, calloc, free
 #include <string.h> // for memset
 
 //  A small, simple heap manager based (loosely) on
 //  the startup heap manager from FreeBSD, optimized for space.
 //
 //  Manages a fixed-size memory pool, supports malloc and free only.
 //  No support for realloc.