On Tue, 8 Jul 2025 at 13:24, Jonathan Wakely <jwak...@redhat.com> wrote: > > On Tue, 8 Jul 2025 at 12:54, Paul Keir <paul.k...@uws.ac.uk> wrote: > > > > Let me know if this needs a refresh. > > The patch fails to apply: > > error: patch failed: libstdc++-v3/include/bits/shared_ptr_base.h:1715 > error: libstdc++-v3/include/bits/shared_ptr_base.h: patch does not apply > > but I think it's your mail client munging whitespace, not something > that can be fixed by rebasing on trunk. > I'll figure it out and apply it by hand.
OK, I added your github fork and did a merge --squash from there > > > > > > ________________________________________ > > From: Paul Keir <paul.k...@uws.ac.uk> > > Sent: 06 June 2025 5:32 PM > > To: Jonathan Wakely > > Cc: gcc-patches@gcc.gnu.org; libstd...@gcc.gnu.org > > Subject: Re: [PATCH] libstdc++: Add smart ptr owner_equals and owner_hash > > structs and members for P1901R2 > > > > No problem. That should be it included below. Github diff for convenience: > > https://github.com/gcc-mirror/gcc/compare/e37eb85...pkeir:gcc:1b7c7c1a > > > > Signed-off-by: Paul Keir <paul.k...@uws.ac.uk> > > > > Tested on x86_64-linux. > > > > libstdc++-v3/ChangeLog: > > > > * include/bits/shared_ptr.h: Added owner_equal and owner_hash > > members to shared_ptr and weak_ptr. > > * include/bits/shared_ptr_base.h: Added owner_equal and owner_hash > > structs. > > * include/bits/version.def: Added > > __cpp_lib_smart_ptr_owner_equality feature macro. > > * include/bits/version.h: Update generated for > > __cpp_lib_smart_ptr_owner_equality feature macro. > > * include/std/memory: Added define for > > __glibcxx_want_smart_ptr_owner_equality. > > * testsuite/20_util/owner_equal/version.cc: New test. > > * testsuite/20_util/owner_equal/cmp.cc: New test. > > * testsuite/20_util/owner_equal/noexcept.cc: New test. > > * testsuite/20_util/owner_hash/cmp.cc: New test. > > * testsuite/20_util/owner_hash/noexcept.cc: New test. > > * testsuite/20_util/shared_ptr/observers/owner_equal.cc: New test. > > * testsuite/20_util/shared_ptr/observers/owner_hash.cc: New test. > > * testsuite/20_util/weak_ptr/observers/owner_equal.cc: New test. > > * testsuite/20_util/weak_ptr/observers/owner_hash.cc: New test. > > > > --- > > > > include/bits/shared_ptr.h | 57 +++++++++++ > > include/bits/shared_ptr_base.h | 40 ++++++++ > > include/bits/version.def | 9 ++ > > include/bits/version.h | 10 ++ > > include/std/memory | 1 + > > testsuite/20_util/owner_equal/cmp.cc | 105 > > +++++++++++++++++++++ > > testsuite/20_util/owner_equal/noexcept.cc | 30 ++++++ > > testsuite/20_util/owner_equal/version.cc | 13 +++ > > testsuite/20_util/owner_hash/cmp.cc | 87 +++++++++++++++++ > > testsuite/20_util/owner_hash/noexcept.cc | 16 ++++ > > .../20_util/shared_ptr/observers/owner_equal.cc | 74 +++++++++++++++ > > .../20_util/shared_ptr/observers/owner_hash.cc | 71 ++++++++++++++ > > .../20_util/weak_ptr/observers/owner_equal.cc | 52 ++++++++++ > > testsuite/20_util/weak_ptr/observers/owner_hash.cc | 50 ++++++++++ > > 14 files changed, 615 insertions(+) > > > > diff --git a/libstdc++-v3/include/bits/shared_ptr.h > > b/libstdc++-v3/include/bits/shared_ptr.h > > index a196a0f1212..dd02ab16e59 100644 > > --- a/libstdc++-v3/include/bits/shared_ptr.h > > +++ b/libstdc++-v3/include/bits/shared_ptr.h > > @@ -909,6 +909,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>> > > { }; > > > > +#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > + > > + /** > > + * @brief Provides ownership-based hashing. > > + * @headerfile memory > > + * @since C++26 > > + */ > > + struct owner_hash > > + { > > + template<typename _Tp> > > + size_t operator()(const shared_ptr<_Tp>& __s) const noexcept > > + { return __s.owner_hash(); } > > + > > + template<typename _Tp> > > + size_t operator()(const weak_ptr<_Tp>& __s) const noexcept > > + { return __s.owner_hash(); } > > + > > + using is_transparent = void; > > + }; > > + > > + /** > > + * @brief Provides ownership-based mixed equality comparisons of > > + * shared and weak pointers. > > + * @headerfile memory > > + * @since C++26 > > + */ > > + struct owner_equal > > + { > > + template<typename _Tp1, typename _Tp2> > > + bool > > + operator()(const shared_ptr<_Tp1>& __lhs, > > + const shared_ptr<_Tp2>& __rhs) const noexcept > > + { return __lhs.owner_equal(__rhs); } > > + > > + template<typename _Tp1, typename _Tp2> > > + bool > > + operator()(const shared_ptr<_Tp1>& __lhs, > > + const weak_ptr<_Tp2>& __rhs) const noexcept > > + { return __lhs.owner_equal(__rhs); } > > + > > + template<typename _Tp1, typename _Tp2> > > + bool > > + operator()(const weak_ptr<_Tp1>& __lhs, > > + const shared_ptr<_Tp2>& __rhs) const noexcept > > + { return __lhs.owner_equal(__rhs); } > > + > > + template<typename _Tp1, typename _Tp2> > > + bool > > + operator()(const weak_ptr<_Tp1>& __lhs, > > + const weak_ptr<_Tp2>& __rhs) const noexcept > > + { return __lhs.owner_equal(__rhs); } > > + > > + using is_transparent = void; > > + }; > > + > > +#endif > > + > > /** > > * @brief Base class allowing use of the member function > > `shared_from_this`. > > * @headerfile memory > > diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h > > b/libstdc++-v3/include/bits/shared_ptr_base.h > > index b4be1b49e4d..f820d31e56b 100644 > > --- a/libstdc++-v3/include/bits/shared_ptr_base.h > > +++ b/libstdc++-v3/include/bits/shared_ptr_base.h > > @@ -1122,6 +1122,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > _M_less(const __weak_count<_Lp>& __rhs) const noexcept > > { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, > > __rhs._M_pi); } > > > > +#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > + size_t > > + _M_owner_hash() const noexcept > > + { return std::hash<_Sp_counted_base<_Lp>*>()(this->_M_pi); } > > +#endif > > + > > // Friend function injected into enclosing namespace and found by ADL > > friend inline bool > > operator==(const __shared_count& __a, const __shared_count& __b) > > noexcept > > @@ -1225,6 +1231,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > _M_less(const __shared_count<_Lp>& __rhs) const noexcept > > { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, > > __rhs._M_pi); } > > > > +#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > + size_t > > + _M_owner_hash() const noexcept > > + { return std::hash<_Sp_counted_base<_Lp>*>()(this->_M_pi); } > > +#endif > > + > > // Friend function injected into enclosing namespace and found by ADL > > friend inline bool > > operator==(const __weak_count& __a, const __weak_count& __b) noexcept > > @@ -1715,6 +1727,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > { return _M_refcount._M_less(__rhs._M_refcount); } > > /// @} > > > > +#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > + size_t owner_hash() const noexcept { return > > _M_refcount._M_owner_hash(); } > > + > > + template<typename _Tp1> > > + bool > > + owner_equal(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept > > + { return _M_refcount == __rhs._M_refcount; } > > + > > + template<typename _Tp1> > > + bool > > + owner_equal(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept > > + { return _M_refcount == __rhs._M_refcount; } > > +#endif > > + > > protected: > > // This constructor is non-standard, it is used by allocate_shared. > > template<typename _Alloc, typename... _Args> > > @@ -2098,6 +2124,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept > > { return _M_refcount._M_less(__rhs._M_refcount); } > > > > +#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > + size_t owner_hash() const noexcept { return > > _M_refcount._M_owner_hash(); } > > + > > + template<typename _Tp1> > > + bool > > + owner_equal(const __shared_ptr<_Tp1, _Lp> & __rhs) const noexcept > > + { return _M_refcount == __rhs._M_refcount; } > > + > > + template<typename _Tp1> > > + bool > > + owner_equal(const __weak_ptr<_Tp1, _Lp> & __rhs) const noexcept > > + { return _M_refcount == __rhs._M_refcount; } > > +#endif > > + > > void > > reset() noexcept > > { __weak_ptr().swap(*this); } > > diff --git a/libstdc++-v3/include/bits/version.def > > b/libstdc++-v3/include/bits/version.def > > index 9ab22cc519f..971bbebd54e 100644 > > --- a/libstdc++-v3/include/bits/version.def > > +++ b/libstdc++-v3/include/bits/version.def > > @@ -1995,6 +1995,15 @@ ftms = { > > }; > > }; > > > > +ftms = { > > + name = smart_ptr_owner_equality; > > + values = { > > + v = 202306; > > + cxxmin = 26; > > + hosted = yes; > > + }; > > +}; > > + > > // Standard test specifications. > > stds[97] = ">= 199711L"; > > stds[03] = ">= 199711L"; > > diff --git a/libstdc++-v3/include/bits/version.h > > b/libstdc++-v3/include/bits/version.h > > index 371a7ba3b1a..b395baa612e 100644 > > --- a/libstdc++-v3/include/bits/version.h > > +++ b/libstdc++-v3/include/bits/version.h > > @@ -2233,4 +2233,14 @@ > > #endif /* !defined(__cpp_lib_polymorphic) && > > defined(__glibcxx_want_polymorphic) */ > > #undef __glibcxx_want_polymorphic > > > > +#if !defined(__cpp_lib_smart_ptr_owner_equality) > > +# if (__cplusplus > 202302L) && _GLIBCXX_HOSTED > > +# define __glibcxx_smart_ptr_owner_equality 202306L > > +# if defined(__glibcxx_want_all) || > > defined(__glibcxx_want_smart_ptr_owner_equality) > > +# define __cpp_lib_smart_ptr_owner_equality 202306L > > +# endif > > +# endif > > +#endif /* !defined(__cpp_lib_smart_ptr_owner_equality) && > > defined(__glibcxx_want_smart_ptr_owner_equality) */ > > +#undef __glibcxx_want_smart_ptr_owner_equality > > + > > #undef __glibcxx_want_all > > diff --git a/libstdc++-v3/include/std/memory > > b/libstdc++-v3/include/std/memory > > index 1da03b3ea6a..763a57ee998 100644 > > --- a/libstdc++-v3/include/std/memory > > +++ b/libstdc++-v3/include/std/memory > > @@ -121,6 +121,7 @@ > > #define __glibcxx_want_smart_ptr_for_overwrite > > #define __glibcxx_want_to_address > > #define __glibcxx_want_transparent_operators > > +#define __glibcxx_want_smart_ptr_owner_equality > > #include <bits/version.h> > > > > #if __cplusplus >= 201103L && __cplusplus <= 202002L && _GLIBCXX_HOSTED > > diff --git a/libstdc++-v3/testsuite/20_util/owner_equal/cmp.cc > > b/libstdc++-v3/testsuite/20_util/owner_equal/cmp.cc > > new file mode 100644 > > index 00000000000..311ddf24748 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/owner_equal/cmp.cc > > @@ -0,0 +1,105 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.6 Struct owner_equal [util.smartptr.owner.equal] > > + > > +#include <memory> > > +#include <algorithm> > > +#include <testsuite_hooks.h> > > + > > +struct A { }; > > + > > +struct B { A a[2]; }; > > + > > +int > > +test01() > > +{ > > + // test empty shared_ptr owners compare equivalent > > + std::owner_equal eq; > > + std::shared_ptr<A> p1; > > + std::shared_ptr<A> p2; > > + VERIFY( eq(p1, p2) && eq(p2, p1) ); > > + std::weak_ptr<A> p3; > > + VERIFY( eq(p1, p3) && eq(p3, p1) ); > > + VERIFY( eq(p1, p3) && eq(p3, p1) ); > > + return 0; > > +} > > + > > + > > +// Construction from pointer > > +int > > +test02() > > +{ > > + std::owner_equal eq; > > + > > + std::shared_ptr<A> empty; > > + > > + std::shared_ptr<A> a1(new A); > > + VERIFY( !eq(empty, a1) && !eq(a1, empty) ); > > + > > + std::shared_ptr<A> a2(new A); > > + VERIFY( !eq(a1, a2) && !eq(a2, a1) ); > > + > > + std::weak_ptr<A> w1(a1); > > + VERIFY( eq(a1, w1) && eq(w1, a1) ); > > + > > + std::weak_ptr<A> w2(a2); > > + VERIFY( !eq(w1, w2) && !eq(w2, w1) ); > > + > > + a1.reset(); > > + VERIFY( eq(empty, a1) && eq(a1, empty) ); > > + VERIFY( !eq(a1, w1) && !eq(w1, a1) ); > > + > > + a2.reset(); > > + VERIFY( eq(a2, a1) && eq(a1, a2) ); > > + > > + return 0; > > +} > > + > > +// aliasing > > +int > > +test03() > > +{ > > + std::owner_equal eq; > > + > > + std::shared_ptr<B> b(new B); > > + std::shared_ptr<A> a0(b, &b->a[0]); > > + std::shared_ptr<A> a1(b, &b->a[1]); > > + // values are different but owners are equivalent: > > + VERIFY( a0 < a1 && eq(a0, a1) && eq(b, a0) && eq(b, a1) ); > > + > > + std::weak_ptr<A> w0(a0); > > + std::weak_ptr<A> w1(a1); > > + VERIFY( eq(w0, w1) && eq(w1, w0) ); > > + VERIFY( eq(a0, w1) && eq(w1, a0) ); > > + VERIFY( eq(w0, a1) && eq(a1, w0) ); > > + > > + return 0; > > +} > > + > > +// as binary predicate > > +int > > +test04() > > +{ > > + std::owner_equal eq; > > + > > + std::shared_ptr<B> b(new B); > > + std::shared_ptr<A> a0(b, &b->a[0]); > > + std::shared_ptr<A> a1(b, &b->a[1]); > > + std::shared_ptr<A> c(new A); > > + std::weak_ptr<A> a[3]{a0, a1, c}; > > + std::weak_ptr<A>* p = std::unique(a, a+3, eq); > > + VERIFY( p == &a[2] ); > > + > > + return 0; > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + test03(); > > + test04(); > > + return 0; > > +} > > diff --git a/libstdc++-v3/testsuite/20_util/owner_equal/noexcept.cc > > b/libstdc++-v3/testsuite/20_util/owner_equal/noexcept.cc > > new file mode 100644 > > index 00000000000..fb479f60a74 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/owner_equal/noexcept.cc > > @@ -0,0 +1,30 @@ > > +// { dg-do compile { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.6 Struct owner_equal [util.smartptr.owner.equal] > > + > > +#include <memory> > > + > > +#ifndef __cpp_lib_smart_ptr_owner_equality > > +# error "Feature-test macro for smart ptr owner equality missing in > > <memory>" > > +#elif __cpp_lib_smart_ptr_owner_equality != 202306L > > +# error "Feature-test macro for smart ptr owner equality has wrong value > > in <memory>" > > +#endif > > + > > +const std::owner_equal eq; > > +const std::shared_ptr<int> si; > > +const std::weak_ptr<int> wi; > > +static_assert( noexcept(!eq(si, si)) ); > > +static_assert( noexcept(!eq(si, wi)) ); > > +static_assert( noexcept(!eq(wi, si)) ); > > +static_assert( noexcept(!eq(wi, wi)) ); > > +static_assert( noexcept(!eq(si, wi)) ); > > +static_assert( noexcept(!eq(wi, si)) ); > > +const std::shared_ptr<long> sl; > > +const std::weak_ptr<char> wc; > > +static_assert( noexcept(!eq(si, si)) ); > > +static_assert( noexcept(!eq(si, sl)) ); > > +static_assert( noexcept(!eq(sl, si)) ); > > +static_assert( noexcept(!eq(si, wc)) ); > > +static_assert( noexcept(!eq(wc, si)) ); > > +static_assert( noexcept(!eq(wc, wi)) ); > > diff --git a/libstdc++-v3/testsuite/20_util/owner_equal/version.cc > > b/libstdc++-v3/testsuite/20_util/owner_equal/version.cc > > new file mode 100644 > > index 00000000000..db29154c578 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/owner_equal/version.cc > > @@ -0,0 +1,13 @@ > > +// { dg-do compile { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 17.3.2 Header <version> synopsis [version.syn] > > + > > +#include <version> > > + > > +#ifndef __cpp_lib_smart_ptr_owner_equality > > +# error "Feature-test macro for smart ptr owner equality missing in > > <version>" > > +#elif __cpp_lib_smart_ptr_owner_equality != 202306L > > +# error "Feature-test macro for smart ptr owner equality has wrong value > > in <version>" > > +#endif > > + > > diff --git a/libstdc++-v3/testsuite/20_util/owner_hash/cmp.cc > > b/libstdc++-v3/testsuite/20_util/owner_hash/cmp.cc > > new file mode 100644 > > index 00000000000..c03a9266d08 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/owner_hash/cmp.cc > > @@ -0,0 +1,87 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.5 Struct owner_hash [util.smartptr.owner.hash] > > + > > +#include <memory> > > +#include <algorithm> > > +#include <testsuite_hooks.h> > > + > > +struct A { }; > > + > > +struct B { A a[2]; }; > > + > > +int > > +test01() > > +{ > > + // test empty shared_ptr hashes compare equivalent > > + std::owner_hash oh; > > + std::shared_ptr<A> p1; > > + std::shared_ptr<A> p2; > > + VERIFY( oh(p1) == oh(p2) ); > > + std::weak_ptr<A> p3; > > + VERIFY( oh(p1) == oh(p3) ); > > + VERIFY( oh(p1) == oh(p3) ); > > + return 0; > > +} > > + > > + > > +// Construction from pointer > > +int > > +test02() > > +{ > > + std::owner_hash oh; > > + > > + std::shared_ptr<A> empty; > > + > > + std::shared_ptr<A> a1(new A); > > + VERIFY( oh(empty) != oh(a1) ); > > + > > + std::shared_ptr<A> a2(new A); > > + VERIFY( oh(a1) != oh(a2) ); > > + > > + std::weak_ptr<A> w1(a1); > > + VERIFY( oh(a1) == oh(w1) ); > > + > > + std::weak_ptr<A> w2(a2); > > + VERIFY( oh(w1) != oh(w2) ); > > + > > + a1.reset(); > > + VERIFY( oh(empty) == oh(a1) ); > > + VERIFY( oh(a1) != oh(w1) ); > > + > > + a2.reset(); > > + VERIFY( oh(a2) == oh(a1) ); > > + > > + return 0; > > +} > > + > > +// aliasing > > +int > > +test03() > > +{ > > + std::owner_hash oh; > > + > > + std::shared_ptr<B> b(new B); > > + std::shared_ptr<A> a0(b, &b->a[0]); > > + std::shared_ptr<A> a1(b, &b->a[1]); > > + // values are different but owners are ohuivalent: > > + VERIFY( a0 < a1 && oh(a0) == oh(a1) && oh(b) == oh(a0) && oh(b) == > > oh(a1) ); > > + > > + std::weak_ptr<A> w0(a0); > > + std::weak_ptr<A> w1(a1); > > + VERIFY( oh(w0) == oh(w1) ); > > + VERIFY( oh(a0) == oh(w1) ); > > + VERIFY( oh(w0) == oh(a1) ); > > + > > + return 0; > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + test03(); > > + return 0; > > +} > > diff --git a/libstdc++-v3/testsuite/20_util/owner_hash/noexcept.cc > > b/libstdc++-v3/testsuite/20_util/owner_hash/noexcept.cc > > new file mode 100644 > > index 00000000000..12b2f2fd04f > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/owner_hash/noexcept.cc > > @@ -0,0 +1,16 @@ > > +// { dg-do compile { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.5 Struct owner_hash [util.smartptr.owner.hash] > > + > > +#include <memory> > > + > > +const std::owner_hash oh; > > +const std::shared_ptr<int> si; > > +const std::weak_ptr<int> wi; > > +static_assert( noexcept(!oh(si)) ); > > +static_assert( noexcept(!oh(wi)) ); > > +const std::shared_ptr<long> sl; > > +const std::weak_ptr<char> wc; > > +static_assert( noexcept(!oh(sl)) ); > > +static_assert( noexcept(!oh(wc)) ); > > diff --git > > a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_equal.cc > > b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_equal.cc > > new file mode 100644 > > index 00000000000..7ec86919ccf > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_equal.cc > > @@ -0,0 +1,74 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.2.6 shared_ptr observers [util.smartptr.shared.obs] > > + > > +#include <memory> > > +#include <testsuite_hooks.h> > > + > > +struct A > > +{ > > + int i; > > + virtual ~A() { } > > +}; > > + > > +struct B : A > > +{ > > +}; > > + > > +void > > +test01() > > +{ > > + // test empty shared_ptr owners compare equivalent > > + std::shared_ptr<A> p1; > > + std::shared_ptr<B> p2; > > + VERIFY( p1.owner_equal(p2) && p2.owner_equal(p1) ); > > +} > > + > > + > > +// Construction from pointer > > +void > > +test02() > > +{ > > + std::shared_ptr<A> a0; > > + > > + std::shared_ptr<A> a1(new A); > > + VERIFY( !a1.owner_equal(a0) && !a0.owner_equal(a1) ); > > + > > + std::shared_ptr<B> b1(new B); > > + VERIFY( !a1.owner_equal(b1) && !b1.owner_equal(a1) ); > > + > > + std::shared_ptr<A> a2(a1); > > + VERIFY( a1.owner_equal(a2) && a2.owner_equal(a1) ); > > + a2 = b1; > > + VERIFY( b1.owner_equal(a2) && a2.owner_equal(b1) ); > > + > > + std::weak_ptr<A> w1(a1); > > + VERIFY( a1.owner_equal(w1) && w1.owner_equal(a1) ); > > + std::weak_ptr<A> w2(a2); > > + VERIFY( b1.owner_equal(w2) && w2.owner_equal(b1) ); > > + > > + static_assert( noexcept(a1.owner_equal(a0)) ); > > + static_assert( noexcept(a1.owner_equal(b1)) ); > > + static_assert( noexcept(b1.owner_equal(a1)) ); > > + static_assert( noexcept(a1.owner_equal(w1)) ); > > + static_assert( noexcept(b1.owner_equal(w1)) ); > > +} > > + > > +// Aliasing > > +void > > +test03() > > +{ > > + std::shared_ptr<A> p1(new A()); > > + std::shared_ptr<int> p2(p1, &p1->i); > > + VERIFY( p1.owner_equal(p2) && p2.owner_equal(p1) ); > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + test03(); > > + return 0; > > +} > > diff --git > > a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_hash.cc > > b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_hash.cc > > new file mode 100644 > > index 00000000000..8e6c02cf162 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_hash.cc > > @@ -0,0 +1,71 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.2.6 shared_ptr observers [util.smartptr.shared.obs] > > + > > +#include <memory> > > +#include <testsuite_hooks.h> > > + > > +struct A > > +{ > > + int i; > > + virtual ~A() { } > > +}; > > + > > +struct B : A > > +{ > > +}; > > + > > +void > > +test01() > > +{ > > + // test empty shared_ptr hashes compare equivalent > > + std::shared_ptr<A> p1; > > + std::shared_ptr<B> p2; > > + VERIFY( p1.owner_hash() == p2.owner_hash() ); > > +} > > + > > + > > +// Construction from pointer > > +void > > +test02() > > +{ > > + std::shared_ptr<A> a0; > > + > > + std::shared_ptr<A> a1(new A); > > + VERIFY( a1.owner_hash() != a0.owner_hash() ); > > + > > + std::shared_ptr<B> b1(new B); > > + VERIFY( a1.owner_hash() != b1.owner_hash() ); > > + > > + std::shared_ptr<A> a2(a1); > > + VERIFY( a1.owner_hash() == a2.owner_hash() ); > > + a2 = b1; > > + VERIFY( b1.owner_hash() == a2.owner_hash() ); > > + > > + std::weak_ptr<A> w1(a1); > > + VERIFY( a1.owner_hash() == w1.owner_hash() ); > > + std::weak_ptr<A> w2(a2); > > + VERIFY( b1.owner_hash() == w2.owner_hash() ); > > + > > + static_assert( noexcept(a1.owner_hash()) ); > > + static_assert( noexcept(b1.owner_hash()) ); > > +} > > + > > +// Aliasing > > +void > > +test03() > > +{ > > + std::shared_ptr<A> p1(new A()); > > + std::shared_ptr<int> p2(p1, &p1->i); > > + VERIFY( p1.owner_hash() == p2.owner_hash() ); > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + test03(); > > + return 0; > > +} > > diff --git > > a/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_equal.cc > > b/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_equal.cc > > new file mode 100644 > > index 00000000000..0217a6e5899 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_equal.cc > > @@ -0,0 +1,52 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.3.6 weak_ptr observers [util.smartptr.weak.obs] > > + > > +#include <memory> > > +#include <testsuite_hooks.h> > > + > > +struct A { }; > > +struct B { }; > > + > > +void > > +test01() > > +{ > > + // test empty weak_ptr owners compare equivalent > > + std::weak_ptr<A> p1; > > + std::weak_ptr<B> p2; > > + VERIFY( p1.owner_equal(p2) && p2.owner_equal(p1) ); > > + > > + std::shared_ptr<B> p3; > > + VERIFY( p1.owner_equal(p3) && p3.owner_equal(p1) ); > > + > > + static_assert( noexcept(p1.owner_equal(p1)) ); > > + static_assert( noexcept(p1.owner_equal(p2)) ); > > + static_assert( noexcept(p1.owner_equal(p3)) ); > > + static_assert( noexcept(p2.owner_equal(p1)) ); > > +} > > + > > + > > +void > > +test02() > > +{ > > + std::shared_ptr<A> a0; > > + std::weak_ptr<A> w0(a0); > > + > > + std::shared_ptr<A> a1(new A); > > + std::weak_ptr<A> w1(a1); > > + VERIFY( a1.owner_equal(w1) && w1.owner_equal(a1) ); > > + VERIFY( !w1.owner_equal(w0) && !w0.owner_equal(w1) ); > > + VERIFY( !w1.owner_equal(a0) && !a0.owner_equal(w1) ); > > + > > + std::shared_ptr<B> b1(new B); > > + VERIFY( !w1.owner_equal(b1) && !b1.owner_equal(w1) ); > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + return 0; > > +} > > diff --git > > a/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_hash.cc > > b/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_hash.cc > > new file mode 100644 > > index 00000000000..148a93be099 > > --- /dev/null > > +++ b/libstdc++-v3/testsuite/20_util/weak_ptr/observers/owner_hash.cc > > @@ -0,0 +1,50 @@ > > +// { dg-do run { target c++26 } } > > +// { dg-require-effective-target hosted } > > + > > +// N5008 20.3.2.3.6 weak_ptr observers [util.smartptr.weak.obs] > > + > > +#include <memory> > > +#include <testsuite_hooks.h> > > + > > +struct A { }; > > +struct B { }; > > + > > +void > > +test01() > > +{ > > + // test empty weak_ptr hashes compare equivalent > > + std::weak_ptr<A> p1; > > + std::weak_ptr<B> p2; > > + VERIFY( p1.owner_hash() == p2.owner_hash() ); > > + > > + std::shared_ptr<B> p3; > > + VERIFY( p1.owner_hash() == p3.owner_hash() ); > > + > > + static_assert( noexcept(p1.owner_hash()) ); > > + static_assert( noexcept(p2.owner_hash()) ); > > +} > > + > > + > > +void > > +test02() > > +{ > > + std::shared_ptr<A> a0; > > + std::weak_ptr<A> w0(a0); > > + > > + std::shared_ptr<A> a1(new A); > > + std::weak_ptr<A> w1(a1); > > + VERIFY( a1.owner_hash() == w1.owner_hash() ); > > + VERIFY( w1.owner_hash() != w0.owner_hash() ); > > + VERIFY( w1.owner_hash() != a0.owner_hash() ); > > + > > + std::shared_ptr<B> b1(new B); > > + VERIFY( w1.owner_hash() != b1.owner_hash() ); > > +} > > + > > +int > > +main() > > +{ > > + test01(); > > + test02(); > > + return 0; > > +} > > > > ________________________________________ > > From: Jonathan Wakely <jwak...@redhat.com> > > Sent: 06 June 2025 12:27 PM > > To: Paul Keir > > Cc: gcc-patches@gcc.gnu.org; libstd...@gcc.gnu.org > > Subject: Re: [PATCH] libstdc++: Add smart ptr owner_equals and owner_hash > > structs and members for P1901R2 > > > > > > > > Warning: Do not open attachments or click on links unless you trust the > > sender > > > > > > > > On 23/05/25 17:55 +0000, Paul Keir wrote: > > >This patch implements C++26 "Enabling the Use of weak_ptr as Keys in > > >Unordered Associative Containers", as specified in P1901R2. > > > > > >I don't have write access. > > > > > >Signed-off-by: Paul Keir <paul.k...@uws.ac.uk> > > > > > >Tested on x86_64-linux. > > > > > >libstdc++-v3/ChangeLog: > > > > > > * include/bits/shared_ptr.h: Added owner_equal and owner_hash > > > members to shared_ptr and weak_ptr > > > * include/bits/shared_ptr_base.h: Added owner_equal and owner_hash > > > structs > > > * testsuite/20_util/owner_equal/cmp.cc: New test. > > > * testsuite/20_util/owner_equal/noexcept.cc: New test. > > > * testsuite/20_util/owner_hash/cmp.cc: New test. > > > * testsuite/20_util/owner_hash/noexcept.cc: New test. > > > * testsuite/20_util/shared_ptr/observers/owner_equal.cc: New test. > > > * testsuite/20_util/shared_ptr/observers/owner_hash.cc: New test. > > > * testsuite/20_util/weak_ptr/observers/owner_equal.cc: New test. > > > * testsuite/20_util/weak_ptr/observers/owner_hash.cc: New test. > > > > > >--- > > > > > > libstdc++-v3/include/bits/shared_ptr.h | 57 ++++++++++ > > > libstdc++-v3/include/bits/shared_ptr_base.h | 40 +++++++ > > > libstdc++-v3/testsuite/20_util/owner_equal/cmp.cc | 122 > > > +++++++++++++++++++++ > > > .../testsuite/20_util/owner_equal/noexcept.cc | 39 +++++++ > > > libstdc++-v3/testsuite/20_util/owner_hash/cmp.cc | 104 > > > ++++++++++++++++++ > > > .../testsuite/20_util/owner_hash/noexcept.cc | 31 ++++++ > > > .../20_util/shared_ptr/observers/owner_equal.cc | 93 ++++++++++++++++ > > > .../20_util/shared_ptr/observers/owner_hash.cc | 90 +++++++++++++++ > > > .../20_util/weak_ptr/observers/owner_equal.cc | 71 ++++++++++++ > > > .../20_util/weak_ptr/observers/owner_hash.cc | 69 ++++++++++++ > > > 10 files changed, 716 insertions(+) > > > > > >diff --git a/libstdc++-v3/include/bits/shared_ptr.h > > >b/libstdc++-v3/include/bits/shared_ptr.h > > >index a196a0f1212..9f25f6ccc23 100644 > > >--- a/libstdc++-v3/include/bits/shared_ptr.h > > >+++ b/libstdc++-v3/include/bits/shared_ptr.h > > >@@ -909,6 +909,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > > : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>> > > > { }; > > > > > >+#if __cplusplus > 202302L > > > > All these preprocessor checks should now use the new macro you've > > defined in bits/version.h > > > > #ifdef __glibcxx_smart_ptr_owner_equality // >= C++26 > > > > (the __glibcxx_smart_ptr_owner_equality macro is the internal one > > that's always defined after including bits/version.h, whereas the > > __cpp_lib_xxx one will only be defined by <memory> and <version>). > > > > Apart from that, the current diff at > > https://github.com/gcc-mirror/gcc/compare/97e8cd9...pkeir:gcc:4f699d8 > > looks good for trunk. > > > > If you can change those #if checks and send a new patch to the list, > > I'll get it pushed to trunk. > > > > Thanks! > > > > > > > > > > Please consider the environment and think before you print. > > > > The University of the West of Scotland is a registered Scottish charity. > > Charity number SC002520. > > > > This e-mail and any attachment is for authorised use by the intended > > recipient(s) only. It may contain proprietary material, confidential > > information and/or be subject to legal privilege. It should not be copied, > > disclosed to, retained or used by, any other party. If you are not an > > intended recipient then please promptly delete this e-mail and any > > attachment and all copies and inform the sender. > > > > Please note that any views or opinions presented in this email are solely > > those of the author and do not necessarily represent those of the > > University of the West of Scotland. > > > > As a public body, the University of the West of Scotland may be required to > > make available emails as well as other written forms of information as a > > result of a request made under the Freedom of Information (Scotland) Act > > 2002. > >
