[libc++] Replace `#include ""` with `<>` in libcxx/src/. NFCI

[• Quuxplusone]

Summary

Our best guess is that the two syntaxes should have exactly equivalent
effects, so, let's be consistent with what we do in libcxx/include/.

I've left #include "include/x.h" and #include "../y.h" alone
because I'm less sure that they're interchangeable, and they aren't
inconsistent with libcxx/include/ because libcxx/include/ never
does that kind of thing.

Also, use the _LIBCPP_PUSH_MACROS/POP_MACROS dance for <__undef_macros>,
even though it's technically unnecessary in a standalone .cpp file,
just so we have consistently one way to do it.

[philnik]

libcxx/src/bind.cpp

9

Not in this PR, but I think it would be a good idea to include the granular header if not all of the header is implemented in one file.

[EricWF]

Why would we do this?

Our best guess is that the two syntaxes should have exactly equivalent

effects,

They don't. You can use clang++ -E -x c++ - -v < /dev/null to view the search path order for the various include types.

The point of writing includes in the source directory using quotes is to ensure we pick up our local headers, and not something installed along a system path.

[• Quuxplusone]

In D119561#3315057, @EricWF wrote:

Our best guess is that the two syntaxes should have exactly equivalent effects,

They don't. You can use clang++ -E -x c++ - -v < /dev/null to view the search path order for the various include types.

The point of writing includes in the source directory using quotes is to ensure we pick up our local headers, and not something installed along a system path.

Let's suppose for the sake of argument that #include "vector" picks up the correct local libcxx/include/vector while #include <vector> would have picked up the wrong header.
Then, when inside the local libcxx/include/vector itself we see #include <memory> or #include <__utility/forward.h> or whatever, wouldn't that necessarily pick up the wrong header?
How could it be OK to use <> inside the library headers themselves, but not to use <> in src/ when building the library?

There are also enough places we do this by accident already

$ git grep '#include <' ../libcxx/src/ | wc -l
      91

and we're not hearing complaints of breakage from anyone yet.

[ldionne]

I have to agree here, I think this is safe and in fact it's only a source of confusion that we're using "" instead of <>. When we setup the libc++ build, we are careful to suppress the normal C++ stdlib header search paths with nostdinc++, and we add the path to the currently-being-built C++ stdlib explicitly using -I (or -isystem, I forgot).

So this LGTM: I don't think this can break anybody, but I'd like to make sure that @EricWF isn't aware of something we don't know before shipping this.

[• Quuxplusone]

Rebased on main. @EricWF ping? can you still imagine this breaking things, and if so, how/example plz?

[ldionne]

Because this conflicts with a lot of patches in-flight, let's land this if CI is happy. If there is new information later, we can always make the change in reverse -- but keeping this review open is just going to create churn.

libcxx/src/algorithm.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 "algorithm"
+#include <algorithm>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);
 #endif
 template void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&);

libcxx/src/any.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 "any"
+#include <any>
 
 namespace std {
 const char* bad_any_cast::what() const noexcept {
     return "bad any cast";
 }
 }
 
 

libcxx/src/bind.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 "functional"
+#include <functional>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace placeholders
 {
 
 const __ph<1>   _1{};
 const __ph<2>   _2{};

libcxx/src/charconv.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 "charconv"
+#include <charconv>
 #include <string.h>
 
 #include "include/ryu/digit_table.h"
 #include "include/to_chars_floating_point.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __itoa

libcxx/src/chrono.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
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__MVS__)
 // As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API
 // to be defined before any system header to include definition of struct timespec64.
 #define _LARGE_TIME_API
 #endif
 
-#include "chrono"
-#include "cerrno"        // errno
-#include "system_error"  // __throw_system_error
+#include <cerrno>        // errno
+#include <chrono>
+#include <system_error>  // __throw_system_error
 
 #if defined(__MVS__)
 #include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic
 #endif
 
 #include <time.h>        // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
 #include "include/apple_availability.h"
 

libcxx/src/condition_variable.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 <__config>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-#include "condition_variable"
-#include "thread"
-#include "system_error"
-#include "__undef_macros"
+#include <condition_variable>
+#include <thread>
+#include <system_error>
 
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
+#  pragma comment(lib, "pthread")
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // ~condition_variable is defined elsewhere.
 
 void
 condition_variable::notify_one() noexcept
 {
     __libcpp_condvar_signal(&__cv_);
notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
     if (tl_ptr.get() == nullptr) {
         tl_ptr.set_pointer(new __thread_struct);
     }
     __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // !_LIBCPP_HAS_NO_THREADS

libcxx/src/condition_variable_destructor.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
 //
 //===----------------------------------------------------------------------===//
 
 // Define ~condition_variable.
 //
 // On some platforms ~condition_variable has been made trivial and the
 // definition is only provided for ABI compatibility.
 
-#include "__config"
-#include "__threading_support"
+#include <__config>
+#include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 # if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION)
 #   define NEEDS_CONDVAR_DESTRUCTOR
 # endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/src/debug.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 "__debug"
-#include "functional"
-#include "algorithm"
-#include "string"
-#include "cstdio"
-#include "__hash_table"
+#include <__config>
+#include <__debug>
+#include <__hash_table>
+#include <algorithm>
+#include <cstdio>
+#include <functional>
+#include <string>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
-#include "mutex"
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
-#endif
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 std::string __libcpp_debug_info::what() const {
   string msg = __file_;
   msg += ":" + to_string(__line_) + ": _LIBCPP_ASSERT '";
   msg += __pred_;

libcxx/src/exception.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 "exception"
-#include "new"
-#include "typeinfo"
+#include <exception>
+#include <new>
+#include <typeinfo>
 
 #if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
   #include <cxxabi.h>
   using namespace __cxxabiv1;
   #define HAVE_DEPENDENT_EH_ABI 1
 #endif
 
 #if defined(_LIBCPP_ABI_MICROSOFT)

libcxx/src/experimental/memory_resource.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 "experimental/memory_resource"
+#include <experimental/memory_resource>
 
 #ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-#include "atomic"
+#  include <atomic>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
-#include "mutex"
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
-#endif
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 // memory_resource
 
 //memory_resource::~memory_resource() {}
 

libcxx/src/filesystem/directory_iterator.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 "filesystem"
-#include "stack"
+#include <__config>
 #include <errno.h>
+#include <filesystem>
+#include <stack>
 
 #include "filesystem_common.h"
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 using detail::ErrorHandler;
 
 #if defined(_LIBCPP_WIN32API)

libcxx/src/filesystem/filesystem_common.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 FILESYSTEM_COMMON_H
 #define FILESYSTEM_COMMON_H
 
-#include "__config"
-#include "array"
-#include "chrono"
-#include "climits"
-#include "cstdarg"
-#include "ctime"
-#include "filesystem"
-#include "ratio"
-#include "system_error"
+#include <__config>
+#include <array>
+#include <chrono>
+#include <climits>
+#include <cstdarg>
+#include <ctime>
+#include <filesystem>
+#include <ratio>
+#include <system_error>
 #include <utility>
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #endif
 

libcxx/src/filesystem/int128_builtins.cpp

 /*===-- int128_builtins.cpp - Implement __muloti4 --------------------------===
  *
  * 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 __muloti4, and is stolen from the compiler_rt library.
  *
  * FIXME: we steal and re-compile it into filesystem, which uses __int128_t,
  * and requires this builtin when sanitized. See llvm.org/PR30643
  *
  * ===----------------------------------------------------------------------===
  */
-#include "__config"
-#include "climits"
+#include <__config>
+#include <climits>
 
 #if !defined(_LIBCPP_HAS_NO_INT128)
 
 extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_FUNC_VIS
 __int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) {
   const int N = (int)(sizeof(__int128_t) * CHAR_BIT);
   const __int128_t MIN = (__int128_t)1 << (N - 1);
   const __int128_t MAX = ~MIN;

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

 
 #if __has_include(<sys/sendfile.h>)
 # include <sys/sendfile.h>
 # define _LIBCPP_FILESYSTEM_USE_SENDFILE
 #elif defined(__APPLE__) || __has_include(<copyfile.h>)
 # include <copyfile.h>
 # define _LIBCPP_FILESYSTEM_USE_COPYFILE
 #else
-# include "fstream"
+# include <fstream>
 # define _LIBCPP_FILESYSTEM_USE_FSTREAM
 #endif
 
 #if !defined(CLOCK_REALTIME) && !defined(_LIBCPP_WIN32API)
 # include <sys/time.h> // for gettimeofday and timeval
 #endif
 
 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)

libcxx/src/filesystem/posix_compat.h

 // These are provided within an anonymous namespace within the detail
 // namespace - callers need to include this header and call them as
 // detail::function(), regardless of platform.
 //
 
 #ifndef POSIX_COMPAT_H
 #define POSIX_COMPAT_H
 
-#include "filesystem"
+#include <filesystem>
 
 #include "filesystem_common.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 # include <io.h>

libcxx/src/format.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 "format"
+#include <format>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 format_error::~format_error() noexcept = default;
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/functional.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 "functional"
+#include <functional>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
 bad_function_call::~bad_function_call() noexcept
 {
 }
 #endif

libcxx/src/future.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 <__config>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-#include "future"
-#include "string"
+#include <future>
+#include <string>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
 public:
     virtual const char* name() const noexcept;

libcxx/src/hash.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 "__hash_table"
-#include "algorithm"
-#include "stdexcept"
-#include "type_traits"
+#include <__hash_table>
+#include <algorithm>
+#include <stdexcept>
+#include <type_traits>
 
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wtautological-constant-out-of-range-compare")
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace {
 
 // handle all next_prime(i) for i in [1, 210), special case 0

libcxx/src/include/atomic_support.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_SUPPORT_H
 #define ATOMIC_SUPPORT_H
 
-#include "__config"
-#include "memory" // for __libcpp_relaxed_load
+#include <__config>
+#include <memory> // for __libcpp_relaxed_load
 
 #if defined(__clang__) && __has_builtin(__atomic_load_n)             \
                        && __has_builtin(__atomic_store_n)            \
                        && __has_builtin(__atomic_add_fetch)          \
                        && __has_builtin(__atomic_exchange_n)         \
                        && __has_builtin(__atomic_compare_exchange_n) \
                        && defined(__ATOMIC_RELAXED)                  \
                        && defined(__ATOMIC_CONSUME)                  \

libcxx/src/include/ryu/d2fixed.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_D2FIXED_H
 #define _LIBCPP_SRC_INCLUDE_RYU_D2FIXED_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
-#include "cstdint"
+#include <__config>
+#include <cstdint>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 void __append_n_digits(const uint32_t __olength, uint32_t __digits, char* const __result);
 void __append_nine_digits(uint32_t __digits, char* const __result);
 
 [[nodiscard]] to_chars_result __d2fixed_buffered_n(char* _First, char* const _Last, const double __d, const uint32_t __precision);
 [[nodiscard]] to_chars_result __d2exp_buffered_n(char* _First, char* const _Last, const double __d, uint32_t __precision);
 
 _LIBCPP_END_NAMESPACE_STD
 
 // clang-format on
 
 #endif // _LIBCPP_SRC_INCLUDE_RYU_D2FIXED_H

libcxx/src/include/ryu/d2fixed_full_table.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_D2FIXED_FULL_TABLE_H
 #define _LIBCPP_SRC_INCLUDE_RYU_D2FIXED_FULL_TABLE_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline constexpr int __TABLE_SIZE = 64;
 
 inline constexpr uint16_t __POW10_OFFSET[__TABLE_SIZE] = {
   0, 2, 5, 8, 12, 16, 21, 26, 32, 39,
   46, 54, 62, 71, 80, 90, 100, 111, 122, 134,

libcxx/src/include/ryu/d2s.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_DS2_H
 #define _LIBCPP_SRC_INCLUDE_RYU_DS2_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline constexpr int __DOUBLE_MANTISSA_BITS = 52;
 inline constexpr int __DOUBLE_EXPONENT_BITS = 11;
 inline constexpr int __DOUBLE_BIAS = 1023;
 
 inline constexpr int __DOUBLE_POW5_INV_BITCOUNT = 122;

libcxx/src/include/ryu/d2s_full_table.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_D2S_FULL_TABLE_H
 #define _LIBCPP_SRC_INCLUDE_RYU_D2S_FULL_TABLE_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline constexpr uint64_t __DOUBLE_POW5_INV_SPLIT[292][2] = {
   {                    1u, 288230376151711744u }, {  3689348814741910324u, 230584300921369395u },
   {  2951479051793528259u, 184467440737095516u }, { 17118578500402463900u, 147573952589676412u },
   { 12632330341676300947u, 236118324143482260u }, { 10105864273341040758u, 188894659314785808u },
   { 15463389048156653253u, 151115727451828646u }, { 17362724847566824558u, 241785163922925834u },

libcxx/src/include/ryu/d2s_intrinsics.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_DS2_INTRINSICS_H
 #define _LIBCPP_SRC_INCLUDE_RYU_DS2_INTRINSICS_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 #include "include/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_M_X64) && defined(_MSC_VER)
 #define _LIBCPP_INTRINSIC128 1
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {

libcxx/src/include/ryu/digit_table.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
 #define _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 _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.
 inline constexpr char __DIGIT_TABLE[200] = {
   '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
   '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',

libcxx/src/include/ryu/f2s.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_FS2_H
 #define _LIBCPP_SRC_INCLUDE_RYU_FS2_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
+#include <__config>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 [[nodiscard]] to_chars_result __f2s_buffered_n(char* const _First, char* const _Last, const float __f, const chars_format _Fmt);
 
 _LIBCPP_END_NAMESPACE_STD
 
 // clang-format on
 
 #endif // _LIBCPP_SRC_INCLUDE_RYU_FS2_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 "cstdint"
-#include "cstring"
-#include "type_traits"
+#include <__charconv/chars_format.h>
+#include <__charconv/to_chars_result.h>
+#include <__config>
+#include <__debug>
+#include <__errc>
+#include <cstdint>
+#include <cstring>
+#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}
 #endif // defined(_MSC_VER)
 

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 "__config"
-#include "__iterator/access.h"
-#include "__iterator/size.h"
-#include "bit"
-#include "cfloat"
-#include "climits"
+#include <__algorithm/find.h>
+#include <__algorithm/find_if.h>
+#include <__algorithm/lower_bound.h>
+#include <__algorithm/min.h>
+#include <__config>
+#include <__iterator/access.h>
+#include <__iterator/size.h>
+#include <bit>
+#include <cfloat>
+#include <climits>
+
 #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'};
 static_assert(_VSTD::size(_Charconv_digits) == 36);

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 "ios"
-
+#include <__config>
+#include <__locale>
+#include <algorithm>
+#include <ios>
+#include <limits>
+#include <memory>
+#include <new>
 #include <stdlib.h>
+#include <string>
 
-#include "__locale"
-#include "algorithm"
 #include "include/config_elast.h"
-#include "limits"
-#include "memory"
-#include "new"
-#include "string"
-#include "__undef_macros"
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __iostream_category
     : public __do_message
 {
 public:
     virtual const char* name() const noexcept;

 {
     static bool previous_state = true;
     bool r = previous_state;
     previous_state = sync;
     return r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS

libcxx/src/ios.instantiations.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 "fstream"
-#include "ios"
-#include "istream"
-#include "ostream"
-#include "sstream"
-#include "streambuf"
-
+#include <__config>
+#include <fstream>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <sstream>
+#include <streambuf>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Original explicit instantiations provided in the library
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ios<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_streambuf<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_istream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ostream<char>;

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 "__std_stream"
-#include "__locale"
-#include "string"
-#include "new"
+#include <__locale>
+#include <__std_stream>
+#include <new>
+#include <string>
 
 #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)]

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 <__config>
 #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 "algorithm"
-#include "clocale"
-#include "codecvt"
-#include "cstdio"
-#include "cstdlib"
-#include "cstring"
-#include "locale"
-#include "string"
-#include "type_traits"
-#include "typeinfo"
-#include "vector"
+#include <algorithm>
+#include <clocale>
+#include <codecvt>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <locale>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <vector>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-#   include "cwctype"
+#   include <cwctype>
 #endif
 
 #if defined(_AIX)
 #   include <sys/localedef.h> // for __lc_ctype_ptr
 #endif
 
 #if defined(_LIBCPP_MSVCRT)
 #   define _CTYPE_DISABLE_MACROS
 #endif
 
 #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
 #   include "__support/win32/locale_win32.h"
 #elif !defined(__BIONIC__) && !defined(__NuttX__)
 #   include <langinfo.h>
 #endif
 
 #include "include/atomic_support.h"
 #include "include/sso_allocator.h"
-#include "__undef_macros"
 
 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
 // lots of noise in the build log, but no bugs that I know of.
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 struct __libcpp_unique_locale {
   __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
 
   ~__libcpp_unique_locale() {
     if (__loc_)
       freelocale(__loc_);

 template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
 template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS

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 "memory"
+#include <memory>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
-#   include "mutex"
-#   include "thread"
-#   if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#       pragma comment(lib, "pthread")
-#   endif
+#  include <mutex>
+#  include <thread>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
 #endif
+
 #include "include/atomic_support.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const allocator_arg_t allocator_arg = allocator_arg_t();
 
 bad_weak_ptr::~bad_weak_ptr() noexcept {}
 

libcxx/src/mutex.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 "mutex"
-#include "limits"
-#include "system_error"
+#include <limits>
+#include <mutex>
+#include <system_error>
+
 #include "include/atomic_support.h"
-#include "__undef_macros"
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
-#endif
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
+
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 const defer_lock_t  defer_lock{};
 const try_to_lock_t try_to_lock{};
 const adopt_lock_t  adopt_lock{};
 
 // ~mutex is defined elsewhere
 

 #endif // _LIBCPP_NO_EXCEPTIONS
     }
     else
         __libcpp_mutex_unlock(&mut);
 #endif // !_LIBCPP_HAS_NO_THREADS
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS

libcxx/src/mutex_destructor.cpp

 // On some platforms ~mutex has been made trivial and the definition is only
 // provided for ABI compatibility.
 //
 // In order to avoid ODR violations within libc++ itself, we need to ensure
 // that *nothing* sees the non-trivial mutex declaration. For this reason
 // we re-declare the entire class in this file instead of using
 // _LIBCPP_BUILDING_LIBRARY to change the definition in the headers.
 
-#include "__config"
-#include "__threading_support"
+#include <__config>
+#include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_THREADS)
-#if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
-#define NEEDS_MUTEX_DESTRUCTOR
-#endif
+#  if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
+#    define NEEDS_MUTEX_DESTRUCTOR
+#  endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef NEEDS_MUTEX_DESTRUCTOR
 class _LIBCPP_TYPE_VIS mutex
 {
     __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;

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 <new>
 #include <stdlib.h>
 
-#include "new"
 #include "include/atomic_support.h"
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
 #   if !defined(_LIBCPP_ABI_VCRUNTIME)
 #       include "support/runtime/new_handler_fallback.ipp"
 #   endif
 #elif defined(LIBCXX_BUILDING_LIBCXXABI)
 #   include <cxxabi.h>

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

libcxx/src/random.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>
 
 #if defined(_LIBCPP_USING_WIN32_RANDOM)
     // Must be defined before including stdlib.h to enable rand_s().
 #   define _CRT_RAND_S
 #endif // defined(_LIBCPP_USING_WIN32_RANDOM)
 
-#include "limits"
-#include "random"
-#include "system_error"
+#include <limits>
+#include <random>
+#include <system_error>
 
 #if defined(__sun__)
 #   define rename solaris_headers_are_broken
 #endif // defined(__sun__)
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>

libcxx/src/random_shuffle.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 "algorithm"
-#include "random"
+#include <algorithm>
+#include <random>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
-#   include "mutex"
-#   if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#       pragma comment(lib, "pthread")
-#   endif
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 static constinit __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
 #endif
 unsigned __rs_default::__c_ = 0;

libcxx/src/regex.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 "regex"
-#include "algorithm"
-#include "iterator"
+#include <algorithm>
+#include <iterator>
+#include <regex>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 static
 const char*
 make_error_type_string(regex_constants::error_type ecode)
 {
     switch (ecode)

libcxx/src/ryu/d2fixed.cpp

 // 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.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
-#include "charconv"
-#include "cstring"
-#include "system_error"
+#include <__config>
+#include <charconv>
+#include <cstring>
+#include <system_error>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2fixed_full_table.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_intrinsics.h"
 #include "include/ryu/digit_table.h"
 

libcxx/src/ryu/d2s.cpp

 // 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.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
-#include "charconv"
+#include <__config>
+#include <charconv>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_full_table.h"
 #include "include/ryu/d2s_intrinsics.h"
 #include "include/ryu/digit_table.h"
 #include "include/ryu/ryu.h"

libcxx/src/ryu/f2s.cpp

 // 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.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
-#include "__config"
-#include "charconv"
+#include <__config>
+#include <charconv>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s_intrinsics.h"
 #include "include/ryu/digit_table.h"
 #include "include/ryu/f2s.h"
 #include "include/ryu/ryu.h"
 

libcxx/src/shared_mutex.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 <__config>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-#include "shared_mutex"
+#include <shared_mutex>
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
+#  pragma comment(lib, "pthread")
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Shared Mutex Base
 __shared_mutex_base::__shared_mutex_base()
     : __state_(0)
 {

libcxx/src/stdexcept.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 "stdexcept"
-#include "new"
-#include "string"
-#include "system_error"
-
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <system_error>
 
 #ifdef _LIBCPP_ABI_VCRUNTIME
 #include "support/runtime/stdexcept_vcruntime.ipp"
 #else
 #include "support/runtime/stdexcept_default.ipp"
 #endif

libcxx/src/string.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 "string"
-#include "charconv"
-#include "cstdlib"
-#include "cerrno"
-#include "limits"
-#include "stdexcept"
+#include <__debug>
+#include <cerrno>
+#include <charconv>
+#include <cstdlib>
+#include <limits>
+#include <stdexcept>
 #include <stdio.h>
-#include "__debug"
+#include <string>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-#   include "cwchar"
+#  include <cwchar>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
 
 template <bool>
 struct __basic_string_common;

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 <__utility/unreachable.h>
-#include "strstream"
-#include "algorithm"
-#include "climits"
-#include "cstring"
-#include "cstdlib"
-#include "__debug"
-#include "__undef_macros"
+#include <__debug>
+#include <algorithm>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <strstream>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 strstreambuf::strstreambuf(streamsize __alsize)
     : __strmode_(__dynamic),
       __alsize_(__alsize),
       __palloc_(nullptr),
       __pfree_(nullptr)

 {
 }
 
 strstream::~strstream()
 {
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS

libcxx/src/system_error.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 "system_error"
+#include <__config>
+#include <__debug>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <string.h>
+#include <system_error>
 
 #include "include/config_elast.h"
-#include "cerrno"
-#include "cstring"
-#include "cstdio"
-#include "cstdlib"
-#include "string"
-#include "string.h"
-#include "__debug"
 
 #if defined(__ANDROID__)
 #include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // class error_category

libcxx/src/thread.cpp

 //===------------------------- thread.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 <__config>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-#include "thread"
-#include "exception"
-#include "vector"
-#include "future"
-#include "limits"
+#include <exception>
+#include <future>
+#include <limits>
+#include <thread>
+#include <vector>
 
 #if __has_include(<unistd.h>)
 # include <unistd.h> // for sysconf
 #endif
 
 #if defined(__NetBSD__)
 #pragma weak pthread_create // Do not create libpthread dependency
 #endif

libcxx/src/typeinfo.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 "typeinfo"
+#include <typeinfo>
 
 #if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_ABI_VCRUNTIME)
+
 #include <string.h>
 
 int std::type_info::__compare(const type_info &__rhs) const noexcept {
   if (&__data == &__rhs.__data)
     return 0;
   return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
 }
 

libcxx/src/utility.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 "utility"
+#include <utility>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const piecewise_construct_t piecewise_construct{};
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/valarray.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 "valarray"
+#include <valarray>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // These two symbols are part of the v1 ABI but not part of the >=v2 ABI.
 #if _LIBCPP_ABI_VERSION == 1
 template _LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t);
 template _LIBCPP_FUNC_VIS valarray<size_t>::~valarray();
 #endif

libcxx/src/variant.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 "variant"
+#include <variant>
 
 namespace std {
 
 const char* bad_variant_access::what() const noexcept {
   return "bad_variant_access";
 }
 
 }  // namespace std

libcxx/src/vector.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 "vector"
+#include <vector>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
 
 template <bool>
 struct __vector_base_common;