From b7df832483ec84d2f44286a4c785f9c4ba495f89 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:02:50 -0700
Subject: [PATCH 01/12] Win8 WaitOnAddress is statically available.

No ABI impact - all removed machinery was in an unnamed namespace, or within a function.
---
 stl/src/atomic_wait.cpp | 145 ----------------------------------------
 1 file changed, 145 deletions(-)

diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index b45ed197403..be0e6689612 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -89,120 +89,12 @@ namespace {
 #endif // defined(_DEBUG)
     }
 
-#ifndef _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE
-#if _STL_WIN32_WINNT >= _STL_WIN32_WINNT_WIN8
-#define _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE 1
-#else // ^^^ _STL_WIN32_WINNT >= _STL_WIN32_WINNT_WIN8 / _STL_WIN32_WINNT < _STL_WIN32_WINNT_WIN8 vvv
-#define _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE 0
-#endif // ^^^ _STL_WIN32_WINNT < _STL_WIN32_WINNT_WIN8 ^^^
-#endif // !defined(_ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE)
-
-#if _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE
-
 #pragma comment(lib, "synchronization")
 
 #define __crtWaitOnAddress       WaitOnAddress
 #define __crtWakeByAddressSingle WakeByAddressSingle
 #define __crtWakeByAddressAll    WakeByAddressAll
 
-#else // ^^^ _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE / !_ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE vvv
-
-    struct _Wait_functions_table {
-        _STD atomic<decltype(&::WaitOnAddress)> _Pfn_WaitOnAddress{nullptr};
-        _STD atomic<decltype(&::WakeByAddressSingle)> _Pfn_WakeByAddressSingle{nullptr};
-        _STD atomic<decltype(&::WakeByAddressAll)> _Pfn_WakeByAddressAll{nullptr};
-        _STD atomic<__std_atomic_api_level> _Api_level{__std_atomic_api_level::__not_set};
-    };
-
-    _Wait_functions_table _Wait_functions;
-
-    void _Force_wait_functions_srwlock_only() noexcept {
-        auto _Local = _Wait_functions._Api_level.load(_STD memory_order_acquire);
-        if (_Local <= __std_atomic_api_level::__detecting) {
-            while (!_Wait_functions._Api_level.compare_exchange_weak(
-                _Local, __std_atomic_api_level::__has_srwlock, _STD memory_order_acq_rel)) {
-                if (_Local > __std_atomic_api_level::__detecting) {
-                    return;
-                }
-            }
-        }
-    }
-
-    [[nodiscard]] __std_atomic_api_level _Init_wait_functions(__std_atomic_api_level _Level) {
-        while (!_Wait_functions._Api_level.compare_exchange_weak(
-            _Level, __std_atomic_api_level::__detecting, _STD memory_order_acq_rel)) {
-            if (_Level > __std_atomic_api_level::__detecting) {
-                return _Level;
-            }
-        }
-
-        _Level = __std_atomic_api_level::__has_srwlock;
-
-        const HMODULE _Sync_module = GetModuleHandleW(L"api-ms-win-core-synch-l1-2-0.dll");
-        if (_Sync_module != nullptr) {
-            const auto _Wait_on_address =
-                reinterpret_cast<decltype(&::WaitOnAddress)>(GetProcAddress(_Sync_module, "WaitOnAddress"));
-            const auto _Wake_by_address_single =
-                reinterpret_cast<decltype(&::WakeByAddressSingle)>(GetProcAddress(_Sync_module, "WakeByAddressSingle"));
-            const auto _Wake_by_address_all =
-                reinterpret_cast<decltype(&::WakeByAddressAll)>(GetProcAddress(_Sync_module, "WakeByAddressAll"));
-
-            if (_Wait_on_address != nullptr && _Wake_by_address_single != nullptr && _Wake_by_address_all != nullptr) {
-                _Wait_functions._Pfn_WaitOnAddress.store(_Wait_on_address, _STD memory_order_relaxed);
-                _Wait_functions._Pfn_WakeByAddressSingle.store(_Wake_by_address_single, _STD memory_order_relaxed);
-                _Wait_functions._Pfn_WakeByAddressAll.store(_Wake_by_address_all, _STD memory_order_relaxed);
-                _Level = __std_atomic_api_level::__has_wait_on_address;
-            }
-        }
-
-        // for __has_srwlock, relaxed would have been enough, not distinguishing for consistency
-        _Wait_functions._Api_level.store(_Level, _STD memory_order_release);
-        return _Level;
-    }
-
-    [[nodiscard]] __std_atomic_api_level _Acquire_wait_functions() noexcept {
-        auto _Level = _Wait_functions._Api_level.load(_STD memory_order_acquire);
-        if (_Level <= __std_atomic_api_level::__detecting) {
-            _Level = _Init_wait_functions(_Level);
-        }
-
-        return _Level;
-    }
-
-    [[nodiscard]] BOOL __crtWaitOnAddress(
-        volatile VOID* Address, PVOID CompareAddress, SIZE_T AddressSize, DWORD dwMilliseconds) {
-        const auto _Wait_on_address = _Wait_functions._Pfn_WaitOnAddress.load(_STD memory_order_relaxed);
-        return _Wait_on_address(Address, CompareAddress, AddressSize, dwMilliseconds);
-    }
-
-    VOID __crtWakeByAddressSingle(PVOID Address) {
-        const auto _Wake_by_address_single = _Wait_functions._Pfn_WakeByAddressSingle.load(_STD memory_order_relaxed);
-        _Wake_by_address_single(Address);
-    }
-
-    VOID __crtWakeByAddressAll(PVOID Address) {
-        const auto _Wake_by_address_all = _Wait_functions._Pfn_WakeByAddressAll.load(_STD memory_order_relaxed);
-        _Wake_by_address_all(Address);
-    }
-
-    bool __stdcall _Atomic_wait_are_equal_direct_fallback(
-        const void* _Storage, void* _Comparand, size_t _Size, void*) noexcept {
-        switch (_Size) {
-        case 1:
-            return __iso_volatile_load8(static_cast<const char*>(_Storage)) == *static_cast<const char*>(_Comparand);
-        case 2:
-            return __iso_volatile_load16(static_cast<const short*>(_Storage)) == *static_cast<const short*>(_Comparand);
-        case 4:
-            return __iso_volatile_load32(static_cast<const int*>(_Storage)) == *static_cast<const int*>(_Comparand);
-        case 8:
-            return __iso_volatile_load64(static_cast<const long long*>(_Storage))
-                == *static_cast<const long long*>(_Comparand);
-        default:
-            _CSTD abort();
-        }
-    }
-#endif // _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE
-
     [[nodiscard]] unsigned char __std_atomic_compare_exchange_128_fallback(
         _Inout_bytecount_(16) long long* _Destination, _In_ long long _ExchangeHigh, _In_ long long _ExchangeLow,
         _Inout_bytecount_(16) long long* _ComparandResult) noexcept {
@@ -225,13 +117,6 @@ namespace {
 extern "C" {
 int __stdcall __std_atomic_wait_direct(const void* const _Storage, void* const _Comparand, const size_t _Size,
     const unsigned long _Remaining_timeout) noexcept {
-#if _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE == 0
-    if (_Acquire_wait_functions() < __std_atomic_api_level::__has_wait_on_address) {
-        return __std_atomic_wait_indirect(
-            _Storage, _Comparand, _Size, nullptr, &_Atomic_wait_are_equal_direct_fallback, _Remaining_timeout);
-    }
-#endif // _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE == 0
-
     const auto _Result = __crtWaitOnAddress(
         const_cast<volatile void*>(_Storage), const_cast<void*>(_Comparand), _Size, _Remaining_timeout);
 
@@ -242,24 +127,10 @@ int __stdcall __std_atomic_wait_direct(const void* const _Storage, void* const _
 }
 
 void __stdcall __std_atomic_notify_one_direct(const void* const _Storage) noexcept {
-#if _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE == 0
-    if (_Acquire_wait_functions() < __std_atomic_api_level::__has_wait_on_address) {
-        __std_atomic_notify_one_indirect(_Storage);
-        return;
-    }
-#endif // _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE = 0
-
     __crtWakeByAddressSingle(const_cast<void*>(_Storage));
 }
 
 void __stdcall __std_atomic_notify_all_direct(const void* const _Storage) noexcept {
-#if _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE == 0
-    if (_Acquire_wait_functions() < __std_atomic_api_level::__has_wait_on_address) {
-        __std_atomic_notify_all_indirect(_Storage);
-        return;
-    }
-#endif // _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE == 0
-
     __crtWakeByAddressAll(const_cast<void*>(_Storage));
 }
 
@@ -357,24 +228,8 @@ unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long lo
 }
 
 __std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level _Requested_api_level) noexcept {
-#if _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE
     (void) _Requested_api_level;
     return __std_atomic_api_level::__has_wait_on_address;
-#else // ^^^ _ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE / !_ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE vvv
-    switch (_Requested_api_level) {
-    case __std_atomic_api_level::__not_set:
-    case __std_atomic_api_level::__detecting:
-        _CSTD abort();
-    case __std_atomic_api_level::__has_srwlock:
-        _Force_wait_functions_srwlock_only();
-        break;
-    case __std_atomic_api_level::__has_wait_on_address:
-    default: // future compat: new header using an old DLL will get the highest requested level supported
-        break;
-    }
-
-    return _Acquire_wait_functions();
-#endif // !_ATOMIC_WAIT_ON_ADDRESS_STATICALLY_AVAILABLE
 }
 
 #pragma warning(push)

From aaf0b70634eade8c25801ed577282d6c223f0f7b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:09:24 -0700
Subject: [PATCH 02/12] Demacroize `__crtWaitOnAddress` => `WaitOnAddress` etc.

---
 stl/src/atomic_wait.cpp | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index be0e6689612..1397639e73d 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -91,10 +91,6 @@ namespace {
 
 #pragma comment(lib, "synchronization")
 
-#define __crtWaitOnAddress       WaitOnAddress
-#define __crtWakeByAddressSingle WakeByAddressSingle
-#define __crtWakeByAddressAll    WakeByAddressAll
-
     [[nodiscard]] unsigned char __std_atomic_compare_exchange_128_fallback(
         _Inout_bytecount_(16) long long* _Destination, _In_ long long _ExchangeHigh, _In_ long long _ExchangeLow,
         _Inout_bytecount_(16) long long* _ComparandResult) noexcept {
@@ -117,8 +113,8 @@ namespace {
 extern "C" {
 int __stdcall __std_atomic_wait_direct(const void* const _Storage, void* const _Comparand, const size_t _Size,
     const unsigned long _Remaining_timeout) noexcept {
-    const auto _Result = __crtWaitOnAddress(
-        const_cast<volatile void*>(_Storage), const_cast<void*>(_Comparand), _Size, _Remaining_timeout);
+    const auto _Result =
+        WaitOnAddress(const_cast<volatile void*>(_Storage), const_cast<void*>(_Comparand), _Size, _Remaining_timeout);
 
     if (!_Result) {
         _Assume_timeout();
@@ -127,11 +123,11 @@ int __stdcall __std_atomic_wait_direct(const void* const _Storage, void* const _
 }
 
 void __stdcall __std_atomic_notify_one_direct(const void* const _Storage) noexcept {
-    __crtWakeByAddressSingle(const_cast<void*>(_Storage));
+    WakeByAddressSingle(const_cast<void*>(_Storage));
 }
 
 void __stdcall __std_atomic_notify_all_direct(const void* const _Storage) noexcept {
-    __crtWakeByAddressAll(const_cast<void*>(_Storage));
+    WakeByAddressAll(const_cast<void*>(_Storage));
 }
 
 void __stdcall __std_atomic_notify_one_indirect(const void* const _Storage) noexcept {

From a729f46cd42bcd5070ff2611cce6936dd4b60688 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:20:47 -0700
Subject: [PATCH 03/12] Preserve `__std_atomic_set_api_level` for bincompat,
 delete `P1135R6_atomic_wait_vista`.

Move `enum class __std_atomic_api_level` to `atomic_wait.cpp`, marked as preserved. It's still `extern "C"`.

Drop the declaration of `__std_atomic_set_api_level` and mark the definition as preserved. It's still dllexported by `stl/src/msvcp_atomic_wait.src`.

Drop the unused parameter name `_Requested_api_level`.

`P1135R6_atomic_wait` doesn't need to verify the API level anymore.

Delete `P1135R6_atomic_wait_vista`, which existed only to test the older API level.
---
 stl/inc/xatomic_wait.h                             | 13 -------------
 stl/src/atomic_wait.cpp                            | 12 ++++++++++--
 tests/std/test.lst                                 |  1 -
 tests/std/tests/P1135R6_atomic_wait/test.cpp       |  2 --
 tests/std/tests/P1135R6_atomic_wait_vista/env.lst  |  4 ----
 tests/std/tests/P1135R6_atomic_wait_vista/test.cpp | 11 -----------
 6 files changed, 10 insertions(+), 33 deletions(-)
 delete mode 100644 tests/std/tests/P1135R6_atomic_wait_vista/env.lst
 delete mode 100644 tests/std/tests/P1135R6_atomic_wait_vista/test.cpp

diff --git a/stl/inc/xatomic_wait.h b/stl/inc/xatomic_wait.h
index 178f91fa9e8..9c9fe1fd024 100644
--- a/stl/inc/xatomic_wait.h
+++ b/stl/inc/xatomic_wait.h
@@ -21,19 +21,6 @@ _STL_DISABLE_CLANG_WARNINGS
 extern "C" {
 inline constexpr unsigned long __std_atomic_wait_no_timeout = 0xFFFF'FFFF; // Pass as partial timeout
 
-enum class __std_atomic_api_level : unsigned long {
-    __not_set,
-    __detecting,
-    __has_srwlock,
-    __has_wait_on_address,
-};
-
-// This function allows testing the atomic wait support while always using the APIs for a platform with fewer
-// capabilities; it attempts to lock the APIs used to the level `_Requested_api_level`, and returns the actual API level
-// in use. Once the API level has been set by calling this function (or detected by a call to one of the atomic wait
-// functions), it can no longer be changed.
-__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level _Requested_api_level) noexcept;
-
 // Support for atomic waits.
 // The "direct" functions are used when the underlying infrastructure can use WaitOnAddress directly; that is, _Size is
 // 1, 2, 4, or 8. The contract is the same as the WaitOnAddress function from the Windows SDK. If WaitOnAddress is not
diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index 1397639e73d..5180390f366 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -223,8 +223,16 @@ unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long lo
     return static_cast<unsigned long>(_Remaining);
 }
 
-__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level _Requested_api_level) noexcept {
-    (void) _Requested_api_level;
+// TRANSITION, ABI: preserved for binary compatibility
+enum class __std_atomic_api_level : unsigned long {
+    __not_set,
+    __detecting,
+    __has_srwlock,
+    __has_wait_on_address,
+};
+
+// TRANSITION, ABI: preserved for binary compatibility
+__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level) noexcept {
     return __std_atomic_api_level::__has_wait_on_address;
 }
 
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 3b22ab147a9..9c6c25788b2 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -522,7 +522,6 @@ tests\P1032R1_miscellaneous_constexpr
 tests\P1132R7_out_ptr
 tests\P1135R6_atomic_flag_test
 tests\P1135R6_atomic_wait
-tests\P1135R6_atomic_wait_vista
 tests\P1135R6_barrier
 tests\P1135R6_latch
 tests\P1135R6_semaphore
diff --git a/tests/std/tests/P1135R6_atomic_wait/test.cpp b/tests/std/tests/P1135R6_atomic_wait/test.cpp
index 2c62d15e1b2..ae5f71b857d 100644
--- a/tests/std/tests/P1135R6_atomic_wait/test.cpp
+++ b/tests/std/tests/P1135R6_atomic_wait/test.cpp
@@ -57,7 +57,5 @@ void test_incomplete_associated_class_all() { // COMPILE-ONLY
 #endif // ^^^ no workaround ^^^
 
 int main() {
-    assert(__std_atomic_set_api_level(__std_atomic_api_level::__has_wait_on_address)
-           == __std_atomic_api_level::__has_wait_on_address);
     test_atomic_wait();
 }
diff --git a/tests/std/tests/P1135R6_atomic_wait_vista/env.lst b/tests/std/tests/P1135R6_atomic_wait_vista/env.lst
deleted file mode 100644
index 351a8293d9d..00000000000
--- a/tests/std/tests/P1135R6_atomic_wait_vista/env.lst
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-RUNALL_INCLUDE ..\usual_20_matrix.lst
diff --git a/tests/std/tests/P1135R6_atomic_wait_vista/test.cpp b/tests/std/tests/P1135R6_atomic_wait_vista/test.cpp
deleted file mode 100644
index dc1dd27e1b0..00000000000
--- a/tests/std/tests/P1135R6_atomic_wait_vista/test.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "test_atomic_wait.hpp"
-
-int main() {
-#if defined(_M_IX86) || defined(_M_X64) && !defined(_M_ARM64EC)
-    assert(__std_atomic_set_api_level(__std_atomic_api_level::__has_srwlock) == __std_atomic_api_level::__has_srwlock);
-    test_atomic_wait();
-#endif // defined(_M_IX86) || defined(_M_X64) && !defined(_M_ARM64EC)
-}

From 36c8462ba57061878627546e9f3bcc2ee09f0b58 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 12:17:37 -0700
Subject: [PATCH 04/12] Spend fewer lines on `__std_atomic_api_level` by
 dropping the trailing comma.

---
 stl/src/atomic_wait.cpp | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index 5180390f366..7b47aedf052 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -224,14 +224,7 @@ unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long lo
 }
 
 // TRANSITION, ABI: preserved for binary compatibility
-enum class __std_atomic_api_level : unsigned long {
-    __not_set,
-    __detecting,
-    __has_srwlock,
-    __has_wait_on_address,
-};
-
-// TRANSITION, ABI: preserved for binary compatibility
+enum class __std_atomic_api_level : unsigned long { __not_set, __detecting, __has_srwlock, __has_wait_on_address };
 __std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level) noexcept {
     return __std_atomic_api_level::__has_wait_on_address;
 }

From 58787b572f7b68b6a81acbce92fa80fae5b99d4f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:29:39 -0700
Subject: [PATCH 05/12] Fuse `test_atomic_wait.hpp` into `P1135R6_atomic_wait`.

No changes other than dropping the duplicate banner and `#pragma once`.
---
 tests/std/include/test_atomic_wait.hpp       | 366 -------------------
 tests/std/tests/P1135R6_atomic_wait/test.cpp | 362 +++++++++++++++++-
 2 files changed, 361 insertions(+), 367 deletions(-)
 delete mode 100644 tests/std/include/test_atomic_wait.hpp

diff --git a/tests/std/include/test_atomic_wait.hpp b/tests/std/include/test_atomic_wait.hpp
deleted file mode 100644
index 28f4be97fba..00000000000
--- a/tests/std/include/test_atomic_wait.hpp
+++ /dev/null
@@ -1,366 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#pragma once
-
-#include <atomic>
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <memory>
-#include <thread>
-
-template <template <class> class Template, class UnderlyingType>
-void test_atomic_wait_func_impl(UnderlyingType& old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    constexpr int seq_max_size = 10;
-    char seq[seq_max_size + 1];
-    std::atomic<char*> base = seq;
-    auto add_seq            = [&](char ch) {
-        char* p = base.fetch_add(1, std::memory_order_relaxed);
-        assert(p - seq < seq_max_size);
-        *p = ch;
-    };
-
-    Template<UnderlyingType> a(old_value);
-    a.wait(new_value);
-
-    add_seq('1');
-
-    std::thread thd([&] {
-        std::this_thread::sleep_for(waiting_duration);
-        add_seq('2');
-        a.notify_all();
-        std::this_thread::sleep_for(waiting_duration);
-        add_seq('3');
-        a.store(old_value);
-        a.notify_one();
-        std::this_thread::sleep_for(waiting_duration);
-        add_seq('4');
-        a.store(new_value);
-        a.notify_one();
-#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
-        // timing assumption that the main thread evaluates the `wait(old_value)` before this timeout expires
-        std::this_thread::sleep_for(waiting_duration);
-        add_seq('6');
-#endif
-    });
-
-    a.wait(old_value);
-    const auto loaded = a.load();
-    assert(memcmp(&loaded, &new_value, sizeof(UnderlyingType)) == 0);
-
-    add_seq('5');
-
-    thd.join();
-
-    add_seq('\0');
-
-#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
-    assert(strcmp(seq, "123456") == 0);
-#else
-    assert(strcmp(seq, "12345") == 0);
-#endif
-}
-
-template <class UnderlyingType>
-void test_atomic_wait_func(UnderlyingType old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    test_atomic_wait_func_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
-    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value_for_ref = old_value;
-    test_atomic_wait_func_impl<std::atomic_ref, UnderlyingType>(old_value_for_ref, new_value, waiting_duration);
-}
-
-template <class UnderlyingType>
-void test_atomic_wait_func_ptr(UnderlyingType old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    test_atomic_wait_func_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
-}
-
-
-template <template <class> class Template, class UnderlyingType>
-void test_notify_all_notifies_all_impl(UnderlyingType& old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    Template<UnderlyingType> c(old_value);
-    const auto waitFn = [&c, old_value] { c.wait(old_value); };
-
-    std::thread w1{waitFn};
-    std::thread w2{waitFn};
-    std::thread w3{waitFn};
-
-    std::this_thread::sleep_for(waiting_duration);
-    c.store(new_value);
-    c.notify_all(); // if this doesn't really notify all, the following joins will deadlock
-
-    w1.join();
-    w2.join();
-    w3.join();
-}
-
-template <class UnderlyingType>
-void test_notify_all_notifies_all(UnderlyingType old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    test_notify_all_notifies_all_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
-    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value_for_ref = old_value;
-    test_notify_all_notifies_all_impl<std::atomic_ref, UnderlyingType>(old_value_for_ref, new_value, waiting_duration);
-}
-
-template <class UnderlyingType>
-void test_notify_all_notifies_all_ptr(UnderlyingType old_value, const UnderlyingType new_value,
-    const std::chrono::steady_clock::duration waiting_duration) {
-    // increased waiting_duration because timing assumption might not hold for atomic smart pointers
-    test_notify_all_notifies_all_impl<std::atomic, UnderlyingType>(old_value, new_value, 3 * waiting_duration);
-}
-
-
-template <template <class> class Template, class UnderlyingType>
-void test_pad_bits_impl(const std::chrono::steady_clock::duration waiting_duration) {
-    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value;
-    memset(&old_value, 0x66, sizeof(UnderlyingType));
-    old_value.set(1);
-
-    UnderlyingType same_old_value;
-    memset(&same_old_value, 0x99, sizeof(UnderlyingType));
-    same_old_value.set(1);
-
-    Template<UnderlyingType> c(old_value);
-
-    bool trigger      = false;
-    const auto waitFn = [&c, same_old_value, &trigger] {
-        c.wait(same_old_value);
-        trigger = true;
-    };
-
-    std::thread w1{waitFn};
-
-    std::this_thread::sleep_for(waiting_duration);
-    assert(!trigger);
-
-    c.store(old_value);
-    c.notify_one();
-
-    std::this_thread::sleep_for(waiting_duration);
-    assert(!trigger);
-
-    UnderlyingType new_value;
-    memset(&new_value, 0x99, sizeof(UnderlyingType));
-    new_value.set(2);
-    c.store(new_value);
-    c.notify_one();
-
-#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
-    std::this_thread::sleep_for(waiting_duration);
-    assert(trigger);
-    w1.join();
-#else // ^^^ CAN_FAIL_ON_TIMING_ASSUMPTION / !CAN_FAIL_ON_TIMING_ASSUMPTION vvv
-    w1.join();
-    assert(trigger);
-#endif // ^^^ !CAN_FAIL_ON_TIMING_ASSUMPTION ^^^
-}
-
-template <class UnderlyingType>
-void test_pad_bits(const std::chrono::steady_clock::duration waiting_duration) {
-    test_pad_bits_impl<std::atomic, UnderlyingType>(waiting_duration);
-    test_pad_bits_impl<std::atomic_ref, UnderlyingType>(waiting_duration);
-}
-
-struct two_shorts {
-    short a;
-    short b;
-
-    friend bool operator==(two_shorts, two_shorts) = delete;
-};
-
-struct three_chars {
-    char a;
-    char b;
-    char c;
-
-    friend bool operator==(three_chars, three_chars) = delete;
-};
-
-struct big_char_like {
-    char value;
-    char unused[16];
-
-    explicit big_char_like(char value_) : value(value_), unused{} {}
-
-    friend bool operator==(big_char_like, big_char_like) = delete;
-};
-
-#pragma warning(push)
-#pragma warning(disable : 4324) // structure was padded due to alignment specifier
-template <size_t size>
-struct with_padding_bits {
-    alignas(size) char value;
-
-    void set(const char value_) {
-        value = value_;
-    }
-
-    friend bool operator==(with_padding_bits, with_padding_bits) = delete;
-};
-#pragma warning(pop)
-
-template <class T, class U>
-[[nodiscard]] bool ownership_equal(const T& t, const U& u) {
-    return !t.owner_before(u) && !u.owner_before(t);
-}
-
-inline void test_gh_3602() {
-    // GH-3602 std::atomic<std::shared_ptr>::wait does not seem to care about control block difference. Is this a bug?
-    {
-        auto sp1    = std::make_shared<char>();
-        auto holder = [sp1] {};
-        auto sp2    = std::make_shared<decltype(holder)>(holder);
-        std::shared_ptr<char> sp3{sp2, sp1.get()};
-
-        std::atomic<std::shared_ptr<char>> asp{sp1};
-        asp.wait(sp3);
-    }
-    {
-        auto sp1    = std::make_shared<char>();
-        auto holder = [sp1] {};
-        auto sp2    = std::make_shared<decltype(holder)>(holder);
-        std::shared_ptr<char> sp3{sp2, sp1.get()};
-        std::weak_ptr<char> wp3{sp3};
-
-        std::atomic<std::weak_ptr<char>> awp{sp1};
-        awp.wait(wp3);
-    }
-
-    {
-        auto sp1    = std::make_shared<char>();
-        auto holder = [sp1] {};
-        auto sp2    = std::make_shared<decltype(holder)>(holder);
-        std::shared_ptr<char> sp3{sp2, sp1.get()};
-
-        std::atomic<std::shared_ptr<char>> asp{sp3};
-
-        std::thread t([&] {
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            asp = sp1;
-            asp.notify_one();
-        });
-
-        asp.wait(sp3);
-
-        t.join();
-    }
-
-    { // Also test shared_ptrs that own the null pointer.
-        int* const raw = nullptr;
-
-        std::shared_ptr<int> sp_empty;
-        std::shared_ptr<int> sp_also_empty;
-        std::shared_ptr<int> sp_original(raw);
-        std::shared_ptr<int> sp_copy(sp_original);
-        std::shared_ptr<int> sp_different(raw);
-
-        assert(ownership_equal(sp_empty, sp_also_empty));
-        assert(!ownership_equal(sp_original, sp_empty));
-        assert(ownership_equal(sp_original, sp_copy));
-        assert(!ownership_equal(sp_original, sp_different));
-
-        std::atomic<std::shared_ptr<int>> asp_empty;
-        asp_empty.wait(sp_original);
-
-        std::atomic<std::shared_ptr<int>> asp_copy{sp_copy};
-        asp_copy.wait(sp_empty);
-        asp_copy.wait(sp_different);
-    }
-}
-
-inline void test_atomic_wait() {
-    // wait for all the threads to be waiting; if this value is too small the test might be ineffective but should not
-    // fail due to timing assumptions except where otherwise noted; if it is too large the test will only take longer
-    // than necessary
-    constexpr std::chrono::milliseconds waiting_duration{100};
-    test_atomic_wait_func<char>(1, 2, waiting_duration);
-    test_atomic_wait_func<signed char>(1, 2, waiting_duration);
-    test_atomic_wait_func<unsigned char>(1, 2, waiting_duration);
-    test_atomic_wait_func<short>(1, 2, waiting_duration);
-    test_atomic_wait_func<unsigned short>(1, 2, waiting_duration);
-    test_atomic_wait_func<int>(1, 2, waiting_duration);
-    test_atomic_wait_func<unsigned int>(1, 2, waiting_duration);
-    test_atomic_wait_func<long>(1, 2, waiting_duration);
-    test_atomic_wait_func<unsigned long>(1, 2, waiting_duration);
-    test_atomic_wait_func<long long>(1, 2, waiting_duration);
-    test_atomic_wait_func<unsigned long long>(1, 2, waiting_duration);
-    test_atomic_wait_func<float>(1, 2, waiting_duration);
-    test_atomic_wait_func<double>(1, 2, waiting_duration);
-    test_atomic_wait_func<long double>(1, 2, waiting_duration);
-    test_atomic_wait_func<const void*>("1", "2", waiting_duration);
-    test_atomic_wait_func(two_shorts{1, 1}, two_shorts{1, 2}, waiting_duration);
-    test_atomic_wait_func(three_chars{1, 1, 3}, three_chars{1, 2, 3}, waiting_duration);
-    test_atomic_wait_func(big_char_like{'a'}, big_char_like{'b'}, waiting_duration);
-
-    test_atomic_wait_func_ptr(std::make_shared<int>('a'), std::make_shared<int>('a'), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int>('a')}, std::weak_ptr{std::make_shared<int>('a')}, waiting_duration);
-    test_atomic_wait_func_ptr(std::make_shared<int[]>(0), std::make_shared<int[]>(0), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int[]>(0)}, std::weak_ptr{std::make_shared<int[]>(0)}, waiting_duration);
-    test_atomic_wait_func_ptr(std::make_shared<int[]>(1), std::make_shared<int[]>(1), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int[]>(1)}, std::weak_ptr{std::make_shared<int[]>(1)}, waiting_duration);
-    test_atomic_wait_func_ptr(std::make_shared<int[2]>(), std::make_shared<int[2]>(), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int[2]>()}, std::weak_ptr{std::make_shared<int[2]>()}, waiting_duration);
-    test_atomic_wait_func_ptr(std::make_shared<int[][2]>(2), std::make_shared<int[][2]>(2), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int[][2]>(2)}, std::weak_ptr{std::make_shared<int[][2]>(2)}, waiting_duration);
-    test_atomic_wait_func_ptr(std::make_shared<int[2][2]>(), std::make_shared<int[2][2]>(), waiting_duration);
-    test_atomic_wait_func_ptr(
-        std::weak_ptr{std::make_shared<int[2][2]>()}, std::weak_ptr{std::make_shared<int[2][2]>()}, waiting_duration);
-
-    test_notify_all_notifies_all<char>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<signed char>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<unsigned char>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<short>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<unsigned short>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<int>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<unsigned int>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<long>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<unsigned long>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<long long>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<unsigned long long>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<float>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<double>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<long double>(1, 2, waiting_duration);
-    test_notify_all_notifies_all<const void*>("1", "2", waiting_duration);
-    test_notify_all_notifies_all(two_shorts{1, 1}, two_shorts{1, 2}, waiting_duration);
-    test_notify_all_notifies_all(three_chars{1, 1, 3}, three_chars{1, 2, 3}, waiting_duration);
-    test_notify_all_notifies_all(big_char_like{'a'}, big_char_like{'b'}, waiting_duration);
-
-    test_notify_all_notifies_all_ptr(std::make_shared<int>('a'), std::make_shared<int>('a'), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int>('a')}, std::weak_ptr{std::make_shared<int>('a')}, waiting_duration);
-    test_notify_all_notifies_all_ptr(std::make_shared<int[]>(0), std::make_shared<int[]>(0), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int[]>(0)}, std::weak_ptr{std::make_shared<int[]>(0)}, waiting_duration);
-    test_notify_all_notifies_all_ptr(std::make_shared<int[]>(1), std::make_shared<int[]>(1), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int[]>(1)}, std::weak_ptr{std::make_shared<int[]>(1)}, waiting_duration);
-    test_notify_all_notifies_all_ptr(std::make_shared<int[2]>(), std::make_shared<int[2]>(), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int[2]>()}, std::weak_ptr{std::make_shared<int[2]>()}, waiting_duration);
-    test_notify_all_notifies_all_ptr(std::make_shared<int[][2]>(2), std::make_shared<int[][2]>(2), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int[][2]>(2)}, std::weak_ptr{std::make_shared<int[][2]>(2)}, waiting_duration);
-    test_notify_all_notifies_all_ptr(std::make_shared<int[2][2]>(), std::make_shared<int[2][2]>(), waiting_duration);
-    test_notify_all_notifies_all_ptr(
-        std::weak_ptr{std::make_shared<int[2][2]>()}, std::weak_ptr{std::make_shared<int[2][2]>()}, waiting_duration);
-
-#ifndef __clang__ // TRANSITION, LLVM-46685
-    test_pad_bits<with_padding_bits<2>>(waiting_duration);
-    test_pad_bits<with_padding_bits<4>>(waiting_duration);
-    test_pad_bits<with_padding_bits<8>>(waiting_duration);
-#ifndef _M_ARM
-    test_pad_bits<with_padding_bits<16>>(waiting_duration);
-    test_pad_bits<with_padding_bits<32>>(waiting_duration);
-#endif // ^^^ !ARM ^^^
-#endif // ^^^ no workaround ^^^
-
-    test_gh_3602();
-}
diff --git a/tests/std/tests/P1135R6_atomic_wait/test.cpp b/tests/std/tests/P1135R6_atomic_wait/test.cpp
index ae5f71b857d..e9be8da9528 100644
--- a/tests/std/tests/P1135R6_atomic_wait/test.cpp
+++ b/tests/std/tests/P1135R6_atomic_wait/test.cpp
@@ -1,7 +1,367 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "test_atomic_wait.hpp"
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <cstring>
+#include <memory>
+#include <thread>
+
+template <template <class> class Template, class UnderlyingType>
+void test_atomic_wait_func_impl(UnderlyingType& old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    constexpr int seq_max_size = 10;
+    char seq[seq_max_size + 1];
+    std::atomic<char*> base = seq;
+    auto add_seq            = [&](char ch) {
+        char* p = base.fetch_add(1, std::memory_order_relaxed);
+        assert(p - seq < seq_max_size);
+        *p = ch;
+    };
+
+    Template<UnderlyingType> a(old_value);
+    a.wait(new_value);
+
+    add_seq('1');
+
+    std::thread thd([&] {
+        std::this_thread::sleep_for(waiting_duration);
+        add_seq('2');
+        a.notify_all();
+        std::this_thread::sleep_for(waiting_duration);
+        add_seq('3');
+        a.store(old_value);
+        a.notify_one();
+        std::this_thread::sleep_for(waiting_duration);
+        add_seq('4');
+        a.store(new_value);
+        a.notify_one();
+#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
+        // timing assumption that the main thread evaluates the `wait(old_value)` before this timeout expires
+        std::this_thread::sleep_for(waiting_duration);
+        add_seq('6');
+#endif
+    });
+
+    a.wait(old_value);
+    const auto loaded = a.load();
+    assert(memcmp(&loaded, &new_value, sizeof(UnderlyingType)) == 0);
+
+    add_seq('5');
+
+    thd.join();
+
+    add_seq('\0');
+
+#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
+    assert(strcmp(seq, "123456") == 0);
+#else
+    assert(strcmp(seq, "12345") == 0);
+#endif
+}
+
+template <class UnderlyingType>
+void test_atomic_wait_func(UnderlyingType old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    test_atomic_wait_func_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
+    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value_for_ref = old_value;
+    test_atomic_wait_func_impl<std::atomic_ref, UnderlyingType>(old_value_for_ref, new_value, waiting_duration);
+}
+
+template <class UnderlyingType>
+void test_atomic_wait_func_ptr(UnderlyingType old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    test_atomic_wait_func_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
+}
+
+
+template <template <class> class Template, class UnderlyingType>
+void test_notify_all_notifies_all_impl(UnderlyingType& old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    Template<UnderlyingType> c(old_value);
+    const auto waitFn = [&c, old_value] { c.wait(old_value); };
+
+    std::thread w1{waitFn};
+    std::thread w2{waitFn};
+    std::thread w3{waitFn};
+
+    std::this_thread::sleep_for(waiting_duration);
+    c.store(new_value);
+    c.notify_all(); // if this doesn't really notify all, the following joins will deadlock
+
+    w1.join();
+    w2.join();
+    w3.join();
+}
+
+template <class UnderlyingType>
+void test_notify_all_notifies_all(UnderlyingType old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    test_notify_all_notifies_all_impl<std::atomic, UnderlyingType>(old_value, new_value, waiting_duration);
+    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value_for_ref = old_value;
+    test_notify_all_notifies_all_impl<std::atomic_ref, UnderlyingType>(old_value_for_ref, new_value, waiting_duration);
+}
+
+template <class UnderlyingType>
+void test_notify_all_notifies_all_ptr(UnderlyingType old_value, const UnderlyingType new_value,
+    const std::chrono::steady_clock::duration waiting_duration) {
+    // increased waiting_duration because timing assumption might not hold for atomic smart pointers
+    test_notify_all_notifies_all_impl<std::atomic, UnderlyingType>(old_value, new_value, 3 * waiting_duration);
+}
+
+
+template <template <class> class Template, class UnderlyingType>
+void test_pad_bits_impl(const std::chrono::steady_clock::duration waiting_duration) {
+    alignas(std::atomic_ref<UnderlyingType>::required_alignment) UnderlyingType old_value;
+    memset(&old_value, 0x66, sizeof(UnderlyingType));
+    old_value.set(1);
+
+    UnderlyingType same_old_value;
+    memset(&same_old_value, 0x99, sizeof(UnderlyingType));
+    same_old_value.set(1);
+
+    Template<UnderlyingType> c(old_value);
+
+    bool trigger      = false;
+    const auto waitFn = [&c, same_old_value, &trigger] {
+        c.wait(same_old_value);
+        trigger = true;
+    };
+
+    std::thread w1{waitFn};
+
+    std::this_thread::sleep_for(waiting_duration);
+    assert(!trigger);
+
+    c.store(old_value);
+    c.notify_one();
+
+    std::this_thread::sleep_for(waiting_duration);
+    assert(!trigger);
+
+    UnderlyingType new_value;
+    memset(&new_value, 0x99, sizeof(UnderlyingType));
+    new_value.set(2);
+    c.store(new_value);
+    c.notify_one();
+
+#ifdef CAN_FAIL_ON_TIMING_ASSUMPTION
+    std::this_thread::sleep_for(waiting_duration);
+    assert(trigger);
+    w1.join();
+#else // ^^^ CAN_FAIL_ON_TIMING_ASSUMPTION / !CAN_FAIL_ON_TIMING_ASSUMPTION vvv
+    w1.join();
+    assert(trigger);
+#endif // ^^^ !CAN_FAIL_ON_TIMING_ASSUMPTION ^^^
+}
+
+template <class UnderlyingType>
+void test_pad_bits(const std::chrono::steady_clock::duration waiting_duration) {
+    test_pad_bits_impl<std::atomic, UnderlyingType>(waiting_duration);
+    test_pad_bits_impl<std::atomic_ref, UnderlyingType>(waiting_duration);
+}
+
+struct two_shorts {
+    short a;
+    short b;
+
+    friend bool operator==(two_shorts, two_shorts) = delete;
+};
+
+struct three_chars {
+    char a;
+    char b;
+    char c;
+
+    friend bool operator==(three_chars, three_chars) = delete;
+};
+
+struct big_char_like {
+    char value;
+    char unused[16];
+
+    explicit big_char_like(char value_) : value(value_), unused{} {}
+
+    friend bool operator==(big_char_like, big_char_like) = delete;
+};
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+template <size_t size>
+struct with_padding_bits {
+    alignas(size) char value;
+
+    void set(const char value_) {
+        value = value_;
+    }
+
+    friend bool operator==(with_padding_bits, with_padding_bits) = delete;
+};
+#pragma warning(pop)
+
+template <class T, class U>
+[[nodiscard]] bool ownership_equal(const T& t, const U& u) {
+    return !t.owner_before(u) && !u.owner_before(t);
+}
+
+inline void test_gh_3602() {
+    // GH-3602 std::atomic<std::shared_ptr>::wait does not seem to care about control block difference. Is this a bug?
+    {
+        auto sp1    = std::make_shared<char>();
+        auto holder = [sp1] {};
+        auto sp2    = std::make_shared<decltype(holder)>(holder);
+        std::shared_ptr<char> sp3{sp2, sp1.get()};
+
+        std::atomic<std::shared_ptr<char>> asp{sp1};
+        asp.wait(sp3);
+    }
+    {
+        auto sp1    = std::make_shared<char>();
+        auto holder = [sp1] {};
+        auto sp2    = std::make_shared<decltype(holder)>(holder);
+        std::shared_ptr<char> sp3{sp2, sp1.get()};
+        std::weak_ptr<char> wp3{sp3};
+
+        std::atomic<std::weak_ptr<char>> awp{sp1};
+        awp.wait(wp3);
+    }
+
+    {
+        auto sp1    = std::make_shared<char>();
+        auto holder = [sp1] {};
+        auto sp2    = std::make_shared<decltype(holder)>(holder);
+        std::shared_ptr<char> sp3{sp2, sp1.get()};
+
+        std::atomic<std::shared_ptr<char>> asp{sp3};
+
+        std::thread t([&] {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            asp = sp1;
+            asp.notify_one();
+        });
+
+        asp.wait(sp3);
+
+        t.join();
+    }
+
+    { // Also test shared_ptrs that own the null pointer.
+        int* const raw = nullptr;
+
+        std::shared_ptr<int> sp_empty;
+        std::shared_ptr<int> sp_also_empty;
+        std::shared_ptr<int> sp_original(raw);
+        std::shared_ptr<int> sp_copy(sp_original);
+        std::shared_ptr<int> sp_different(raw);
+
+        assert(ownership_equal(sp_empty, sp_also_empty));
+        assert(!ownership_equal(sp_original, sp_empty));
+        assert(ownership_equal(sp_original, sp_copy));
+        assert(!ownership_equal(sp_original, sp_different));
+
+        std::atomic<std::shared_ptr<int>> asp_empty;
+        asp_empty.wait(sp_original);
+
+        std::atomic<std::shared_ptr<int>> asp_copy{sp_copy};
+        asp_copy.wait(sp_empty);
+        asp_copy.wait(sp_different);
+    }
+}
+
+inline void test_atomic_wait() {
+    // wait for all the threads to be waiting; if this value is too small the test might be ineffective but should not
+    // fail due to timing assumptions except where otherwise noted; if it is too large the test will only take longer
+    // than necessary
+    constexpr std::chrono::milliseconds waiting_duration{100};
+    test_atomic_wait_func<char>(1, 2, waiting_duration);
+    test_atomic_wait_func<signed char>(1, 2, waiting_duration);
+    test_atomic_wait_func<unsigned char>(1, 2, waiting_duration);
+    test_atomic_wait_func<short>(1, 2, waiting_duration);
+    test_atomic_wait_func<unsigned short>(1, 2, waiting_duration);
+    test_atomic_wait_func<int>(1, 2, waiting_duration);
+    test_atomic_wait_func<unsigned int>(1, 2, waiting_duration);
+    test_atomic_wait_func<long>(1, 2, waiting_duration);
+    test_atomic_wait_func<unsigned long>(1, 2, waiting_duration);
+    test_atomic_wait_func<long long>(1, 2, waiting_duration);
+    test_atomic_wait_func<unsigned long long>(1, 2, waiting_duration);
+    test_atomic_wait_func<float>(1, 2, waiting_duration);
+    test_atomic_wait_func<double>(1, 2, waiting_duration);
+    test_atomic_wait_func<long double>(1, 2, waiting_duration);
+    test_atomic_wait_func<const void*>("1", "2", waiting_duration);
+    test_atomic_wait_func(two_shorts{1, 1}, two_shorts{1, 2}, waiting_duration);
+    test_atomic_wait_func(three_chars{1, 1, 3}, three_chars{1, 2, 3}, waiting_duration);
+    test_atomic_wait_func(big_char_like{'a'}, big_char_like{'b'}, waiting_duration);
+
+    test_atomic_wait_func_ptr(std::make_shared<int>('a'), std::make_shared<int>('a'), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int>('a')}, std::weak_ptr{std::make_shared<int>('a')}, waiting_duration);
+    test_atomic_wait_func_ptr(std::make_shared<int[]>(0), std::make_shared<int[]>(0), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int[]>(0)}, std::weak_ptr{std::make_shared<int[]>(0)}, waiting_duration);
+    test_atomic_wait_func_ptr(std::make_shared<int[]>(1), std::make_shared<int[]>(1), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int[]>(1)}, std::weak_ptr{std::make_shared<int[]>(1)}, waiting_duration);
+    test_atomic_wait_func_ptr(std::make_shared<int[2]>(), std::make_shared<int[2]>(), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int[2]>()}, std::weak_ptr{std::make_shared<int[2]>()}, waiting_duration);
+    test_atomic_wait_func_ptr(std::make_shared<int[][2]>(2), std::make_shared<int[][2]>(2), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int[][2]>(2)}, std::weak_ptr{std::make_shared<int[][2]>(2)}, waiting_duration);
+    test_atomic_wait_func_ptr(std::make_shared<int[2][2]>(), std::make_shared<int[2][2]>(), waiting_duration);
+    test_atomic_wait_func_ptr(
+        std::weak_ptr{std::make_shared<int[2][2]>()}, std::weak_ptr{std::make_shared<int[2][2]>()}, waiting_duration);
+
+    test_notify_all_notifies_all<char>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<signed char>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<unsigned char>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<short>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<unsigned short>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<int>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<unsigned int>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<long>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<unsigned long>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<long long>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<unsigned long long>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<float>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<double>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<long double>(1, 2, waiting_duration);
+    test_notify_all_notifies_all<const void*>("1", "2", waiting_duration);
+    test_notify_all_notifies_all(two_shorts{1, 1}, two_shorts{1, 2}, waiting_duration);
+    test_notify_all_notifies_all(three_chars{1, 1, 3}, three_chars{1, 2, 3}, waiting_duration);
+    test_notify_all_notifies_all(big_char_like{'a'}, big_char_like{'b'}, waiting_duration);
+
+    test_notify_all_notifies_all_ptr(std::make_shared<int>('a'), std::make_shared<int>('a'), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int>('a')}, std::weak_ptr{std::make_shared<int>('a')}, waiting_duration);
+    test_notify_all_notifies_all_ptr(std::make_shared<int[]>(0), std::make_shared<int[]>(0), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int[]>(0)}, std::weak_ptr{std::make_shared<int[]>(0)}, waiting_duration);
+    test_notify_all_notifies_all_ptr(std::make_shared<int[]>(1), std::make_shared<int[]>(1), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int[]>(1)}, std::weak_ptr{std::make_shared<int[]>(1)}, waiting_duration);
+    test_notify_all_notifies_all_ptr(std::make_shared<int[2]>(), std::make_shared<int[2]>(), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int[2]>()}, std::weak_ptr{std::make_shared<int[2]>()}, waiting_duration);
+    test_notify_all_notifies_all_ptr(std::make_shared<int[][2]>(2), std::make_shared<int[][2]>(2), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int[][2]>(2)}, std::weak_ptr{std::make_shared<int[][2]>(2)}, waiting_duration);
+    test_notify_all_notifies_all_ptr(std::make_shared<int[2][2]>(), std::make_shared<int[2][2]>(), waiting_duration);
+    test_notify_all_notifies_all_ptr(
+        std::weak_ptr{std::make_shared<int[2][2]>()}, std::weak_ptr{std::make_shared<int[2][2]>()}, waiting_duration);
+
+#ifndef __clang__ // TRANSITION, LLVM-46685
+    test_pad_bits<with_padding_bits<2>>(waiting_duration);
+    test_pad_bits<with_padding_bits<4>>(waiting_duration);
+    test_pad_bits<with_padding_bits<8>>(waiting_duration);
+#ifndef _M_ARM
+    test_pad_bits<with_padding_bits<16>>(waiting_duration);
+    test_pad_bits<with_padding_bits<32>>(waiting_duration);
+#endif // ^^^ !ARM ^^^
+#endif // ^^^ no workaround ^^^
+
+    test_gh_3602();
+}
 
 #ifndef _M_CEE // TRANSITION, VSO-1659496
 // GH-140: STL: We should _STD qualify _Ugly function calls to avoid ADL

From 3bd3422627d6bd9aab6f1d3221a415e8d2d741f4 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:34:32 -0700
Subject: [PATCH 06/12] Win8 `__fastfail` is always available.

No ABI impact - this is within a function.
---
 stl/src/ppltasks.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/stl/src/ppltasks.cpp b/stl/src/ppltasks.cpp
index ef1048cad14..62cf885e54a 100644
--- a/stl/src/ppltasks.cpp
+++ b/stl/src/ppltasks.cpp
@@ -26,12 +26,6 @@ namespace Concurrency {
 
     namespace details {
         [[noreturn]] _CRTIMP2 void __cdecl _ReportUnobservedException() {
-#if (defined(_M_IX86) || defined(_M_X64)) && !defined(_CRT_APP) && _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
-            if (!IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE)) {
-                std::abort();
-            }
-#endif // ^^^ __fastfail conditionally available ^^^
-
             __fastfail(FAST_FAIL_INVALID_ARG);
         }
 

From fe85a7bf31f166de054a972d516835421822adaf Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:43:11 -0700
Subject: [PATCH 07/12] Win8 `GetSystemTimePreciseAsFileTime` is always
 available.

`<__msvc_chrono.hpp>`: Update comment as `system_clock` is now always Precise.

awint.hpp: We don't need to macroize the `__crt` name because we'll directly call the WinAPI function.
We also don't need to declare the `__crt` name anymore. The definition is still dllexported because it's consistently marked as `_CRTIMP2`.

winapisupp.cpp: We don't need to define and store the function pointer, which was in an unnamed namespace, so no ABI impact.
Mark the `__crt` function as preserved for bincompat, directly call the WinAPI function.

xtime.cpp: Directly call the WinAPI function.
---
 stl/inc/__msvc_chrono.hpp |  2 +-
 stl/src/awint.hpp         | 11 -----------
 stl/src/winapisupp.cpp    | 18 ++----------------
 stl/src/xtime.cpp         |  2 +-
 4 files changed, 4 insertions(+), 29 deletions(-)

diff --git a/stl/inc/__msvc_chrono.hpp b/stl/inc/__msvc_chrono.hpp
index cad459cf814..08268b83b84 100644
--- a/stl/inc/__msvc_chrono.hpp
+++ b/stl/inc/__msvc_chrono.hpp
@@ -640,7 +640,7 @@ namespace chrono {
         return time_point<_Clock, _To>(_CHRONO round<_To>(_Time.time_since_epoch()));
     }
 
-    _EXPORT_STD struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
+    _EXPORT_STD struct system_clock { // wraps GetSystemTimePreciseAsFileTime
         using rep                       = long long;
         using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
         using duration                  = _CHRONO duration<rep, period>;
diff --git a/stl/src/awint.hpp b/stl/src/awint.hpp
index da1e26e470a..797801b7a98 100644
--- a/stl/src/awint.hpp
+++ b/stl/src/awint.hpp
@@ -14,17 +14,6 @@
 
 _CRT_BEGIN_C_HEADER
 
-#if _STL_WIN32_WINNT >= _WIN32_WINNT_WIN8
-
-#define __crtGetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime) \
-    GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime)
-
-#else // ^^^ _STL_WIN32_WINNT >= _WIN32_WINNT_WIN8 / _STL_WIN32_WINNT < _WIN32_WINNT_WIN8 vvv
-
-_CRTIMP2 void __cdecl __crtGetSystemTimePreciseAsFileTime(_Out_ LPFILETIME lpSystemTimeAsFileTime) noexcept;
-
-#endif // ^^^ _STL_WIN32_WINNT < _WIN32_WINNT_WIN8 ^^^
-
 _CRTIMP2 int __cdecl __crtCompareStringA(_In_z_ LPCWSTR _LocaleName, _In_ DWORD _DwCmpFlags,
     _In_reads_(_CchCount1) LPCSTR _LpString1, _In_ int _CchCount1, _In_reads_(_CchCount2) LPCSTR _LpString2,
     _In_ int _CchCount2, _In_ int _CodePage) noexcept;
diff --git a/stl/src/winapisupp.cpp b/stl/src/winapisupp.cpp
index 94dc7a55b15..2ecda2402ce 100644
--- a/stl/src/winapisupp.cpp
+++ b/stl/src/winapisupp.cpp
@@ -25,10 +25,6 @@ namespace {
     DEFINEFUNCTIONPOINTER(GetCurrentPackageId);
 #endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
 
-#if _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
-    DEFINEFUNCTIONPOINTER(GetSystemTimePreciseAsFileTime);
-#endif // _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
-
     DEFINEFUNCTIONPOINTER(GetTempPath2W);
 
 // Use this macro for caching a function pointer from a DLL
@@ -267,15 +263,9 @@ extern "C" _CRTIMP2 BOOL __cdecl __crtSetFileInformationByHandle(_In_ HANDLE con
 
 #if _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
 
+// TRANSITION, ABI: preserved for binary compatibility
 extern "C" _CRTIMP2 void __cdecl __crtGetSystemTimePreciseAsFileTime(_Out_ LPFILETIME lpSystemTimeAsFileTime) noexcept {
-    // use GetSystemTimePreciseAsFileTime if it is available (only on Windows 8+)...
-    IFDYNAMICGETCACHEDFUNCTION(GetSystemTimePreciseAsFileTime) {
-        pfGetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime);
-        return;
-    }
-
-    // ...otherwise use GetSystemTimeAsFileTime.
-    GetSystemTimeAsFileTime(lpSystemTimeAsFileTime);
+    GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime);
 }
 
 #endif // _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
@@ -309,10 +299,6 @@ static int __cdecl initialize_pointers() noexcept {
     STOREFUNCTIONPOINTER(hKernel32, GetCurrentPackageId);
 #endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
 
-#if _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
-    STOREFUNCTIONPOINTER(hKernel32, GetSystemTimePreciseAsFileTime);
-#endif // _STL_WIN32_WINNT < _WIN32_WINNT_WIN8
-
     // Note that GetTempPath2W is defined as of Windows 10 Build 20348 (a server release) or Windows 11,
     // but there is no "_WIN32_WINNT_WIN11" constant, so we will always dynamically load it
     STOREFUNCTIONPOINTER(hKernel32, GetTempPath2W);
diff --git a/stl/src/xtime.cpp b/stl/src/xtime.cpp
index c59d0fc73af..7499f42e19d 100644
--- a/stl/src/xtime.cpp
+++ b/stl/src/xtime.cpp
@@ -51,7 +51,7 @@ _CRTIMP2_PURE long long __cdecl _Xtime_get_ticks() noexcept {
     constexpr long long _Epoch = 0x19DB1DED53E8000LL;
 
     FILETIME ft;
-    __crtGetSystemTimePreciseAsFileTime(&ft);
+    GetSystemTimePreciseAsFileTime(&ft);
     return ((static_cast<long long>(ft.dwHighDateTime)) << 32) + static_cast<long long>(ft.dwLowDateTime) - _Epoch;
 }
 

From a8bf7c57cb4a703a438c0cb967aec9295c0f8936 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 11:56:56 -0700
Subject: [PATCH 08/12] Increase our baseline to `_STL_WIN32_WINNT_WIN8` (still
 overridden for the STL DLL).

---
 stl/inc/yvals_core.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 8a0e7d29d1d..4a3d0ab173e 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1937,13 +1937,10 @@ compiler option, or define _ALLOW_RTCc_IN_STL to suppress this error.
 #if defined(_M_ARM64)
 // The first ARM64 Windows was Windows 10
 #define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN10
-#elif defined(_M_ARM) || defined(_ONECORE) || defined(_CRT_APP)
-// The first ARM or OneCore or App Windows was Windows 8
+#else // ^^^ defined(_M_ARM64) / !defined(_M_ARM64) vvv
+// The earliest Windows supported by this implementation is Windows 8
 #define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN8
-#else // ^^^ default to Win8 / default to Win7 vvv
-// The earliest Windows supported by this implementation is Windows 7
-#define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN7
-#endif // ^^^ !defined(_M_ARM) && !defined(_M_ARM64) && !defined(_ONECORE) && !defined(_CRT_APP) ^^^
+#endif // ^^^ !defined(_M_ARM64) ^^^
 #endif // !defined(_STL_WIN32_WINNT)
 
 #ifdef __cpp_noexcept_function_type

From bc6e71040c6c87e40472177c08d86a962cc43212 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 12:08:56 -0700
Subject: [PATCH 09/12] `_STL_WIN32_WINNT_WIN7` is now unused.

---
 stl/inc/yvals_core.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 4a3d0ab173e..93cbcfaf80e 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1927,7 +1927,6 @@ compiler option, or define _ALLOW_RTCc_IN_STL to suppress this error.
 #endif // defined(MRTDLL) && !defined(_M_CEE_PURE)
 
 #define _STL_WIN32_WINNT_VISTA   0x0600 // _WIN32_WINNT_VISTA from sdkddkver.h
-#define _STL_WIN32_WINNT_WIN7    0x0601 // _WIN32_WINNT_WIN7 from sdkddkver.h
 #define _STL_WIN32_WINNT_WIN8    0x0602 // _WIN32_WINNT_WIN8 from sdkddkver.h
 #define _STL_WIN32_WINNT_WINBLUE 0x0603 // _WIN32_WINNT_WINBLUE from sdkddkver.h
 #define _STL_WIN32_WINNT_WIN10   0x0A00 // _WIN32_WINNT_WIN10 from sdkddkver.h

From e14be04c29122d49ac0e103fdd620bf74a28f8c7 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 12:23:05 -0700
Subject: [PATCH 10/12] Drop comment about "If WaitOnAddress is not available".

---
 stl/inc/xatomic_wait.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stl/inc/xatomic_wait.h b/stl/inc/xatomic_wait.h
index 9c9fe1fd024..5058335d974 100644
--- a/stl/inc/xatomic_wait.h
+++ b/stl/inc/xatomic_wait.h
@@ -23,8 +23,7 @@ inline constexpr unsigned long __std_atomic_wait_no_timeout = 0xFFFF'FFFF; // Pa
 
 // Support for atomic waits.
 // The "direct" functions are used when the underlying infrastructure can use WaitOnAddress directly; that is, _Size is
-// 1, 2, 4, or 8. The contract is the same as the WaitOnAddress function from the Windows SDK. If WaitOnAddress is not
-// available on the current platform, falls back to a similar solution based on SRWLOCK and CONDITION_VARIABLE.
+// 1, 2, 4, or 8. The contract is the same as the WaitOnAddress function from the Windows SDK.
 int __stdcall __std_atomic_wait_direct(
     const void* _Storage, void* _Comparand, size_t _Size, unsigned long _Remaining_timeout) noexcept;
 void __stdcall __std_atomic_notify_one_direct(const void* _Storage) noexcept;

From 67700e1864febea9d2f4fb6ae413b58e26e2adaa Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Sun, 16 Jun 2024 12:32:21 -0700
Subject: [PATCH 11/12] Link with synchronization.lib when building the
 atomic_wait satellite DLL.

Verified that the msbuild change is necessary and sufficient.

For clarity, move up the `#pragma comment` in atomic_wait.cpp.
---
 stl/CMakeLists.txt                                            | 2 +-
 .../stl_atomic_wait/msvcp_atomic_wait.settings.targets        | 1 +
 stl/src/atomic_wait.cpp                                       | 4 ++--
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/stl/CMakeLists.txt b/stl/CMakeLists.txt
index 376f4ef9cd5..1532ef4da0e 100644
--- a/stl/CMakeLists.txt
+++ b/stl/CMakeLists.txt
@@ -556,7 +556,7 @@ function(add_stl_dlls D_SUFFIX REL_OR_DBG)
     generate_satellite_def("atomic_wait" "${D_SUFFIX}")
 
     add_library(msvcp${D_SUFFIX}_atomic_wait SHARED "${CMAKE_BINARY_DIR}/msvcp_atomic_wait${D_SUFFIX}.def")
-    target_link_libraries(msvcp${D_SUFFIX}_atomic_wait PRIVATE msvcp${D_SUFFIX}_atomic_wait_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "advapi32.lib")
+    target_link_libraries(msvcp${D_SUFFIX}_atomic_wait PRIVATE msvcp${D_SUFFIX}_atomic_wait_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "advapi32.lib" "synchronization.lib")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_atomic_wait${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}_atomic_wait${VCLIBS_SUFFIX}")
diff --git a/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets b/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
index 869f8a1ecd2..0f29c995877 100644
--- a/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
+++ b/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
@@ -70,6 +70,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(UniversalCRTLib)"/>
         <TargetLib Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'" Include="$(SdkLibPath)\advapi32.lib"/>
+        <TargetLib Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'" Include="$(SdkLibPath)\synchronization.lib"/>
     </ItemGroup>
 
     <!-- Copy the output dll and pdb to various destinations -->
diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index 7b47aedf052..b9d907150ba 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -10,6 +10,8 @@
 
 #include <Windows.h>
 
+#pragma comment(lib, "synchronization")
+
 namespace {
     constexpr unsigned long long _Atomic_wait_no_deadline = 0xFFFF'FFFF'FFFF'FFFF;
 
@@ -89,8 +91,6 @@ namespace {
 #endif // defined(_DEBUG)
     }
 
-#pragma comment(lib, "synchronization")
-
     [[nodiscard]] unsigned char __std_atomic_compare_exchange_128_fallback(
         _Inout_bytecount_(16) long long* _Destination, _In_ long long _ExchangeHigh, _In_ long long _ExchangeLow,
         _Inout_bytecount_(16) long long* _ComparandResult) noexcept {

From 8097edce3b36d0e67108335399460d6d0a0cda18 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Wed, 19 Jun 2024 13:27:22 -0700
Subject: [PATCH 12/12] Cauterize usage of Win8 GetCurrentPackageId.

Going all the way back to VS 2015 RTM, `__crtIsPackagedApp` was dllexported but never declared for users. Because there are no actual clients to worry about, we can
cauterize its implementation, dramatically simplifying winapisupp.cpp while preserving bincompat. The function needs to continue to exist in order to satisfy our
dllexport validation, but it doesn't need to do anything useful.

Here's the programmer-archaeology. I dug up TFS changeset 1280651 from 2014-06-17.
(Internal URL: https://vstfdevdiv.corp.microsoft.com/DevDiv2/DevDiv/_versionControl/changeset/1280651/ )
This changeset "Remove /guard support from toolset for Dev14 CTP2" unquestionably predated VS 2015 RTM. I downloaded `$/DevDiv/pu/WinC/vctools/crt` and searched for
all mentions of this function:

```
C:\Users\stl\Downloads\crt>rg __crtIsPackagedApp
crtw32\stdcpp\filesys.h
30:     if (__crtIsPackagedApp()) \
69:     if (__crtIsPackagedApp() || AreFileApisANSI())

crtw32\misc\winapisupp.cpp
104:*__crtIsPackagedApp() - Check if the current app is a Packaged app
122:extern "C"  BOOL __cdecl __crtIsPackagedApp (

crtw32\h\awint.h
37:_CRTIMP2 BOOL __cdecl __crtIsPackagedApp(void);
```

The paths have changed over the years, but they're all internal to the STL's separately compiled code, not available via user-visible headers.
The only usage was in our experimental filesystem implementation, so the function was *unnecessarily* dllexported (via `_CRTIMP2`). This was common back then,
because we were confused about how our separately compiled code worked. In this case, different TUs within the STL's separately compiled code (whether the
DLL or the static LIB) had to communicate, but they didn't have to communicate with user TUs. There is Only One STL (that DLL or static LIB) so there are
no mismatch concerns. We had just mindlessly copy-pasted the `_CRTIMP2` incantation.

The experimental filesystem usage was removed very early on in VS 2015's lifecycle.
That was TFS changeset 1536084 on 2015-10-10, "Removed `__crtIsPackagedApp` and added `FILE_FLAG_BACKUP_SEMANTICS` to applicable Windows API calls."
(Internal URL: https://vstfdevdiv.corp.microsoft.com/DevDiv2/DevDiv/_versionControl/changeset/1536084/ )

So we can make the following changes:

* Make `__crtIsPackagedApp` always return `FALSE`. (The value doesn't actually matter.)
  + It's already marked as preserved for bincompat, but we can drop the large comment explaining what it did.
* Drop the two flavors of definitions for `__crt_IsPackagedAppHelper`. Note that it wasn't dllexported, so this has no ABI impact.
  + The first definition, for `defined(_ONECORE)`, used WRL. Drop the machinery that we defined in an unnamed namespace (obviously no ABI impact), then drop the inclusion of `<wrl/wrappers/corewrappers.h>`.
  + The second definition, for `!defined(_ONECORE)`, needed the `APPMODEL_ERROR_NO_PACKAGE` constant and loaded `GetCurrentPackageId` via a cached function pointer.
* Drop the inclusion of `<AppModel.h>` (conveniently commented as providing `APPMODEL_ERROR_NO_PACKAGE`) and the clang-format suppression for it.
* Drop the `DEFINEFUNCTIONPOINTER`, `STOREFUNCTIONPOINTER` for `GetCurrentPackageId`.
  + This function pointer is defined within an unnamed namespace, so there's definitely no ABI impact. This very slightly improves the STL's performance (one fewer function pointer to store) and security (one fewer function pointer available as a target).
---
 stl/src/winapisupp.cpp | 123 ++---------------------------------------
 1 file changed, 5 insertions(+), 118 deletions(-)

diff --git a/stl/src/winapisupp.cpp b/stl/src/winapisupp.cpp
index 2ecda2402ce..de6f6ae4d29 100644
--- a/stl/src/winapisupp.cpp
+++ b/stl/src/winapisupp.cpp
@@ -1,19 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-// clang-format off
-// Prevent clang-format from reordering <AppModel.h> before <Windows.h>
-#include <Windows.h>
-#include <AppModel.h> // for APPMODEL_ERROR_NO_PACKAGE
-#include <internal_shared.h>
-#include <cstdlib>
 #include <yvals.h>
-// clang-format on
 
-#pragma warning(push)
-#pragma warning(disable : 4265) // non-virtual destructor in base class
-#include <wrl/wrappers/corewrappers.h>
-#pragma warning(pop)
+#include <cstdlib>
+#include <internal_shared.h>
+
+#include <Windows.h>
 
 #if !defined(_ONECORE)
 namespace {
@@ -21,10 +14,6 @@ namespace {
 // Use this macro for defining the following function pointers
 #define DEFINEFUNCTIONPOINTER(fn_name) decltype(&fn_name) __KERNEL32Function_##fn_name = nullptr
 
-#if !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
-    DEFINEFUNCTIONPOINTER(GetCurrentPackageId);
-#endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
-
     DEFINEFUNCTIONPOINTER(GetTempPath2W);
 
 // Use this macro for caching a function pointer from a DLL
@@ -39,107 +28,9 @@ namespace {
 
 #if !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
 
-#if !defined(_CRT_APP)
-#if defined(_ONECORE)
-
-namespace {
-    struct HMODULETraits {
-        using Type = HMODULE;
-
-        static bool Close(Type const h) noexcept {
-            return ::FreeLibrary(h) != FALSE;
-        }
-
-        static Type GetInvalidValue() noexcept {
-            return nullptr;
-        }
-    };
-
-    using HMODULEHandle = Microsoft::WRL::Wrappers::HandleT<HMODULETraits>;
-} // unnamed namespace
-
-extern "C" int __crt_IsPackagedAppHelper() noexcept {
-    static wchar_t const* const possible_apisets[] = {
-        L"api-ms-win-appmodel-runtime-l1-1-1.dll", // Windows 8.1+ APISet
-        L"ext-ms-win-kernel32-package-current-l1-1-0.dll", // Legacy APISet
-        L"appmodel.dll" // LNM implementation DLL
-    };
-
-    for (auto& dll : possible_apisets) {
-        HMODULEHandle const apiset(LoadLibraryExW(dll, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32));
-        if (!apiset.IsValid()) {
-            continue;
-        }
-
-        auto const get_current_package_id =
-            reinterpret_cast<decltype(&GetCurrentPackageId)>(GetProcAddress(apiset.Get(), "GetCurrentPackageId"));
-
-        if (!get_current_package_id) {
-            continue;
-        }
-
-        UINT32 buffer_length = 0;
-        if (get_current_package_id(&buffer_length, nullptr) == ERROR_INSUFFICIENT_BUFFER) {
-            return 1;
-        } else {
-            return 0;
-        }
-    }
-
-    // Either the app is not packaged or we cannot determine if the app is packaged:
-    return 0;
-}
-
-#else // ^^^ defined(_ONECORE) / !defined(_ONECORE) vvv
-
-extern "C" int __crt_IsPackagedAppHelper() noexcept {
-    LONG retValue       = APPMODEL_ERROR_NO_PACKAGE;
-    UINT32 bufferLength = 0;
-
-    IFDYNAMICGETCACHEDFUNCTION(GetCurrentPackageId) {
-        retValue = pfGetCurrentPackageId(&bufferLength, nullptr);
-    }
-
-    if (retValue == ERROR_INSUFFICIENT_BUFFER) {
-        return 1;
-    }
-
-    // If GetCurrentPackageId was not found, or it returned a different error,
-    // then this is NOT a Packaged app
-    return 0;
-}
-
-#endif // ^^^ !defined(_ONECORE) ^^^
-#endif // ^^^ !defined(_CRT_APP) ^^^
-
-// __crtIsPackagedApp() - Check if the current app is a Packaged app
-//
-// Purpose:
-//        Check if the current application was started through a package.
-//        This determines if the app is a Packaged app or not.
-//
-//        This function uses a new Windows 8 API, GetCurrentPackageId, to detect
-//        if the application is deployed via a package.
-//
-// Entry:
-//        None
-//
-// Exit:
-//        TRUE if Packaged app, FALSE if not.
 // TRANSITION, ABI: preserved for binary compatibility
 extern "C" _CRTIMP2 BOOL __cdecl __crtIsPackagedApp() noexcept {
-#ifdef _CRT_APP
-    return TRUE;
-#else // ^^^ defined(_CRT_APP) / !defined(_CRT_APP) vvv
-    static int isPackaged = -1; // Initialize to undefined state
-
-    // If we've already made this check, just return the prev result
-    if (isPackaged < 0) {
-        isPackaged = __crt_IsPackagedAppHelper();
-    }
-
-    return (isPackaged > 0) ? TRUE : FALSE;
-#endif // ^^^ !defined(_CRT_APP) ^^^
+    return FALSE;
 }
 
 #endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
@@ -295,10 +186,6 @@ static int __cdecl initialize_pointers() noexcept {
     HINSTANCE hKernel32 = GetModuleHandleW(L"kernel32.dll");
     _Analysis_assume_(hKernel32);
 
-#if !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
-    STOREFUNCTIONPOINTER(hKernel32, GetCurrentPackageId);
-#endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
-
     // Note that GetTempPath2W is defined as of Windows 10 Build 20348 (a server release) or Windows 11,
     // but there is no "_WIN32_WINNT_WIN11" constant, so we will always dynamically load it
     STOREFUNCTIONPOINTER(hKernel32, GetTempPath2W);