[gcc r17-2267] libstdc++: make trees hetero equal_range O(lg n) [PR118851]
Nathan Myers
ncm@gcc.gnu.org
Wed Jul 8 20:33:10 GMT 2026
https://gcc.gnu.org/g:6fc5746a5e809e4f22f343eb51bb963cd151ee7e
commit r17-2267-g6fc5746a5e809e4f22f343eb51bb963cd151ee7e
Author: Nathan Myers <ncm@cantrip.org>
Date: Thu Jun 4 23:42:11 2026 -0400
libstdc++: make trees hetero equal_range O(lg n) [PR118851]
As shipped, the heterogeneous-key members equal_range of rbtree
containers map, multimap, set, and multiset walk the entire range
calling the predicate, in violation of the requirement for
logarithmic complexity. This patch revises them to match the
behavior of the non-heterogeneous multimap and multiset members,
and provides tests to verify it.
libstdc++-v3/Changelog:
PR libstdc++/118851
* include/bits/stl_tree.h (_M_equal_range_tr): Rewrite to match
non-heterogeneous equal_range implementation.
* testsuite/23_containers/map/operations/hetero/equal_range.cc:
New test.
* testsuite/23_containers/multimap/operations/hetero/equal_range.cc:
Same.
* testsuite/23_containers/multiset/operations/hetero/equal_range.cc:
Same.
* testsuite/23_containers/set/operations/hetero/equal_range.cc: Same.
Diff:
---
libstdc++-v3/include/bits/stl_tree.h | 29 +++++--
.../map/operations/hetero/equal_range.cc | 90 ++++++++++++++++++++++
.../multimap/operations/hetero/equal_range.cc | 90 ++++++++++++++++++++++
.../multiset/operations/hetero/equal_range.cc | 90 ++++++++++++++++++++++
.../set/operations/hetero/equal_range.cc | 90 ++++++++++++++++++++++
5 files changed, 383 insertions(+), 6 deletions(-)
diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h
index a7781b72114a..313ee8160023 100644
--- a/libstdc++-v3/include/bits/stl_tree.h
+++ b/libstdc++-v3/include/bits/stl_tree.h
@@ -2026,12 +2026,29 @@ namespace __rb_tree
pair<const_iterator, const_iterator>
_M_equal_range_tr(const _Kt& __k) const
{
- const_iterator __low(_M_lower_bound_tr(__k));
- auto __high = __low;
- auto& __cmp = _M_impl._M_key_compare;
- while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
- ++__high;
- return { __low, __high };
+ auto __x = _M_begin();
+ auto __y = _M_end();
+ while (__x)
+ {
+ if (_M_key_compare(_S_key(__x), __k))
+ __x = _S_right(__x);
+ else if (_M_key_compare(__k, _S_key(__x)))
+ {
+ __y = __x;
+ __x = _S_left(__x);
+ }
+ else
+ {
+ auto __xu(__x);
+ auto __yu(__y);
+ __y = __x;
+ __x = _S_left(__x);
+ __xu = _S_right(__xu);
+ return { const_iterator(_M_lower_bound_tr(__x, __y, __k)),
+ const_iterator(_M_upper_bound_tr(__xu, __yu, __k)) };
+ }
+ }
+ return { const_iterator(__y), const_iterator(__y) };
}
#endif // __glibcxx_generic_associative_lookup
diff --git a/libstdc++-v3/testsuite/23_containers/map/operations/hetero/equal_range.cc b/libstdc++-v3/testsuite/23_containers/map/operations/hetero/equal_range.cc
new file mode 100644
index 000000000000..3ed6ff62ba87
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/map/operations/hetero/equal_range.cc
@@ -0,0 +1,90 @@
+// { dg-do run { target c++14 } }
+
+#include <map>
+#include <string>
+#include <utility>
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct Z;
+
+struct X {
+ std::string s;
+ X(std::string str) : s(str) {}
+ X(Z&&);
+ X(const Z&);
+ friend bool operator<(X const& a, X const& b) { return a.s < b.s; }
+ friend bool operator==(X const& a, X const& b) { return a.s == b.s; }
+};
+
+using cmp = std::less<void>;
+
+struct Z {
+ std::string s;
+ mutable int compares = 0;
+
+ Z() = default;
+ Z(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+ Z(const Z& z) = default;
+ Z& operator=(Z&& z) { s = std::move(z.s); z.s.clear(); return *this; }
+ Z& operator=(const Z& z) = default;
+ Z(std::string s) : s(s) {}
+ Z(int n) : s(std::string(n, 'a')) {}
+ friend bool operator<(Z const& a, Z const& b) { return a.s < b.s; }
+ friend bool operator<(X const& a, Z const& b)
+ { return ++b.compares, a.s.substr(0, b.s.size()) < b.s; }
+ friend bool operator<(Z const& a, X const& b)
+ { return ++a.compares, a.s < b.s.substr(0, a.s.size()); }
+};
+
+X::X(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+X::X(const Z& z) : s(z.s) {}
+
+// A heterogeneous key type like Z here that compares equal
+// if it matches just the first part of the key is allowed.
+
+template <typename T>
+T populate(T a)
+{
+ const std::string vs[] = { "dec", "ded", "dee", "def", "deg", "deh", "dei" };
+ for (auto const& v : vs)
+ a[v] = v+v;
+ return a;
+}
+
+void test_equal_range()
+{
+ std::map<X, std::string, cmp> amap{cmp{}};
+ amap.insert({{X{"abc"}, {"xyz"}}, {X{"def"}, {"uvw"}}, {X{"ghi"}, {"rst"}}});
+
+ {
+ auto a = populate(amap);
+ VERIFY(a.size() == 9);
+ Z z{"de"};
+ auto it = a.equal_range(z);
+ VERIFY(it.first != a.end());
+ VERIFY(it.second != a.end());
+ VERIFY(it.first->first == std::string("dec"));
+ VERIFY(it.second->first == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+ {
+ auto a = populate(amap);
+ VERIFY(a.size() == 9);
+ Z z{"de"};
+ auto const& ca = a;
+ auto it = ca.equal_range(z);
+ VERIFY(it.first != ca.end());
+ VERIFY(it.second != ca.end());
+ VERIFY(it.first->first == std::string("dec"));
+ VERIFY(it.second->first == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+}
+
+int main()
+{
+ test_equal_range();
+}
diff --git a/libstdc++-v3/testsuite/23_containers/multimap/operations/hetero/equal_range.cc b/libstdc++-v3/testsuite/23_containers/multimap/operations/hetero/equal_range.cc
new file mode 100644
index 000000000000..490407c244da
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/multimap/operations/hetero/equal_range.cc
@@ -0,0 +1,90 @@
+// { dg-do run { target c++14 } }
+
+#include <map>
+#include <string>
+#include <utility>
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct Z;
+
+struct X {
+ std::string s;
+ X(std::string str) : s(str) {}
+ X(Z&&);
+ X(const Z&);
+ friend bool operator<(X const& a, X const& b) { return a.s < b.s; }
+ friend bool operator==(X const& a, X const& b) { return a.s == b.s; }
+};
+
+using cmp = std::less<void>;
+
+struct Z {
+ std::string s;
+ mutable int compares = 0;
+
+ Z() = default;
+ Z(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+ Z(const Z& z) = default;
+ Z& operator=(Z&& z) { s = std::move(z.s); z.s.clear(); return *this; }
+ Z& operator=(const Z& z) = default;
+ Z(std::string sv) : s(sv) {}
+ Z(int n) : s(std::string(n, 'a')) {}
+ friend bool operator<(Z const& a, Z const& b) { return a.s < b.s; }
+ friend bool operator<(X const& a, Z const& b)
+ { return ++b.compares, a.s.substr(0, b.s.size()) < b.s; }
+ friend bool operator<(Z const& a, X const& b)
+ { return ++a.compares, a.s < b.s.substr(0, a.s.size()); }
+};
+
+X::X(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+X::X(const Z& z) : s(z.s) {}
+
+// A heterogeneous key type like Z here that compares equal
+// if it matches just the first part of the key is allowed.
+
+template <typename T>
+T populate(T a)
+{
+ const std::string vs[] = { "dec", "ded", "dee", "def", "deg", "deh", "dei" };
+ for (auto const& v : vs)
+ a.insert({X{v}, {v+v}});
+ return a;
+}
+
+void test_equal_range()
+{
+ std::multimap<X, std::string, cmp> amap{cmp{}};
+ amap.insert({{X{"abc"}, {"xyz"}}, {X{"def"}, {"uvw"}}, {X{"ghi"}, {"rst"}}});
+
+ {
+ auto a = populate(amap);
+ VERIFY(a.size() == 10);
+ Z z{"de"};
+ auto it = a.equal_range(z);
+ VERIFY(it.first != a.end());
+ VERIFY(it.second != a.end());
+ VERIFY(it.first->first == std::string("dec"));
+ VERIFY(it.second->first == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+ {
+ auto a = populate(amap);
+ VERIFY(a.size() == 10);
+ Z z{"de"};
+ auto const& ca = a;
+ auto it = ca.equal_range(z);
+ VERIFY(it.first != ca.end());
+ VERIFY(it.second != ca.end());
+ VERIFY(it.first->first == std::string("dec"));
+ VERIFY(it.second->first == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+}
+
+int main()
+{
+ test_equal_range();
+}
diff --git a/libstdc++-v3/testsuite/23_containers/multiset/operations/hetero/equal_range.cc b/libstdc++-v3/testsuite/23_containers/multiset/operations/hetero/equal_range.cc
new file mode 100644
index 000000000000..a9a479a78cd1
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/multiset/operations/hetero/equal_range.cc
@@ -0,0 +1,90 @@
+// { dg-do run { target c++14 } }
+
+#include <set>
+#include <string>
+#include <utility>
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct Z;
+
+struct X {
+ std::string s;
+ X(std::string str) : s(str) {}
+ X(Z&&);
+ X(const Z&);
+ friend bool operator<(X const& a, X const& b) { return a.s < b.s; }
+ friend bool operator==(X const& a, X const& b) { return a.s == b.s; }
+};
+
+using cmp = std::less<void>;
+
+struct Z {
+ std::string s;
+ mutable int compares = 0;
+
+ Z() = default;
+ Z(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+ Z(const Z& z) = default;
+ Z& operator=(Z&& z) { s = std::move(z.s); z.s.clear(); return *this; }
+ Z& operator=(const Z& z) = default;
+ Z(std::string sv) : s(sv) {}
+ Z(int n) : s(std::string(n, 'a')) {}
+ friend bool operator<(Z const& a, Z const& b) { return a.s < b.s; }
+ friend bool operator<(X const& a, Z const& b)
+ { return ++b.compares, a.s.substr(0, b.s.size()) < b.s; }
+ friend bool operator<(Z const& a, X const& b)
+ { return ++a.compares, a.s < b.s.substr(0, a.s.size()); }
+};
+
+X::X(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+X::X(const Z& z) : s(z.s) {}
+
+// A heterogeneous key type like Z here that compares equal
+// if it matches just the first part of the key is allowed.
+
+template <typename T>
+T populate(T a)
+{
+ const std::string vs[] = { "dec", "ded", "dee", "def", "deg", "deh", "dei" };
+ for (auto const& v : vs)
+ a.insert(X{v});
+ return a;
+}
+
+void test_equal_range()
+{
+ std::multiset<X, cmp> aset{cmp{}};
+ aset.insert({X{"abc"}, X{"def"}, X{"ghi"}});
+
+ {
+ auto a = populate(aset);
+ VERIFY(a.size() == 10);
+ Z z{"de"};
+ auto it = a.equal_range(z);
+ VERIFY(it.first != a.end());
+ VERIFY(it.second != a.end());
+ VERIFY(*it.first == std::string("dec"));
+ VERIFY(*it.second == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+ {
+ auto a = populate(aset);
+ VERIFY(a.size() == 10);
+ Z z{"de"};
+ auto const& ca = a;
+ auto it = ca.equal_range(z);
+ VERIFY(it.first != ca.end());
+ VERIFY(it.second != ca.end());
+ VERIFY(*it.first == std::string("dec"));
+ VERIFY(*it.second == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+}
+
+int main()
+{
+ test_equal_range();
+}
diff --git a/libstdc++-v3/testsuite/23_containers/set/operations/hetero/equal_range.cc b/libstdc++-v3/testsuite/23_containers/set/operations/hetero/equal_range.cc
new file mode 100644
index 000000000000..1c9e7a335181
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/set/operations/hetero/equal_range.cc
@@ -0,0 +1,90 @@
+// { dg-do run { target c++14 } }
+
+#include <set>
+#include <string>
+#include <utility>
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct Z;
+
+struct X {
+ std::string s;
+ X(std::string str) : s(str) {}
+ X(Z&&);
+ X(const Z&);
+ friend bool operator<(X const& a, X const& b) { return a.s < b.s; }
+ friend bool operator==(X const& a, X const& b) { return a.s == b.s; }
+};
+
+using cmp = std::less<void>;
+
+struct Z {
+ std::string s;
+ mutable int compares = 0;
+
+ Z() = default;
+ Z(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+ Z(const Z& z) = default;
+ Z& operator=(Z&& z) { s = std::move(z.s); z.s.clear(); return *this; }
+ Z& operator=(const Z& z) = default;
+ Z(std::string sv) : s(sv) {}
+ Z(int n) : s(std::string(n, 'a')) {}
+ friend bool operator<(Z const& a, Z const& b) { return a.s < b.s; }
+ friend bool operator<(X const& a, Z const& b)
+ { return ++b.compares, a.s.substr(0, b.s.size()) < b.s; }
+ friend bool operator<(Z const& a, X const& b)
+ { return ++a.compares, a.s < b.s.substr(0, a.s.size()); }
+};
+
+X::X(Z&& z) : s(std::move(z.s)) { z.s.clear(); }
+X::X(const Z& z) : s(z.s) {}
+
+// A heterogeneous key type like Z here that compares equal
+// if it matches just the first part of the key is allowed.
+
+template <typename T>
+T populate(T a)
+{
+ const std::string vs[] = { "dec", "ded", "dee", "def", "deg", "deh", "dei" };
+ for (auto const& v : vs)
+ a.insert(X{v});
+ return a;
+}
+
+void test_equal_range()
+{
+ std::set<X, cmp> aset{cmp{}};
+ aset.insert({X{"abc"}, X{"def"}, X{"ghi"}});
+
+ {
+ auto a = populate(aset);
+ VERIFY(a.size() == 9);
+ Z z{"de"};
+ auto it = a.equal_range(z);
+ VERIFY(it.first != a.end());
+ VERIFY(it.second != a.end());
+ VERIFY(*it.first == std::string("dec"));
+ VERIFY(*it.second == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+ {
+ auto a = populate(aset);
+ VERIFY(a.size() == 9);
+ Z z{"de"};
+ auto const& ca = a;
+ auto it = ca.equal_range(z);
+ VERIFY(it.first != ca.end());
+ VERIFY(it.second != ca.end());
+ VERIFY(*it.first == std::string("dec"));
+ VERIFY(*it.second == std::string("ghi"));
+
+ VERIFY(z.compares == 7);
+ }
+}
+
+int main()
+{
+ test_equal_range();
+}
More information about the Libstdc++-cvs
mailing list