gdb/dwarf: use std::equal_range in cooked_index_shard::find

Looking at `cooked_index_shard::find`, I thought that we could make a
small optimization: when finding the upper bound, we already know the
lower bound.  And we know that the upper bound is >= the lower bound.
So we could pass `lower` as the first argument of the `std::upper_bound`
call to cut the part of the search space that is below `lower`.

It then occured to me that what we do is basically what
`std::equal_range` is for, so why not use it.  Implementations of
`std::equal_range` are likely do to things as efficiently as possible.

Unfortunately, because `cooked_index_entry::compare` is sensitive to the
order of its parameters, we need to provide two different comparison
functions (just like we do know, to the lower_bound and upper_bound
calls).  But I think that the use of equal_range makes it clear what the
intent of the code is.

Regression tested using the various DWARF target boards on Debian 12.

Change-Id: Idfad812fb9abae1b942d81ad9976aeed7c2cf762
Approved-By: Tom Tromey <tom@tromey.com>

diff --git a/gdb/dwarf2/cooked-index.c b/gdb/dwarf2/cooked-index.c
index 1a2e19debab597016b52eebd99cb0a3f69cb4421..feaf9b5fe29d9df022fda2bb941106b37f25642c 100644 (file)
--- a/gdb/dwarf2/cooked-index.c
+++ b/gdb/dwarf2/cooked-index.c
@@ -547,25 +547,28 @@ cooked_index_shard::finalize (const parent_map_map *parent_maps)
 cooked_index_shard::range
 cooked_index_shard::find (const std::string &name, bool completing) const
 {
-  cooked_index_entry::comparison_mode mode = (completing
-                                             ? cooked_index_entry::COMPLETE
-                                             : cooked_index_entry::MATCH);
-
-  auto lower = std::lower_bound (m_entries.cbegin (), m_entries.cend (), name,
-                                [=] (const cooked_index_entry *entry,
-                                     const std::string &n)
+  struct comparator
   {
-    return cooked_index_entry::compare (entry->canonical, n.c_str (), mode) < 0;
-  });
+    cooked_index_entry::comparison_mode mode;
 
-  auto upper = std::upper_bound (m_entries.cbegin (), m_entries.cend (), name,
-                                [=] (const std::string &n,
-                                     const cooked_index_entry *entry)
-  {
-    return cooked_index_entry::compare (entry->canonical, n.c_str (), mode) > 0;
-  });
+    bool operator() (const cooked_index_entry *entry,
+                    const char *name) const noexcept
+    {
+      return cooked_index_entry::compare (entry->canonical, name, mode) < 0;
+    }
+
+    bool operator() (const char *name,
+                    const cooked_index_entry *entry) const noexcept
+    {
+      return cooked_index_entry::compare (entry->canonical, name, mode) > 0;
+    }
+  };
 
-  return range (lower, upper);
+  return std::make_from_tuple<range>
+    (std::equal_range (m_entries.cbegin (), m_entries.cend (), name.c_str (),
+                      comparator { (completing
+                                    ? cooked_index_entry::COMPLETE
+                                    : cooked_index_entry::MATCH) }));
 }
 
 /* See cooked-index.h.  */