mutex.cpp, cond.cpp: Use static dispatch

stl/inc/mutex

@@ -93,11 +93,7 @@ public:
  _Mtx_unlock(_Mymtx());
  }
 
- using native_handle_type = void*;
-
- _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ {
- return _Mtx_getconcrtcs(_Mymtx());
- }
+ // native_handle_type and native_handle() have intentionally been removed. See GH-3820.
 
 protected:
  _NODISCARD_TRY_CHANGE_STATE bool _Verify_ownership_levels() noexcept {
@@ -636,8 +632,6 @@ _EXPORT_STD enum class cv_status { // names for wait returns
 
 _EXPORT_STD class condition_variable { // class for waiting for conditions
 public:
- using native_handle_type = _Cnd_t;
-
  condition_variable() noexcept /* strengthened */ {
  _Cnd_init_in_situ(_Mycnd());
  }
@@ -725,9 +719,7 @@ public:
  return _Wait_until1(_Lck, _Abs_time, _Pred);
  }
 
- _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ {
- return _Mycnd();
- }
+ // native_handle_type and native_handle() have intentionally been removed. See GH-3820.
 
  void _Register(unique_lock<mutex>& _Lck, int* _Ready) noexcept { // register this object for release at thread exit
  _Cnd_register_at_thread_exit(_Mycnd(), _Lck.release()->_Mymtx(), _Ready);

stl/src/cond.cpp

@@ -15,9 +15,9 @@ struct _Cnd_internal_imp_t { // condition variable implementation for ConcRT
  typename std::_Aligned_storage<Concurrency::details::stl_condition_variable_max_size,
  Concurrency::details::stl_condition_variable_max_alignment>::type cv;
 
- [[nodiscard]] Concurrency::details::stl_condition_variable_interface* _get_cv() noexcept {
+ [[nodiscard]] Concurrency::details::stl_condition_variable_win7* _get_cv() noexcept {
  // get pointer to implementation
- return reinterpret_cast<Concurrency::details::stl_condition_variable_interface*>(&cv);
+ return reinterpret_cast<Concurrency::details::stl_condition_variable_win7*>(&cv);
  }
 };
 
@@ -28,9 +28,7 @@ void _Cnd_init_in_situ(const _Cnd_t cond) { // initialize condition variable in
  Concurrency::details::create_stl_condition_variable(cond->_get_cv());
 }
 
-void _Cnd_destroy_in_situ(const _Cnd_t cond) { // destroy condition variable in situ
- cond->_get_cv()->destroy();
-}
+void _Cnd_destroy_in_situ(_Cnd_t) {} // destroy condition variable in situ
 
 int _Cnd_init(_Cnd_t* const pcond) { // initialize
  *pcond = nullptr;
@@ -53,7 +51,7 @@ void _Cnd_destroy(const _Cnd_t cond) { // clean up
 }
 
 int _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) { // wait until signaled
- const auto cs = static_cast<Concurrency::details::stl_critical_section_interface*>(_Mtx_getconcrtcs(mtx));
+ const auto cs = static_cast<Concurrency::details::stl_critical_section_win7*>(_Mtx_getconcrtcs(mtx));
  _Mtx_clear_owner(mtx);
  cond->_get_cv()->wait(cs);
  _Mtx_reset_owner(mtx);
@@ -63,7 +61,7 @@ int _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) { // wait until signaled
 // wait until signaled or timeout
 int _Cnd_timedwait(const _Cnd_t cond, const _Mtx_t mtx, const _timespec64* const target) {
  int res = _Thrd_success;
- const auto cs = static_cast<Concurrency::details::stl_critical_section_interface*>(_Mtx_getconcrtcs(mtx));
+ const auto cs = static_cast<Concurrency::details::stl_critical_section_win7*>(_Mtx_getconcrtcs(mtx));
  if (target == nullptr) { // no target time specified, wait on mutex
  _Mtx_clear_owner(mtx);
  cond->_get_cv()->wait(cs);

stl/src/mutex.cpp

@@ -43,8 +43,8 @@ struct _Mtx_internal_imp_t { // ConcRT mutex
  Concurrency::details::stl_critical_section_max_alignment>::type cs;
  long thread_id;
  int count;
- Concurrency::details::stl_critical_section_interface* _get_cs() { // get pointer to implementation
- return reinterpret_cast<Concurrency::details::stl_critical_section_interface*>(&cs);
+ [[nodiscard]] Concurrency::details::stl_critical_section_win7* _get_cs() { // get pointer to implementation
+ return reinterpret_cast<Concurrency::details::stl_critical_section_win7*>(&cs);
  }
 };
 
@@ -65,7 +65,7 @@ void _Mtx_init_in_situ(_Mtx_t mtx, int type) { // initialize mutex in situ
 
 void _Mtx_destroy_in_situ(_Mtx_t mtx) { // destroy mutex in situ
  _THREAD_ASSERT(mtx->count == 0, "mutex destroyed while busy");
- mtx->_get_cs()->destroy();
+ (void) mtx;
 }
 
 int _Mtx_init(_Mtx_t* mtx, int type) { // initialize mutex
@@ -126,7 +126,7 @@ static int mtx_do_lock(_Mtx_t mtx, const _timespec64* target) { // lock mutex
  while (now.tv_sec < target->tv_sec || now.tv_sec == target->tv_sec && now.tv_nsec < target->tv_nsec) {
  // time has not expired
  if (mtx->thread_id == static_cast<long>(GetCurrentThreadId())
- || mtx->_get_cs()->try_lock_for(_Xtime_diff_to_millis2(target, &now))) { // stop waiting
+ || mtx->_get_cs()->try_lock()) { // stop waiting
  res = WAIT_OBJECT_0;
  break;
  } else {

stl/src/primitives.hpp

@@ -10,48 +10,23 @@
 
 namespace Concurrency {
  namespace details {
- class __declspec(novtable) stl_critical_section_interface {
- public:
- virtual void lock() = 0;
- virtual bool try_lock() = 0;
- virtual bool try_lock_for(unsigned int) = 0;
- virtual void unlock() = 0;
- virtual void destroy() = 0;
- };
-
- class __declspec(novtable) stl_condition_variable_interface {
- public:
- virtual void wait(stl_critical_section_interface*) = 0;
- virtual bool wait_for(stl_critical_section_interface*, unsigned int) = 0;
- virtual void notify_one() = 0;
- virtual void notify_all() = 0;
- virtual void destroy() = 0;
- };
-
- class stl_critical_section_win7 final : public stl_critical_section_interface {
+ class stl_critical_section_win7 {
  public:
  stl_critical_section_win7() = default;
 
  ~stl_critical_section_win7() = delete;
  stl_critical_section_win7(const stl_critical_section_win7&) = delete;
  stl_critical_section_win7& operator=(const stl_critical_section_win7&) = delete;
 
- void destroy() override {}
-
- void lock() override {
+ void lock() {
  AcquireSRWLockExclusive(&m_srw_lock);
  }
 
- bool try_lock() override {
+ bool try_lock() {
  return TryAcquireSRWLockExclusive(&m_srw_lock) != 0;
  }
 
- bool try_lock_for(unsigned int) override {
- // STL will call try_lock_for once again if this call will not succeed
- return stl_critical_section_win7::try_lock();
- }
-
- void unlock() override {
+ void unlock() {
  _Analysis_assume_lock_held_(m_srw_lock);
  ReleaseSRWLockExclusive(&m_srw_lock);
  }
@@ -61,50 +36,46 @@ namespace Concurrency {
  }
 
  private:
+ void* unused = nullptr; // TRANSITION, ABI: was the vptr
  SRWLOCK m_srw_lock = SRWLOCK_INIT;
  };
 
- class stl_condition_variable_win7 final : public stl_condition_variable_interface {
+ class stl_condition_variable_win7 {
  public:
- stl_condition_variable_win7() {
- InitializeConditionVariable(&m_condition_variable);
- }
+ stl_condition_variable_win7() = default;
 
  ~stl_condition_variable_win7() = delete;
  stl_condition_variable_win7(const stl_condition_variable_win7&) = delete;
  stl_condition_variable_win7& operator=(const stl_condition_variable_win7&) = delete;
 
- void destroy() override {}
-
- void wait(stl_critical_section_interface* lock) override {
- if (!stl_condition_variable_win7::wait_for(lock, INFINITE)) {
+ void wait(stl_critical_section_win7* lock) {
+ if (!wait_for(lock, INFINITE)) {
  std::terminate();
  }
  }
 
- bool wait_for(stl_critical_section_interface* lock, unsigned int timeout) override {
- return SleepConditionVariableSRW(&m_condition_variable,
- static_cast<stl_critical_section_win7*>(lock)->native_handle(), timeout, 0)
- != 0;
+ bool wait_for(stl_critical_section_win7* lock, unsigned int timeout) {
+ return SleepConditionVariableSRW(&m_condition_variable, lock->native_handle(), timeout, 0) != 0;
  }
 
- void notify_one() override {
+ void notify_one() {
  WakeConditionVariable(&m_condition_variable);
  }
 
- void notify_all() override {
+ void notify_all() {
  WakeAllConditionVariable(&m_condition_variable);
  }
 
  private:
- CONDITION_VARIABLE m_condition_variable;
+ void* unused = nullptr; // TRANSITION, ABI: was the vptr
+ CONDITION_VARIABLE m_condition_variable = CONDITION_VARIABLE_INIT;
  };
 
- inline void create_stl_critical_section(stl_critical_section_interface* p) {
+ inline void create_stl_critical_section(stl_critical_section_win7* p) {
  new (p) stl_critical_section_win7;
  }
 
- inline void create_stl_condition_variable(stl_condition_variable_interface* p) {
+ inline void create_stl_condition_variable(stl_condition_variable_win7* p) {
  new (p) stl_condition_variable_win7;
  }
 

tests/std/tests/Dev11_1150223_shared_mutex/test.cpp

@@ -58,10 +58,7 @@ STATIC_ASSERT(noexcept(declval<thread&>().native_handle()));
 #if _HAS_CXX20
 STATIC_ASSERT(noexcept(declval<jthread&>().native_handle()));
 #endif // _HAS_CXX20
-STATIC_ASSERT(noexcept(declval<mutex&>().native_handle()));
-STATIC_ASSERT(noexcept(declval<recursive_mutex&>().native_handle()));
 STATIC_ASSERT(noexcept(declval<shared_mutex&>().native_handle()));
-STATIC_ASSERT(noexcept(declval<condition_variable&>().native_handle()));
 
 // Also test mandatory and strengthened exception specification for try_lock().
 STATIC_ASSERT(noexcept(declval<mutex&>().try_lock())); // strengthened