diff --git a/stl/inc/regex b/stl/inc/regex
index 0cd17c2b3a0..330944b8a28 100644
--- a/stl/inc/regex
+++ b/stl/inc/regex
@@ -2466,7 +2466,7 @@ public:
                 _MyRe = nullptr;
 
 #if _ITERATOR_DEBUG_LEVEL == 2
-                this->_Orphan_me();
+                this->_Orphan_me_v2();
 #endif // _ITERATOR_DEBUG_LEVEL
 
                 return *this;
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 6c54d796390..9550df6676a 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -27,7 +27,7 @@ _STD_BEGIN
 template <class _Ty>
 struct _NODISCARD _Tidy_guard { // class with destructor that calls _Tidy
     _Ty* _Target;
-    ~_Tidy_guard() {
+    _CONSTEXPR20_DYNALLOC ~_Tidy_guard() {
         if (_Target) {
             _Target->_Tidy();
         }
@@ -38,7 +38,7 @@ struct _NODISCARD _Tidy_guard { // class with destructor that calls _Tidy
 template <class _Ty>
 struct _NODISCARD _Tidy_deallocate_guard { // class with destructor that calls _Tidy_deallocate
     _Ty* _Target;
-    ~_Tidy_deallocate_guard() {
+    _CONSTEXPR20_DYNALLOC ~_Tidy_deallocate_guard() {
         if (_Target) {
             _Target->_Tidy_deallocate();
         }
@@ -286,12 +286,12 @@ using _Rebind_pointer_t = typename pointer_traits<_Ptr>::template rebind<_Ty>;
 
 // FUNCTION TEMPLATE _Refancy
 template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
-_Pointer _Refancy(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
+_CONSTEXPR20 _Pointer _Refancy(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
     return pointer_traits<_Pointer>::pointer_to(*_Ptr);
 }
 
 template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
-_Pointer _Refancy(_Pointer _Ptr) noexcept {
+_CONSTEXPR20 _Pointer _Refancy(_Pointer _Ptr) noexcept {
     return _Ptr;
 }
 
@@ -843,7 +843,7 @@ public:
 
     template <class _Objty, class... _Types>
     _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void construct(_Objty* const _Ptr, _Types&&... _Args) {
-        ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr))) _Objty(_STD forward<_Types>(_Args)...);
+        ::new (_Voidify_iter(_Ptr)) _Objty(_STD forward<_Types>(_Args)...);
     }
 
     template <class _Uty>
@@ -909,7 +909,7 @@ using _Alloc_size_t = typename allocator_traits<_Alloc>::size_type;
 
 // FUNCTION TEMPLATE _Pocca
 template <class _Alloc>
-void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
+_CONSTEXPR20 void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
     if constexpr (allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value) {
         _Left = _Right;
     }
@@ -917,7 +917,7 @@ void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
 
 // FUNCTION TEMPLATE _Pocma
 template <class _Alloc>
-void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { // (maybe) propagate on container move assignment
+_CONSTEXPR20 void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { // (maybe) propagate on container move assignment
     if constexpr (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value) {
         _Left = _STD move(_Right);
     }
@@ -925,7 +925,7 @@ void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { // (maybe) propagate on co
 
 // FUNCTION TEMPLATE _Pocs
 template <class _Alloc>
-void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
+_CONSTEXPR20 void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
     if constexpr (allocator_traits<_Alloc>::propagate_on_container_swap::value) {
         _Swap_adl(_Left, _Right);
     } else {
@@ -935,7 +935,8 @@ void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
 
 // FUNCTION TEMPLATE _Destroy_range WITH ALLOC
 template <class _Alloc>
-void _Destroy_range(_Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
+_CONSTEXPR20_DYNALLOC void _Destroy_range(
+    _Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
     // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
     using _Ty = typename _Alloc::value_type;
     if constexpr (!conjunction_v<is_trivially_destructible<_Ty>, _Uses_default_destroy<_Alloc, _Ty*>>) {
@@ -975,7 +976,7 @@ _NODISCARD constexpr size_t _Convert_size<size_t>(const size_t _Len) noexcept {
 
 // FUNCTION TEMPLATE _Deallocate_plain
 template <class _Alloc>
-void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+_CONSTEXPR20_DYNALLOC void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
     // deallocate a plain pointer using an allocator
     using _Alloc_traits = allocator_traits<_Alloc>;
     if constexpr (is_same_v<_Alloc_ptr_t<_Alloc>, typename _Alloc::value_type*>) {
@@ -988,7 +989,7 @@ void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noe
 
 // FUNCTION TEMPLATE _Delete_plain_internal
 template <class _Alloc>
-void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+_CONSTEXPR20_DYNALLOC void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
     // destroy *_Ptr in place, then deallocate _Ptr using _Al; used for internal container types the user didn't name
     using _Ty = typename _Alloc::value_type;
     _Ptr->~_Ty();
@@ -1002,18 +1003,18 @@ struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_
     _Alloc& _Al;
     pointer _Ptr;
 
-    explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {}
+    _CONSTEXPR20_DYNALLOC explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {}
 
-    _NODISCARD pointer _Release() noexcept { // disengage *this and return contained pointer
+    _NODISCARD _CONSTEXPR20_DYNALLOC pointer _Release() noexcept { // disengage *this and return contained pointer
         return _STD exchange(_Ptr, nullptr);
     }
 
-    void _Allocate() { // disengage *this, then allocate a new memory block
+    _CONSTEXPR20_DYNALLOC void _Allocate() { // disengage *this, then allocate a new memory block
         _Ptr = nullptr; // if allocate throws, prevents double-free
         _Ptr = _Al.allocate(1);
     }
 
-    ~_Alloc_construct_ptr() { // if this instance is engaged, deallocate storage
+    _CONSTEXPR20_DYNALLOC ~_Alloc_construct_ptr() { // if this instance is engaged, deallocate storage
         if (_Ptr) {
             _Al.deallocate(_Ptr, 1);
         }
@@ -1027,15 +1028,15 @@ struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_
 struct _Fake_allocator {};
 
 struct _Container_base0 {
-    void _Orphan_all() noexcept {}
-    void _Swap_proxy_and_iterators(_Container_base0&) noexcept {}
-    void _Alloc_proxy(const _Fake_allocator&) noexcept {}
-    void _Reload_proxy(const _Fake_allocator&, const _Fake_allocator&) noexcept {}
+    _CONSTEXPR20_CONTAINER void _Orphan_all() noexcept {}
+    _CONSTEXPR20_CONTAINER void _Swap_proxy_and_iterators(_Container_base0&) noexcept {}
+    _CONSTEXPR20_CONTAINER void _Alloc_proxy(const _Fake_allocator&) noexcept {}
+    _CONSTEXPR20_CONTAINER void _Reload_proxy(const _Fake_allocator&, const _Fake_allocator&) noexcept {}
 };
 
 struct _Iterator_base0 {
-    void _Adopt(const void*) noexcept {}
-    const _Container_base0* _Getcont() const noexcept {
+    _CONSTEXPR20_CONTAINER void _Adopt(const void*) noexcept {}
+    _CONSTEXPR20_CONTAINER const _Container_base0* _Getcont() const noexcept {
         return nullptr;
     }
 
@@ -1045,25 +1046,25 @@ struct _Iterator_base0 {
 // CLASS _Container_proxy
 struct _Container_base12;
 struct _Container_proxy { // store head of iterator chain and back pointer
-    _Container_proxy() noexcept : _Mycont(nullptr), _Myfirstiter(nullptr) {}
-    _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_), _Myfirstiter(nullptr) {}
+    _CONSTEXPR20_CONTAINER _Container_proxy() noexcept = default;
+    _CONSTEXPR20_CONTAINER _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_) {}
 
-    const _Container_base12* _Mycont;
-    _Iterator_base12* _Myfirstiter;
+    const _Container_base12* _Mycont       = nullptr;
+    mutable _Iterator_base12* _Myfirstiter = nullptr;
 };
 
 struct _Container_base12 {
 public:
-    _Container_base12() noexcept : _Myproxy(nullptr) {}
+    _CONSTEXPR20_CONTAINER _Container_base12() noexcept = default;
 
     _Container_base12(const _Container_base12&) = delete;
     _Container_base12& operator=(const _Container_base12&) = delete;
 
-    void _Orphan_all() noexcept;
-    void _Swap_proxy_and_iterators(_Container_base12&) noexcept;
+    _CONSTEXPR20_CONTAINER void _Orphan_all() noexcept;
+    _CONSTEXPR20_CONTAINER void _Swap_proxy_and_iterators(_Container_base12&) noexcept;
 
     template <class _Alloc>
-    void _Alloc_proxy(_Alloc&& _Al) {
+    _CONSTEXPR20_CONTAINER void _Alloc_proxy(_Alloc&& _Al) {
         _Container_proxy* const _New_proxy = _Unfancy(_Al.allocate(1));
         _Construct_in_place(*_New_proxy, this);
         _Myproxy            = _New_proxy;
@@ -1071,7 +1072,7 @@ public:
     }
 
     template <class _Alloc>
-    void _Reload_proxy(_Alloc&& _Old_alloc, _Alloc&& _New_alloc) {
+    _CONSTEXPR20_CONTAINER void _Reload_proxy(_Alloc&& _Old_alloc, _Alloc&& _New_alloc) {
         // pre: no iterators refer to the existing proxy
         _Container_proxy* const _New_proxy = _Unfancy(_New_alloc.allocate(1));
         _Construct_in_place(*_New_proxy, this);
@@ -1079,113 +1080,160 @@ public:
         _Delete_plain_internal(_Old_alloc, _STD exchange(_Myproxy, _New_proxy));
     }
 
-    _Container_proxy* _Myproxy;
+    _Container_proxy* _Myproxy = nullptr;
+
+private:
+    _CONSTEXPR20_CONTAINER void _Orphan_all_unlocked() noexcept;
+    _CONSTEXPR20_CONTAINER void _Swap_proxy_and_iterators_unlocked(_Container_base12&) noexcept;
+
+    void _Orphan_all_locked() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_all_unlocked();
+    }
+
+    void _Swap_proxy_and_iterators_locked(_Container_base12& _Right) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    }
 };
 
 struct _Iterator_base12 { // store links to container proxy, next iterator
-    _Iterator_base12() noexcept : _Myproxy(nullptr), _Mynextiter(nullptr) {} // construct orphaned iterator
+public:
+    _CONSTEXPR20_CONTAINER _Iterator_base12() noexcept = default; // construct orphaned iterator
 
-    _Iterator_base12(const _Iterator_base12& _Right) noexcept : _Myproxy(nullptr), _Mynextiter(nullptr) {
+    _CONSTEXPR20_CONTAINER _Iterator_base12(const _Iterator_base12& _Right) noexcept {
         *this = _Right;
     }
 
-    _Iterator_base12& operator=(const _Iterator_base12& _Right) noexcept {
+    _CONSTEXPR20_CONTAINER _Iterator_base12& operator=(const _Iterator_base12& _Right) noexcept {
         if (_Myproxy != _Right._Myproxy) {
             if (_Right._Myproxy) {
                 _Adopt(_Right._Myproxy->_Mycont);
             } else { // becoming invalid, disown current parent
 #if _ITERATOR_DEBUG_LEVEL == 2
-                _Lockit _Lock(_LOCK_DEBUG);
-                _Orphan_me();
+                _Orphan_me_v2();
 #else // _ITERATOR_DEBUG_LEVEL == 2
                 _Myproxy = nullptr;
 #endif // _ITERATOR_DEBUG_LEVEL == 2
             }
         }
-
         return *this;
     }
 
-    ~_Iterator_base12() noexcept {
 #if _ITERATOR_DEBUG_LEVEL == 2
-        _Lockit _Lock(_LOCK_DEBUG);
-        _Orphan_me();
-#endif // _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20_CONTAINER ~_Iterator_base12() noexcept {
+        _Orphan_me_v2();
     }
 
-    void _Adopt(const _Container_base12* _Parent) noexcept {
-        if (_Parent) {
-            // have a parent, do adoption
+    _CONSTEXPR20_CONTAINER void _Adopt(const _Container_base12* _Parent) noexcept {
+        if (_Parent) { // have a parent, do adoption
             _Container_proxy* _Parent_proxy = _Parent->_Myproxy;
-
-#if _ITERATOR_DEBUG_LEVEL == 2
             if (_Myproxy != _Parent_proxy) { // change parentage
-                _Lockit _Lock(_LOCK_DEBUG);
-                _Orphan_me();
-                _Mynextiter                 = _Parent_proxy->_Myfirstiter;
-                _Parent_proxy->_Myfirstiter = this;
-                _Myproxy                    = _Parent_proxy;
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+                if (_STD is_constant_evaluated()) {
+                    _Adopt_unlocked(_Parent_proxy);
+                } else
+#endif // __cpp_lib_constexpr_dynamic_alloc
+                {
+                    _Adopt_locked(_Parent_proxy);
+                }
             }
-
-#else // _ITERATOR_DEBUG_LEVEL == 2
-            _Myproxy = _Parent_proxy;
-#endif // _ITERATOR_DEBUG_LEVEL == 2
-        } else {
-            // no future parent, just disown current parent
-#if _ITERATOR_DEBUG_LEVEL == 2
-            _Lockit _Lock(_LOCK_DEBUG);
-            _Orphan_me();
-#else // _ITERATOR_DEBUG_LEVEL == 2
-            _Myproxy = nullptr;
-#endif // _ITERATOR_DEBUG_LEVEL == 2
+        } else { // no future parent, just disown current parent
+            _Orphan_me_v2();
         }
     }
 
-    const _Container_base12* _Getcont() const noexcept {
-        return _Myproxy ? _Myproxy->_Mycont : nullptr;
-    }
-
-#if _ITERATOR_DEBUG_LEVEL == 2
-    void _Orphan_me() noexcept {
+    _CONSTEXPR20_CONTAINER void _Orphan_me_v2() noexcept {
         if (_Myproxy) { // adopted, remove self from list
-            _Iterator_base12** _Pnext = &_Myproxy->_Myfirstiter;
-            while (*_Pnext && *_Pnext != this) {
-                _Pnext = &(*_Pnext)->_Mynextiter;
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+            if (_STD is_constant_evaluated()) {
+                _Orphan_me_unlocked();
+            } else
+#endif // __cpp_lib_constexpr_dynamic_alloc
+            {
+                _Orphan_me_locked();
             }
+        }
+    }
 
-            _STL_VERIFY(*_Pnext, "ITERATOR LIST CORRUPTED!");
-            *_Pnext  = _Mynextiter;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 ^^^ / vvv _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _CONSTEXPR20_CONTAINER void _Adopt(const _Container_base12* _Parent) noexcept {
+        if (_Parent) { // have a parent, do adoption
+            _Myproxy = _Parent->_Myproxy;
+        } else { // no future parent, just disown current parent
             _Myproxy = nullptr;
         }
     }
-#endif // _ITERATOR_DEBUG_LEVEL == 2
+#endif // _ITERATOR_DEBUG_LEVEL != 2
+
+    _CONSTEXPR20_CONTAINER const _Container_base12* _Getcont() const noexcept {
+        return _Myproxy ? _Myproxy->_Mycont : nullptr;
+    }
 
     static constexpr bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0;
 
-    _Container_proxy* _Myproxy;
-    _Iterator_base12* _Mynextiter;
-};
+    _Container_proxy* _Myproxy    = nullptr;
+    _Iterator_base12* _Mynextiter = nullptr;
 
-// MEMBER FUNCTIONS FOR _Container_base12
-inline void _Container_base12::_Orphan_all() noexcept {
 #if _ITERATOR_DEBUG_LEVEL == 2
-    if (_Myproxy) { // proxy allocated, drain it
+private:
+    _CONSTEXPR20_CONTAINER void _Adopt_unlocked(_Container_proxy* _Parent_proxy) noexcept {
+        if (_Myproxy) { // adopted, remove self from list
+            _Orphan_me_unlocked();
+        }
+        _Mynextiter                 = _Parent_proxy->_Myfirstiter;
+        _Parent_proxy->_Myfirstiter = this;
+        _Myproxy                    = _Parent_proxy;
+    }
+
+    void _Adopt_locked(_Container_proxy* _Parent_proxy) noexcept {
         _Lockit _Lock(_LOCK_DEBUG);
+        _Adopt_unlocked(_Parent_proxy);
+    }
 
-        for (auto _Pnext = &_Myproxy->_Myfirstiter; *_Pnext; *_Pnext = (*_Pnext)->_Mynextiter) {
-            (*_Pnext)->_Myproxy = nullptr;
+    _CONSTEXPR20_CONTAINER void _Orphan_me_unlocked() noexcept {
+        _Iterator_base12** _Pnext = &_Myproxy->_Myfirstiter;
+        while (*_Pnext && *_Pnext != this) {
+            const auto _Temp = *_Pnext; // TRANSITION, VSO-1269037
+            _Pnext           = &_Temp->_Mynextiter;
         }
 
-        _Myproxy->_Myfirstiter = nullptr;
+        _STL_VERIFY(*_Pnext, "ITERATOR LIST CORRUPTED!");
+        *_Pnext  = _Mynextiter;
+        _Myproxy = nullptr;
+    }
+
+    void _Orphan_me_locked() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_me_unlocked();
     }
 #endif // _ITERATOR_DEBUG_LEVEL == 2
+};
+
+// MEMBER FUNCTIONS FOR _Container_base12
+_CONSTEXPR20_CONTAINER void _Container_base12::_Orphan_all_unlocked() noexcept {
+    for (auto _Pnext = &_Myproxy->_Myfirstiter; *_Pnext; *_Pnext = (*_Pnext)->_Mynextiter) {
+        (*_Pnext)->_Myproxy = nullptr;
+    }
+    _Myproxy->_Myfirstiter = nullptr;
 }
 
-inline void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Right) noexcept {
+_CONSTEXPR20_CONTAINER void _Container_base12::_Orphan_all() noexcept {
 #if _ITERATOR_DEBUG_LEVEL == 2
-    _Lockit _Lock(_LOCK_DEBUG);
+    if (_Myproxy) { // proxy allocated, drain it
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (_STD is_constant_evaluated()) {
+            _Orphan_all_unlocked();
+        } else
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            _Orphan_all_locked();
+        }
+    }
 #endif // _ITERATOR_DEBUG_LEVEL == 2
+}
 
+_CONSTEXPR20_CONTAINER void _Container_base12::_Swap_proxy_and_iterators_unlocked(_Container_base12& _Right) noexcept {
     _Container_proxy* _Temp = _Myproxy;
     _Myproxy                = _Right._Myproxy;
     _Right._Myproxy         = _Temp;
@@ -1199,6 +1247,21 @@ inline void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Rig
     }
 }
 
+_CONSTEXPR20_CONTAINER void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Right) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+    if (_STD is_constant_evaluated()) {
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    } else
+#endif // __cpp_lib_constexpr_dynamic_alloc
+    {
+        _Swap_proxy_and_iterators_locked(_Right);
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 ^^^ / vvv _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _Swap_proxy_and_iterators_unlocked(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 2
+}
+
 #if _ITERATOR_DEBUG_LEVEL == 0
 using _Container_base = _Container_base0;
 using _Iterator_base  = _Iterator_base0;
@@ -1215,23 +1278,23 @@ struct _Leave_proxy_unbound {
 struct _Fake_proxy_ptr_impl { // fake replacement for a container proxy smart pointer when no container proxy is in use
     _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&) = delete;
     _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
-    _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
-    _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
+    _CONSTEXPR20_CONTAINER _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
+    _CONSTEXPR20_CONTAINER _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
 
-    void _Bind(const _Fake_allocator&, _Container_base0*) noexcept {}
-    void _Release() noexcept {}
+    _CONSTEXPR20_CONTAINER void _Bind(const _Fake_allocator&, _Container_base0*) noexcept {}
+    _CONSTEXPR20_CONTAINER void _Release() noexcept {}
 };
 
 struct _Basic_container_proxy_ptr12 {
     // smart pointer components for a _Container_proxy * that don't depend on the allocator
-    _Container_proxy* _Ptr;
+    _Container_proxy* _Ptr = nullptr;
 
-    void _Release() noexcept { // disengage this _Basic_container_proxy_ptr12
+    constexpr void _Release() noexcept { // disengage this _Basic_container_proxy_ptr12
         _Ptr = nullptr;
     }
 
 protected:
-    _Basic_container_proxy_ptr12()                                    = default;
+    _CONSTEXPR20_CONTAINER _Basic_container_proxy_ptr12()             = default;
     _Basic_container_proxy_ptr12(const _Basic_container_proxy_ptr12&) = delete;
     _Basic_container_proxy_ptr12(_Basic_container_proxy_ptr12&&)      = delete;
 };
@@ -1241,26 +1304,27 @@ struct _Container_proxy_ptr12 : _Basic_container_proxy_ptr12 {
     // smart pointer components for a _Container_proxy * for an allocator family
     _Alloc& _Al;
 
-    _Container_proxy_ptr12(_Alloc& _Al_, _Leave_proxy_unbound) : _Al(_Al_) { // create a new unbound _Container_proxy
+    _CONSTEXPR20_CONTAINER _Container_proxy_ptr12(_Alloc& _Al_, _Leave_proxy_unbound) : _Al(_Al_) {
+        // create a new unbound _Container_proxy
         _Ptr = _Unfancy(_Al_.allocate(1));
         _Construct_in_place(*_Ptr);
     }
 
-    _Container_proxy_ptr12(_Alloc& _Al_, _Container_base12& _Mycont)
-        : _Al(_Al_) { // create a new _Container_proxy pointing at _Mycont
+    _CONSTEXPR20_CONTAINER _Container_proxy_ptr12(_Alloc& _Al_, _Container_base12& _Mycont) : _Al(_Al_) {
+        // create a new _Container_proxy pointing at _Mycont
         _Ptr = _Unfancy(_Al_.allocate(1));
         _Construct_in_place(*_Ptr, _STD addressof(_Mycont));
         _Mycont._Myproxy = _Ptr;
     }
 
-    void _Bind(_Alloc& _Old_alloc, _Container_base12* _Mycont) noexcept {
+    _CONSTEXPR20_CONTAINER void _Bind(_Alloc& _Old_alloc, _Container_base12* _Mycont) noexcept {
         // Attach the proxy stored in *this to _Mycont, and destroy _Mycont's existing proxy
         // with _Old_alloc. Requires that no iterators are alive referring to _Mycont.
         _Ptr->_Mycont = _Mycont;
         _Delete_plain_internal(_Old_alloc, _STD exchange(_Mycont->_Myproxy, _STD exchange(_Ptr, nullptr)));
     }
 
-    ~_Container_proxy_ptr12() {
+    _CONSTEXPR20_CONTAINER ~_Container_proxy_ptr12() {
         if (_Ptr) {
             _Delete_plain_internal(_Al, _Ptr);
         }
@@ -1393,18 +1457,18 @@ struct _NODISCARD _Uninitialized_backout {
     _Uninitialized_backout(const _Uninitialized_backout&) = delete;
     _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;
 
-    ~_Uninitialized_backout() {
+    _CONSTEXPR20_DYNALLOC ~_Uninitialized_backout() {
         _Destroy_range(_First, _Last);
     }
 
     template <class... _Types>
-    void _Emplace_back(_Types&&... _Vals) {
+    _CONSTEXPR20_DYNALLOC void _Emplace_back(_Types&&... _Vals) {
         // construct a new element at *_Last and increment
         _Construct_in_place(*_Last, _STD forward<_Types>(_Vals)...);
         ++_Last;
     }
 
-    _NoThrowFwdIt _Release() { // suppress any exception handling backout and return _Last
+    constexpr _NoThrowFwdIt _Release() { // suppress any exception handling backout and return _Last
         _First = _Last;
         return _Last;
     }
@@ -1437,18 +1501,23 @@ namespace ranges {
 
 // FUNCTION TEMPLATE _Uninitialized_move_unchecked
 template <class _InIt, class _NoThrowFwdIt>
-_NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+_CONSTEXPR20_DYNALLOC _NoThrowFwdIt _Uninitialized_move_unchecked(
+    _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // move [_First, _Last) to raw [_Dest, ...)
     if constexpr (_Ptr_move_cat<_InIt, _NoThrowFwdIt>::_Really_trivial) {
-        return _Copy_memmove(_First, _Last, _Dest);
-    } else {
-        _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
-        for (; _First != _Last; ++_First) {
-            _Backout._Emplace_back(_STD move(*_First));
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            return _Copy_memmove(_First, _Last, _Dest);
         }
-
-        return _Backout._Release();
     }
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back(_STD move(*_First));
+    }
+
+    return _Backout._Release();
 }
 
 #ifdef __cpp_lib_concepts
@@ -1516,22 +1585,23 @@ class _NODISCARD _Uninitialized_backout_al {
     using pointer = _Alloc_ptr_t<_Alloc>;
 
 public:
-    _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
+    _CONSTEXPR20_DYNALLOC _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_)
+        : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
 
     _Uninitialized_backout_al(const _Uninitialized_backout_al&) = delete;
     _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;
 
-    ~_Uninitialized_backout_al() {
+    _CONSTEXPR20_DYNALLOC ~_Uninitialized_backout_al() {
         _Destroy_range(_First, _Last, _Al);
     }
 
     template <class... _Types>
-    void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
+    _CONSTEXPR20_DYNALLOC void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
         allocator_traits<_Alloc>::construct(_Al, _Unfancy(_Last), _STD forward<_Types>(_Vals)...);
         ++_Last;
     }
 
-    pointer _Release() { // suppress any exception handling backout and return _Last
+    constexpr pointer _Release() { // suppress any exception handling backout and return _Last
         _First = _Last;
         return _Last;
     }
@@ -1544,7 +1614,7 @@ private:
 
 // FUNCTION TEMPLATE _Uninitialized_copy WITH ALLOCATOR
 template <class _InIt, class _Alloc>
-_Alloc_ptr_t<_Alloc> _Uninitialized_copy(
+_CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
     const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
     // copy [_First, _Last) to raw _Dest, using _Al
     // note: only called internally from elsewhere in the STL
@@ -1555,21 +1625,46 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
 
     if constexpr (conjunction_v<bool_constant<_Ptr_copy_cat<decltype(_UFirst), _Ptrval>::_Really_trivial>,
                       _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>) {
-        _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
-        _Dest += _ULast - _UFirst;
-    } else {
-        _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
-        for (; _UFirst != _ULast; ++_UFirst) {
-            _Backout._Emplace_back(*_UFirst);
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
+            _Dest += _ULast - _UFirst;
+            return _Dest;
         }
+    }
 
-        _Dest = _Backout._Release();
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(*_UFirst);
     }
 
-    return _Dest;
+    return _Backout._Release();
 }
 
 // FUNCTION TEMPLATE uninitialized_copy
+template <class _InIt, class _NoThrowFwdIt>
+_CONSTEXPR20_DYNALLOC _NoThrowFwdIt _Uninitialized_copy_unchecked(
+    _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    if constexpr (_Ptr_copy_cat<_InIt, _NoThrowFwdIt>::_Really_trivial) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            return _Copy_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back(*_First);
+    }
+
+    return _Backout._Release();
+}
+
 template <class _InIt, class _NoThrowFwdIt>
 _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // copy [_First, _Last) to raw [_Dest, ...)
@@ -1577,24 +1672,13 @@ _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrow
     auto _UFirst      = _Get_unwrapped(_First);
     const auto _ULast = _Get_unwrapped(_Last);
     auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
-    if constexpr (_Ptr_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Really_trivial) {
-        _UDest = _Copy_memmove(_UFirst, _ULast, _UDest);
-    } else {
-        _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
-        for (; _UFirst != _ULast; ++_UFirst) {
-            _Backout._Emplace_back(*_UFirst);
-        }
-
-        _UDest = _Backout._Release();
-    }
-
-    _Seek_wrapped(_Dest, _UDest);
+    _Seek_wrapped(_Dest, _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest));
     return _Dest;
 }
 
 // FUNCTION TEMPLATE _Uninitialized_move WITH ALLOCATOR
 template <class _InIt, class _Alloc>
-_Alloc_ptr_t<_Alloc> _Uninitialized_move(
+_CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_move(
     const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
     // move [_First, _Last) to raw _Dest, using _Al
     // note: only called internally from elsewhere in the STL
@@ -1603,41 +1687,55 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_move(
     const auto _ULast = _Get_unwrapped(_Last);
     if constexpr (conjunction_v<bool_constant<_Ptr_move_cat<decltype(_UFirst), _Ptrval>::_Really_trivial>,
                       _Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {
-        _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
-        return _Dest + (_ULast - _UFirst);
-    } else {
-        _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
-        for (; _UFirst != _ULast; ++_UFirst) {
-            _Backout._Emplace_back(_STD move(*_UFirst));
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
+            return _Dest + (_ULast - _UFirst);
         }
+    }
 
-        return _Backout._Release();
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(_STD move(*_UFirst));
     }
+
+    return _Backout._Release();
 }
 
 // FUNCTION TEMPLATE _Uninitialized_fill_n WITH ALLOCATOR
 template <class _Alloc>
-_Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
+_CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
     _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, const typename _Alloc::value_type& _Val, _Alloc& _Al) {
     // copy _Count copies of _Val to raw _First, using _Al
     using _Ty = typename _Alloc::value_type;
     if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
-        _Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
-        return _First + _Count;
-    } else {
-        if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            _Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
+            return _First + _Count;
+        }
+    } else if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
             if (_Is_all_bits_zero(_Val)) {
                 _Fill_zero_memset(_Unfancy(_First), static_cast<size_t>(_Count));
                 return _First + _Count;
             }
         }
-        _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
-        for (; 0 < _Count; --_Count) {
-            _Backout._Emplace_back(_Val);
-        }
+    }
 
-        return _Backout._Release();
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back(_Val);
     }
+
+    return _Backout._Release();
 }
 
 // FUNCTION TEMPLATE uninitialized_fill
@@ -1656,6 +1754,7 @@ void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, c
                 return;
             }
         }
+
         _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
         while (_Backout._Last != _ULast) {
             _Backout._Emplace_back(_Val);
@@ -1680,22 +1779,27 @@ _Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { // fill [_First, _Last)
 }
 
 template <class _Alloc>
-_Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
+_CONSTEXPR20_DYNALLOC _Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
     _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, _Alloc& _Al) {
     // value-initialize _Count objects to raw _First, using _Al
     using _Ptrty = typename _Alloc::value_type*;
     if constexpr (_Use_memset_value_construct_v<_Ptrty> && _Uses_default_construct<_Alloc, _Ptrty>::value) {
-        auto _PFirst = _Unfancy(_First);
-        _Zero_range(_PFirst, _PFirst + _Count);
-        return _First + _Count;
-    } else {
-        _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
-        for (; 0 < _Count; --_Count) {
-            _Backout._Emplace_back();
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+        if (!_STD is_constant_evaluated())
+#endif // __cpp_lib_constexpr_dynamic_alloc
+        {
+            auto _PFirst = _Unfancy(_First);
+            _Zero_range(_PFirst, _PFirst + _Count);
+            return _First + _Count;
         }
+    }
 
-        return _Backout._Release();
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back();
     }
+
+    return _Backout._Release();
 }
 
 template <class _NoThrowFwdIt, class _Diff>
@@ -1861,7 +1965,8 @@ _NODISCARD _CONSTEXPR20 _FwdIt remove_if(_FwdIt _First, const _FwdIt _Last, _Pr
 
 // FUNCTION TEMPLATE _Erase_remove
 template <class _Container, class _Uty>
-typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val) { // erase each element matching _Val
+_CONSTEXPR20_DYNALLOC typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val) {
+    // erase each element matching _Val
     auto _First          = _Cont.begin();
     const auto _Last     = _Cont.end();
     const auto _Old_size = _Cont.size();
@@ -1872,7 +1977,8 @@ typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val
 
 // FUNCTION TEMPLATE _Erase_remove_if
 template <class _Container, class _Pr>
-typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) { // erase each element satisfying _Pred
+_CONSTEXPR20_DYNALLOC typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
     auto _First          = _Cont.begin();
     const auto _Last     = _Cont.end();
     const auto _Old_size = _Cont.size();
@@ -1883,7 +1989,8 @@ typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) {
 
 // FUNCTION TEMPLATE _Erase_nodes_if
 template <class _Container, class _Pr>
-typename _Container::size_type _Erase_nodes_if(_Container& _Cont, _Pr _Pred) { // erase each element satisfying _Pred
+typename _Container::size_type _Erase_nodes_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
     auto _First          = _Cont.begin();
     const auto _Last     = _Cont.end();
     const auto _Old_size = _Cont.size();
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 9f1c687ad01..eb2a04cadf3 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -131,18 +131,26 @@ _NODISCARD constexpr void* _Voidify_iter(_Iter _It) noexcept {
 
 // FUNCTION TEMPLATE construct_at
 #if _HAS_CXX20
-template <class _Ty, class... _Types>
-_CONSTEXPR20_DYNALLOC auto construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
-    noexcept(::new (_Voidify_iter(_Location)) _Ty(_STD forward<_Types>(_Args)...))) // strengthened
-    -> decltype(::new (_Voidify_iter(_Location)) _Ty(_STD forward<_Types>(_Args)...)) {
+template <class _Ty, class... _Types,
+    class = void_t<decltype(::new (_STD declval<void*>()) _Ty(_STD declval<_Types>()...))>>
+_CONSTEXPR20_DYNALLOC _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
+    noexcept(::new (_Voidify_iter(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
     return ::new (_Voidify_iter(_Location)) _Ty(_STD forward<_Types>(_Args)...);
 }
 #endif // _HAS_CXX20
 
 // FUNCTION TEMPLATE _Construct_in_place
 template <class _Ty, class... _Types>
-void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
-    ::new (_Voidify_iter(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...);
+_CONSTEXPR20_DYNALLOC void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(
+    is_nothrow_constructible_v<_Ty, _Types...>) {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+    if (_STD is_constant_evaluated()) {
+        _STD construct_at(_STD addressof(_Obj), _STD forward<_Types>(_Args)...);
+    } else
+#endif // __cpp_lib_constexpr_dynamic_alloc
+    {
+        ::new (_Voidify_iter(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...);
+    }
 }
 
 // FUNCTION TEMPLATE _Default_construct_in_place
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index ce9b36d67aa..d5d0f8f2e84 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1190,10 +1190,9 @@
 #define __cpp_lib_constexpr_algorithms 201806L
 #define __cpp_lib_constexpr_complex    201711L
 
-#if defined(__cpp_constexpr_dynamic_alloc) \
-    && defined(__clang__) // TRANSITION, MSVC support for constexpr dynamic allocation
+#ifdef __cpp_constexpr_dynamic_alloc
 #define __cpp_lib_constexpr_dynamic_alloc 201907L
-#endif // defined(__cpp_constexpr_dynamic_alloc) && defined(__clang__)
+#endif // __cpp_constexpr_dynamic_alloc
 
 #define __cpp_lib_constexpr_functional  201907L
 #define __cpp_lib_constexpr_iterator    201811L
@@ -1284,6 +1283,13 @@
 #define _CONSTEXPR20_DYNALLOC inline
 #endif
 
+// Functions that became constexpr in C++20 via P0980R1 or P1004R2
+#if defined(__cpp_lib_constexpr_dynamic_alloc) && !defined(__clang__) // TRANSITION:LLVM-48606
+#define _CONSTEXPR20_CONTAINER constexpr
+#else
+#define _CONSTEXPR20_CONTAINER inline
+#endif
+
 #ifdef _RTC_CONVERSION_CHECKS_ENABLED
 #ifndef _ALLOW_RTCc_IN_STL
 #error /RTCc rejects conformant code, so it is not supported by the C++ Standard Library. Either remove this \
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index ed1d3397670..e406827dbd4 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -310,18 +310,9 @@ std/language.support/support.limits/support.limits.general/format.version.pass.c
 std/utilities/format/format.error/format.error.pass.cpp FAIL
 
 # C++20 P0784R7 "More constexpr containers"
-std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp:0 FAIL
-std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp:0 FAIL
 std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp FAIL
-std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp:0 FAIL
 std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp FAIL
-std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp:0 FAIL
-std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp:0 FAIL
-std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp:0 FAIL
 std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.pass.cpp FAIL
-std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp:0 FAIL
-std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp:0 FAIL
-std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp:0 FAIL
 
 # C++20 P0896R4 "<ranges>"
 std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp FAIL
diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt
index d50700aaccf..9482df7db03 100644
--- a/tests/libcxx/skipped_tests.txt
+++ b/tests/libcxx/skipped_tests.txt
@@ -310,18 +310,9 @@ language.support\support.limits\support.limits.general\format.version.pass.cpp
 utilities\format\format.error\format.error.pass.cpp
 
 # C++20 P0784R7 "More constexpr containers"
-utilities\memory\allocator.traits\allocator.traits.members\allocate.pass.cpp
-utilities\memory\allocator.traits\allocator.traits.members\allocate_hint.pass.cpp
 utilities\memory\allocator.traits\allocator.traits.members\construct.pass.cpp
-utilities\memory\allocator.traits\allocator.traits.members\deallocate.pass.cpp
 utilities\memory\allocator.traits\allocator.traits.members\destroy.pass.cpp
-utilities\memory\allocator.traits\allocator.traits.members\max_size.pass.cpp
-utilities\memory\allocator.traits\allocator.traits.members\select_on_container_copy_construction.pass.cpp
-utilities\memory\default.allocator\allocator.globals\eq.pass.cpp
 utilities\memory\specialized.algorithms\specialized.construct\construct_at.pass.cpp
-utilities\memory\specialized.algorithms\specialized.destroy\destroy.pass.cpp
-utilities\memory\specialized.algorithms\specialized.destroy\destroy_at.pass.cpp
-utilities\memory\specialized.algorithms\specialized.destroy\destroy_n.pass.cpp
 
 # C++20 P0896R4 "<ranges>"
 language.support\support.limits\support.limits.general\algorithm.version.pass.cpp
diff --git a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
index 52da34b9f96..7939af14b21 100644
--- a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
+++ b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
@@ -227,6 +227,7 @@ void test_array(const T& val) {
 }
 
 #ifdef __cpp_lib_constexpr_dynamic_alloc
+#ifndef __EDG__ // TRANSITION, VSO-1269976
 template <class T>
 struct storage_for {
     union {
@@ -244,9 +245,11 @@ constexpr void test_compiletime() {
         assert(s.object == 42);
         destroy_at(&s.object);
 
+#ifdef __cpp_lib_concepts
         ranges::construct_at(&s.object, 1729);
         assert(s.object == 1729);
         ranges::destroy_at(&s.object);
+#endif // __cpp_lib_concepts
     }
 
     struct nontrivial {
@@ -262,12 +265,15 @@ constexpr void test_compiletime() {
         assert(s.object.x == 42);
         destroy_at(&s.object);
 
+#ifdef __cpp_lib_concepts
         ranges::construct_at(&s.object, 1729);
         assert(s.object.x == 1729);
         ranges::destroy_at(&s.object);
+#endif // __cpp_lib_concepts
     }
 }
 static_assert((test_compiletime(), true));
+#endif // __EDG__
 
 template <class T>
 struct A {
@@ -286,6 +292,7 @@ struct nontrivial_A {
 };
 
 constexpr void test_compiletime_destroy_variants() {
+#ifndef __EDG__ // TRANSITION, VSO-1270011
     {
         allocator<A<int>> alloc{};
         A<int>* a = alloc.allocate(10);
@@ -304,6 +311,7 @@ constexpr void test_compiletime_destroy_variants() {
         destroy(a, a + 10);
         alloc.deallocate(a, 10);
     }
+#endif // __EDG__
 #ifdef __cpp_lib_concepts
     {
         allocator<A<int>> alloc{};
@@ -385,6 +393,7 @@ constexpr void test_compiletime_destroy_variants() {
 }
 static_assert((test_compiletime_destroy_variants(), true));
 
+#ifndef __EDG__ // TRANSITION, VSO-1269976
 template <class T, bool Construct = false, bool Destroy = false>
 struct Alloc {
     using value_type = T;
@@ -498,6 +507,7 @@ constexpr void test_compiletime_allocator_traits() {
     }
 }
 static_assert((test_compiletime_allocator_traits(), true));
+#endif // __EDG__
 
 constexpr void test_compiletime_allocator() {
     {
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index db066537944..b0f604ebbca 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -411,8 +411,7 @@ STATIC_ASSERT(__cpp_lib_constexpr_complex == 201711L);
 #endif
 #endif
 
-#if _HAS_CXX20 && defined(__cpp_constexpr_dynamic_alloc) \
-    && defined(__clang__) // TRANSITION, MSVC support for constexpr dynamic allocation
+#if _HAS_CXX20 && defined(__cpp_constexpr_dynamic_alloc)
 #ifndef __cpp_lib_constexpr_dynamic_alloc
 #error __cpp_lib_constexpr_dynamic_alloc is not defined
 #elif __cpp_lib_constexpr_dynamic_alloc != 201907L