[libcxx][pmr] Make std::pmr::memory_resource ABI-compatible with GNU libstdc++ and Microsoft STL implementation.

[ldionne]

Summary

The idea of this patch to make libcxx implementation of std::pmr::memory_resource and some of its utilities ABI-compatible with GNU and Microsoft implementation of standard library.

Since both GNU and Microsoft libraries have the name without namespace versioning we would like to remove that as well in libcxx to result in the same mangled name with GNU implementation. It also allows to let's say set memory_resource via std::pmr::set_default_resource in some library compiled with GNU/Microsoft and then read it with std::pmr::<get|set>_default_resource it in the library/application that is built with libcxx.

The similar technic as applied (for example) for std::<get|set>_terminate functions.

I believe it's worth committing this patch before release because now the latest libcxx has no implementation of memory resource. Introducing it later would be the ABI breaking change.

Please advise what tests should we add

Co-authored-by: Konstantin Boyarinov <[e-mail]>

[philnik]

Our implementation isn't ABI compatible with libstdc++ or the MSVL STL. Putting them in the same namespace just results in subtle bugs.

[rarutyun]

In D142902#4090931, @philnik wrote:

Our implementation isn't ABI compatible with libstdc++ or the MSVL STL. Putting them in the same namespace just results in subtle bugs.

Is which sense?

• If we are talking about the full C++ standard library implementation - of course, it's not, but some parts were intentionally done compatible. For example: exception_ptr, <get|set>_terminate and other basic stuff.
• If we are talking about the full <memory_resource> implementation it also would not be fully ABI compatible. But probably it should not be.
• If we are talking just about std::pmr::memory_resource (and <get|set>_terminate), I believe it should be ABI compatible. The virtual methods are listed in the same order in libcxx file as in GNU and LLVM. So, to the best of my knowledge (and also based on experiments) the compiler correctly calculates the offset of the virtual table itself and the offset of the called method. That allows to pass memory resource from one binary (or translation unit) and interpret it correctly in other translation unit.

I think get|set_default_resource are also possible to make ABI compatible. Memory allocation is pretty basic operation and (as far as I know) there were attempts (probably successful, but as far as I remember something was broken with Windows toolchain) to make new ABI compatible with GNU and MSVC STL as well (set_new_handler, etc.) The behavior we want here is having the opportunity to have one default resource being set and then use it application-wide (for example if libcxx is built in compat mode with GNU). The similar scenario works with <get|set_terminate.

Other classes from pmr can potentially bring problems. If that's the concern probably the solution might be to put some APIs to __1 namespace. And I am not sure if those are bugs or not because nobody guarantees that two different C++ standard library implementations would work in one application (or I misunderstood the context). It might result in submitted bugs in bug tracker, though :) But still libcxx makes some effort to be ABI compatible with GNU and Microsoft for basic APIs. To me this use-cases as important as other examples I've provided above.

[philnik]

In D142902#4091857, @rarutyun wrote:

In D142902#4090931, @philnik wrote:

Our implementation isn't ABI compatible with libstdc++ or the MSVL STL. Putting them in the same namespace just results in subtle bugs.

Is which sense?

• If we are talking about the full C++ standard library implementation - of course, it's not, but some parts were intentionally done compatible. For example: exception_ptr, <get|set>_terminate and other basic stuff.
• If we are talking about the full <memory_resource> implementation it also would not be fully ABI compatible. But probably it should not be.
• If we are talking just about std::pmr::memory_resource (and <get|set>_terminate), I believe it should be ABI compatible. The virtual methods are listed in the same order in libcxx file as in GNU and LLVM. So, to the best of my knowledge (and also based on experiments) the compiler correctly calculates the offset of the virtual table itself and the offset of the called method. That allows to pass memory resource from one binary (or translation unit) and interpret it correctly in other translation unit.

I think get|set_default_resource are also possible to make ABI compatible. Memory allocation is pretty basic operation and (as far as I know) there were attempts (probably successful, but as far as I remember something was broken with Windows toolchain) to make new ABI compatible with GNU and MSVC STL as well (set_new_handler, etc.) The behavior we want here is having the opportunity to have one default resource being set and then use it application-wide (for example if libcxx is built in compat mode with GNU). The similar scenario works with <get|set_terminate.

Other classes from pmr can potentially bring problems. If that's the concern probably the solution might be to put some APIs to __1 namespace. And I am not sure if those are bugs or not because nobody guarantees that two different C++ standard library implementations would work in one application (or I misunderstood the context). It might result in submitted bugs in bug tracker, though :) But still libcxx makes some effort to be ABI compatible with GNU and Microsoft for basic APIs. To me this use-cases as important as other examples I've provided above.

I'm not convinced it's a good idea to guarantee ABI compatibility in any way here, but my main concern right now is that the changes in this patch don't reflect what is claimed in the commit message. monotonic_buffer_resource, etc. are clearly not ABI compatible and polymorphic_resource should probably also be in the versioned namespace. I see no reason to change that. The aliases also don't belong in the unversioned namespace. It doesn't make any real difference, but you look twice every time you come across it. (BTW it would have been nice to see this patch a few months ago, not after the release branch where the ABI is set in stone to have some time to discuss this)

[rarutyun]

I'm not convinced it's a good idea to guarantee ABI compatibility in any way here, but my main concern right now is that the changes in this patch don't reflect what is claimed in the commit message. monotonic_buffer_resource, etc. are clearly not ABI compatible and polymorphic_resource should probably also be in the versioned namespace. I see no reason to change that.

Ok, I basically agree that we should not mix things. But I do believe that making std::pmr::<get|set>_default_resourse as well as std::pmr::memory_resource itself still worth our efforts because as I said it's basic global API for default memory allocation source and might be used application-wide. I definitely agree that monotonic_buffer_resource (+ other resources) and polymorphic_allocator (I believe, you meant that) are not ABI compatible and I am not arguing they should be. Unfortunately, we can not mix namespace std::pmr and namespace std::_1::pmr where _1 is inline namespace because in that case pmr name becomes ambiguous (https://godbolt.org/z/YPEY6Kd8o). What we could do to prevent that ambiguity is

either (Actually I don't believe anybody would want that because it's not consistent with the rest of the library implementation and is not something how it is supposed to introduce the versioning namespace):

namespace std {
namespace pmr
{
inline namespace _1 {
// Non-ABI compatible pmr stuff
}
}

Or something like (That option is more viable in my opinion):

namespace std {

    namespace pmr {
        class memory_resource {};
    }

    inline namespace _1 {
        namespace detail { // whatever name you prefer
            // and other non ABI-compatible APIs
            class monotonic_buffer_resource {};
        }
    }

    namespace pmr {
        // and other pmr non ABI-compatible API names
        using detail::monotonic_buffer_resource;
    }  
}

The aliases also don't belong in the unversioned namespace. It doesn't make any real difference, but you look twice every time you come across it.

I completely agree with that. They just don't affect ABI anyhow. So, I don't care in which namespace they are. The reason why it was changed is exactly because of pmr name ambiguity issue I am talking about above.

(BTW it would have been nice to see this patch a few months ago, not after the release branch where the ABI is set in stone to have some time to discuss this)

Sorry about that but I occasionally found out that <memory_resource> was implemented in libc++ (at the end of December IIRC) and unfortunately I am not familiar when the release branch is created and frozen. The end of December doesn't sound like "a few months ago" anyway but I do believe if we still have some opportunity window to make it happen in the upcoming release it would be great because later it would mean ABI breaking change that (I think) makes it impossible to introduce in future.

P.S. buildbot is broken with these changes right now but I want to have an understanding if we do that or not and how we do that before fixing every error in the CI.

[ldionne]

I don't think this is a guarantee we want to provide at all. Have libstdc++ and MSVC concerted to make sure their respective pmr implementations were ABI compatible? FWIW that's the only thing that would make me think this is a good guarantee to provide (but then we should get it enshrined into the Standard). This sort of "guarantee" is extremely difficult to provide and maintain through years of software evolution, so it's not to be taken lightly. If we claim to be ABI compatible but we fail to do a good job at it, we won't be helping anyone, so that would be even worse than not providing it from the start.

[rarutyun]

In D142902#4119069, @ldionne wrote:

Have libstdc++ and MSVC concerted to make sure their respective pmr implementations were ABI compatible?

It's not fully ABI compatible. As far as I know GNU libstdc++ doesn't have compat layer at all. Since Microsoft linker works differently comparing with GNU one, without some compat layer Microsoft linker would not choose the right symbol to link with. memory_resource, however, should be ABI compatible. They list the virtual functions in the same order (probably occasionally). So, if somebody passes it across translation units everything should work fine.

In D142902#4119069, @ldionne wrote:

This sort of "guarantee" is extremely difficult to provide and maintain through years of software evolution, so it's not to be taken lightly. If we claim to be ABI compatible but we fail to do a good job at it, we won't be helping anyone, so that would be even worse than not providing it from the start.

Ok, how about making just <get|set>_memory_resource ABI compatible?

We could leave everything in _LIBCPP_BEGIN_NAMESPACE_STD and then use functions with different (mangled) names comparing with GNU and MSVC STL. In the implementation of compat layer for those functions we reinterpret_cast memory_resource similarly how it's done in exceptions ABI compatibility layer for exception_ptr. Since memory_resource is already ABI compatible (not name-wise but layout-wise) everything should work just fine. I could also understand your concern about potential further changes of memory_resource but I think changing the set of virtual methods is an ABI breaking change anyway because you cannot freely path this object anymore across the translation units after that. BTW, with the option of making just <get|set>_memory_resource ABI compatible I believe we could apply this patch even after the release because it would not be the ABI break. I need to think more about new_delete_resource and null_memory_resource though, to make sure they are also unaffected.

I often mention <get|set>_terminate as the example of similar behavior and I understand that things are more complicated here due to virtual table of memory_resource but I still believe in use-case importance where user could set global memory pool for the whole application and then all the calls just go to the right place.

[ldionne]

[Github PR transition cleanup]

I don't know how to say this other than to say that we are reluctant to increase the complexity and the "API surface" (in the general sense of having a contract with users) of the library in order to provide an impression of ABI-compatibility with MSVC. If we wanted to be truly ABI compatible with MSVC in some regards, we would want to have a much more holistic plan than just making sure these function names match and a few data structures happen to have the same layout. That's just too brittle and it creates a haunted graveyard where we'll forever wonder how much leeway we have in making changes to our code because of this presumed ABI compatibility. I also question how much benefit this would provide to users, since I expect the number of people that will try to mix libc++ and the MSVC STL in a way that requires ABI compatibility to be extremely tiny.

Also, generally speaking, mixing stdlibs makes it super easy for users to get into sketchy situations without understanding why. We generally frown upon making changes that suggest it's a good idea. For all these reasons, I believe this patch is not in line with where we want to take the library so I'm going to close it. (Sorry, that requires commandeering and then abandoning which may seem a bit rude, but it's how Phab works)

[rarutyun]

In D142902#4631440, @ldionne wrote:

[Github PR transition cleanup]

I don't know how to say this other than to say that we are reluctant to increase the complexity and the "API surface" (in the general sense of having a contract with users) of the library in order to provide an impression of ABI-compatibility with MSVC. If we wanted to be truly ABI compatible with MSVC in some regards, we would want to have a much more holistic plan than just making sure these function names match and a few data structures happen to have the same layout. That's just too brittle and it creates a haunted graveyard where we'll forever wonder how much leeway we have in making changes to our code because of this presumed ABI compatibility. I also question how much benefit this would provide to users, since I expect the number of people that will try to mix libc++ and the MSVC STL in a way that requires ABI compatibility to be extremely tiny.

Also, generally speaking, mixing stdlibs makes it super easy for users to get into sketchy situations without understanding why. We generally frown upon making changes that suggest it's a good idea. For all these reasons, I believe this patch is not in line with where we want to take the library so I'm going to close it. (Sorry, that requires commandeering and then abandoning which may seem a bit rude, but it's how Phab works)

Hi Louis,

No worries. I am not considering it rude. As I said I see the point of making this patch since you already have some compatibility layer. On the other hand, I can completely understand your arguments. So, to me, it's totally fine to abandon this review if you guys are not interested in those changes.

libcxx/include/__fwd/memory_resource.h

 #define _LIBCPP___FWD_MEMORY_RESOURCE_H
 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 template <class _ValueType>
 class _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP___FWD_MEMORY_RESOURCE_H

libcxx/include/__fwd/string.h

 using u8string = basic_string<char8_t>;
 #endif
 
 using u16string = basic_string<char16_t>;
 using u32string = basic_string<char32_t>;
 
 #if _LIBCPP_STD_VER >= 17
 
+_LIBCPP_END_NAMESPACE_STD
+
+namespace std {
 namespace pmr {
+
 template <class _CharT, class _Traits = char_traits<_CharT>>
 using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
 
 using string = basic_string<char>;
 
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wstring = basic_string<wchar_t>;
 #  endif
 
 #  ifndef _LIBCPP_HAS_NO_CHAR8_T
 using u8string = basic_string<char8_t>;
 #  endif
 
 using u16string = basic_string<char16_t>;
 using u32string = basic_string<char32_t>;
 
 } // namespace pmr
+} // namespace std
+
+_LIBCPP_BEGIN_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 17
 
 // clang-format off
 template <class _CharT, class _Traits, class _Allocator>
 class _LIBCPP_PREFERRED_NAME(string)
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
       _LIBCPP_PREFERRED_NAME(wstring)

libcxx/include/__memory_resource/memory_resource.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.res.class]
 
 class _LIBCPP_TYPE_VIS memory_resource {
   static const size_t __max_align = alignof(max_align_t);
 

 
 [[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
 [[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
 [[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
 [[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

libcxx/include/__memory_resource/monotonic_buffer_resource.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.res.monotonic.buffer]
 
 class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource {
   static const size_t __default_buffer_capacity  = 1024;
   static const size_t __default_buffer_alignment = 16;

 private:
   __initial_descriptor __initial_;
   __chunk_footer* __chunks_;
   memory_resource* __res_;
 };
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_MONOTONIC_BUFFER_RESOURCE_H

libcxx/include/__memory_resource/polymorphic_allocator.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.poly.allocator.class]
 
 template <class _ValueType
 #  if _LIBCPP_STD_VER >= 20
           = byte

 template <class _Tp, class _Up>
 inline _LIBCPP_HIDE_FROM_ABI bool
 operator!=(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H

libcxx/include/__memory_resource/pool_options.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.res.pool.options]
 
 struct _LIBCPP_TYPE_VIS pool_options {
   size_t max_blocks_per_chunk        = 0;
   size_t largest_required_pool_block = 0;
 };
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_POOL_OPTIONS_H

libcxx/include/__memory_resource/synchronized_pool_resource.h

 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.res.pool.overview]
 
 class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource {
 public:
   _LIBCPP_HIDE_FROM_ABI synchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream)

 #  if !defined(_LIBCPP_HAS_NO_THREADS)
   mutex __mut_;
 #  endif
   unsynchronized_pool_resource __unsync_;
 };
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 14
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std { // purposefully not using versioning namespace
 
 namespace pmr {
 
 // [mem.res.pool.overview]
 
 class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource {
   class __fixed_pool;
 
private:
   __adhoc_pool __adhoc_pool_;
   __fixed_pool* __fixed_pools_;
   int __num_fixed_pools_;
   uint32_t __options_max_blocks_per_chunk_;
 };
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H

libcxx/include/deque

 inline constexpr bool __format::__enable_insertable<std::deque<wchar_t>> = true;
 #endif
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std {
+
 namespace pmr {
 template <class _ValueT>
 using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_DEQUE

libcxx/include/forward_list

inline _LIBCPP_INLINE_VISIBILITY
     erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
   return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _ValueT>
 using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_FORWARD_LIST

libcxx/include/list

 inline constexpr bool __format::__enable_insertable<std::list<wchar_t>> = true;
 #endif
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _ValueT>
 using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LIST

libcxx/include/map

erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
              _Predicate __pred) {
   return _VSTD::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
 using map = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
 using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MAP

libcxx/include/regex

_VSTD::regex_replace(std::back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _BidirT>
 using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
 
 using cmatch  = match_results<const char*>;
 using smatch  = match_results<std::pmr::string::const_iterator>;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wcmatch = match_results<const wchar_t*>;
 using wsmatch = match_results<std::pmr::wstring::const_iterator>;
 #endif
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <iosfwd>
 #  include <iterator>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/set

inline _LIBCPP_INLINE_VISIBILITY
     erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
   return _VSTD::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
 using set = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
 using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_SET

libcxx/include/unordered_map

operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
 using unordered_map =
     std::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
 using unordered_multimap =
     std::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
 #  include <concepts>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_UNORDERED_MAP

libcxx/include/unordered_set

operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace std {
+
 namespace pmr {
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
 using unordered_set = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
 using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_UNORDERED_SET

libcxx/include/vector

_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __ref, _FormatContext& __ctx) const {
         return __underlying_.format(__ref, __ctx);
   }
 };
 #endif // _LIBCPP_STD_VER > 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std {
+
 namespace pmr {
 template <class _ValueT>
 using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
-_LIBCPP_END_NAMESPACE_STD
+
+} // namespace std
+
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VECTOR

libcxx/src/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 <memory>
 #include <memory_resource>
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#  include "support/runtime/memory_resource_msvc.ipp"
+#else
+#  include "support/runtime/memory_resource_fallback.ipp"
+#endif
+
 #ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
 #  include <atomic>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <mutex>
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std {
 
 namespace pmr {
 
 // memory_resource
 
 memory_resource::~memory_resource() = default;
 
-// new_delete_resource()
-
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-static bool is_aligned_to(void* ptr, size_t align) {
-  void* p2     = ptr;
-  size_t space = 1;
-  void* result = std::align(align, 1, p2, space);
-  return (result == ptr);
-}
-#endif
-
-class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp : public memory_resource {
-  void* do_allocate(size_t bytes, size_t align) override {
-#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-    return std::__libcpp_allocate(bytes, align);
-#else
-    if (bytes == 0)
-      bytes = 1;
-    void* result = std::__libcpp_allocate(bytes, align);
-    if (!is_aligned_to(result, align)) {
-      std::__libcpp_deallocate(result, bytes, align);
-      __throw_bad_alloc();
-    }
-    return result;
-#endif
-  }
-
-  void do_deallocate(void* p, size_t bytes, size_t align) override { std::__libcpp_deallocate(p, bytes, align); }
-
-  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
-};
-
-// null_memory_resource()
-
-class _LIBCPP_TYPE_VIS __null_memory_resource_imp : public memory_resource {
-  void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
-  void do_deallocate(void*, size_t, size_t) override {}
-  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
-};
-
-namespace {
-
-union ResourceInitHelper {
-  struct {
-    __new_delete_memory_resource_imp new_delete_res;
-    __null_memory_resource_imp null_res;
-  } resources;
-  char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
-  ~ResourceInitHelper() {}
-};
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "memory_resource_init_helper.h"
-
-} // end namespace
-
-memory_resource* new_delete_resource() noexcept { return &res_init.resources.new_delete_res; }
-
-memory_resource* null_memory_resource() noexcept { return &res_init.resources.null_res; }
-
-// default_memory_resource()
-
-static memory_resource* __default_memory_resource(bool set = false, memory_resource* new_res = nullptr) noexcept {
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-  static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
-  if (set) {
-    new_res = new_res ? new_res : new_delete_resource();
-    // TODO: Can a weaker ordering be used?
-    return std::atomic_exchange_explicit(&__res, new_res, memory_order_acq_rel);
-  } else {
-    return std::atomic_load_explicit(&__res, memory_order_acquire);
-  }
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-  static constinit memory_resource* res = &res_init.resources.new_delete_res;
-  static mutex res_lock;
-  if (set) {
-    new_res = new_res ? new_res : new_delete_resource();
-    lock_guard<mutex> guard(res_lock);
-    memory_resource* old_res = res;
-    res = new_res;
-    return old_res;
-  } else {
-    lock_guard<mutex> guard(res_lock);
-    return res;
-  }
-#else
-  static constinit memory_resource* res = &res_init.resources.new_delete_res;
-  if (set) {
-    new_res                  = new_res ? new_res : new_delete_resource();
-    memory_resource* old_res = res;
-    res                      = new_res;
-    return old_res;
-  } else {
-    return res;
-  }
-#endif
-}
-
-memory_resource* get_default_resource() noexcept { return __default_memory_resource(); }
-
-memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
-  return __default_memory_resource(true, __new_res);
-}
-
 // 23.12.5, mem.res.pool
 
 static size_t roundup(size_t count, size_t alignment) {
   size_t mask = alignment - 1;
   return (count + mask) & ~mask;
 }
 
 struct unsynchronized_pool_resource::__adhoc_pool::__chunk_footer {
void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align) {
   footer->__align_       = align;
   __chunks_              = footer;
 
   return __chunks_->__try_allocate_from_chunk(bytes, align);
 }
 
 } // namespace pmr
 
-_LIBCPP_END_NAMESPACE_STD
+} // namespace std

libcxx/src/support/runtime/memory_resource_fallback.ipp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+namespace std {
+
+namespace pmr {
+
+// new_delete_resource()
+
+#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+static bool is_aligned_to(void* ptr, size_t align) {
+  void* p2     = ptr;
+  size_t space = 1;
+  void* result = std::align(align, 1, p2, space);
+  return (result == ptr);
+}
+#endif
+
+class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t bytes, size_t align) override {
+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+    return std::__libcpp_allocate(bytes, align);
+#else
+    if (bytes == 0)
+      bytes = 1;
+    void* result = std::__libcpp_allocate(bytes, align);
+    if (!is_aligned_to(result, align)) {
+      std::__libcpp_deallocate(result, bytes, align);
+      __throw_bad_alloc();
+    }
+    return result;
+#endif
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t align) override { std::__libcpp_deallocate(p, bytes, align); }
+
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+// null_memory_resource()
+
+class _LIBCPP_TYPE_VIS __null_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
+  void do_deallocate(void*, size_t, size_t) override {}
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+namespace {
+
+union ResourceInitHelper {
+  struct {
+    __new_delete_memory_resource_imp new_delete_res;
+    __null_memory_resource_imp null_res;
+  } resources;
+  char dummy;
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
+  ~ResourceInitHelper() {}
+};
+
+// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
+// attribute with a value that's reserved for the implementation (we're the implementation).
+#include "memory_resource_init_helper.h"
+
+} // end namespace
+
+memory_resource* new_delete_resource() noexcept { return &res_init.resources.new_delete_res; }
+
+memory_resource* null_memory_resource() noexcept { return &res_init.resources.null_res; }
+
+// default_memory_resource()
+
+static memory_resource* __default_memory_resource(bool set = false, memory_resource* new_res = nullptr) noexcept {
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+  static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    // TODO: Can a weaker ordering be used?
+    return std::atomic_exchange_explicit(&__res, new_res, memory_order_acq_rel);
+  } else {
+    return std::atomic_load_explicit(&__res, memory_order_acquire);
+  }
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  static mutex res_lock;
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    lock_guard<mutex> guard(res_lock);
+    memory_resource* old_res = res;
+    res = new_res;
+    return old_res;
+  } else {
+    lock_guard<mutex> guard(res_lock);
+    return res;
+  }
+#else
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  if (set) {
+    new_res                  = new_res ? new_res : new_delete_resource();
+    memory_resource* old_res = res;
+    res                      = new_res;
+    return old_res;
+  } else {
+    return res;
+  }
+#endif
+}
+
+memory_resource* get_default_resource() noexcept { return __default_memory_resource(); }
+
+memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
+  return __default_memory_resource(true, __new_res);
+}
+
+} // namespace pmr
+} // namespace std

libcxx/src/support/runtime/memory_resource_msvc.ipp

+// -*- 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_ABI_MICROSOFT
+#error this header can only be used when targeting the MSVC ABI
+#endif
+
+// default_memory_resource()
+
+extern "C" {
+
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Aligned_set_default_resource(std::pmr::memory_resource*) noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Unaligned_set_default_resource(std::pmr::memory_resource*) noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Aligned_get_default_resource() noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Unaligned_get_default_resource() noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Aligned_new_delete_resource() noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl _Unaligned_new_delete_resource() noexcept;
+_LIBCPP_CRT_FUNC std::pmr::memory_resource* __cdecl null_memory_resource() noexcept;
+
+};
+
+namespace std {
+
+namespace pmr {
+
+memory_resource* get_default_resource() noexcept {
+#ifdef __cpp_aligned_new
+    return ::_Aligned_get_default_resource();
+#else
+    return ::_Unaligned_get_default_resource();
+#endif
+}
+
+memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
+#ifdef __cpp_aligned_new
+    return ::_Aligned_set_default_resource(__new_res);
+#else
+    return ::_Unaligned_set_default_resource(__new_res);
+#endif
+}
+
+memory_resource* new_delete_resource() noexcept {
+#ifdef __cpp_aligned_new
+    return ::_Aligned_new_delete_resource();
+#else
+    return ::_Unaligned_new_delete_resource();
+#endif
+}
+
+memory_resource* null_memory_resource() noexcept {
+    return ::null_memory_resource();
+}
+
+} // namespace pmr
+
+} // namespace std