Re: [PATCH 3/7] gdb: simplify find_compunit_symtab_for_pc_sect

["Jan Vraný" <Jan.Vrany@labware.com>]

On Thu, 2026-02-19 at 13:02 -0700, Tom Tromey wrote:
> > > > > > "Jan" == Jan Vrany <jan.vrany@labware.com> writes:
> 
> Jan> This commit simplifies find_compunit_symtab_for_pc_sect by removing the
> Jan> code that walks over all (currently expanded) CUs and delegating to
> Jan> quick_symbol_functions::find_pc_sect_compunit_symtab instead.
> 
> Jan> With this commit on Linux x86_64 I see no regression. With -readnow
> Jan> there are some regressions, mainly caused by slightly different order
> Jan> of expanding CUs. Since there's a proposal to remove -readnow support,
> Jan> I have not fixed nor investigated failing tests in depth.
> 
> I think that proposal was rejected so I'm afraid you'll have to revisit
> that.

So I did that. The only regression I spotted is dw2-entry-points.exp in
which the hand-written DWARF creates to CUs, first one with "hole". 
And since blockvector::lookup() returns static block if no better block 
is found and because the CU with hole happens to be tried first, 
the test fails. If one changes the order of CUs in the test, it passed. 

There's an easy "fix" for that - look for compunit that contains shortest 
block containing the PC, somewhat along the lines of "big chunk": in current 
find_compunit_symtab_for_pc_sect (see patch below). 

But: I'm not sure we want to do that. This brings us back to the idea that 
blockvector::lookup() should never return static block. Or accept that
regression. 

Jan

-- >8 --
From a4b9d584634f4aff9fc0d2f4b3ce2a2a5019b3ad Mon Sep 17 00:00:00 2001
From: Jan Vrany <jan.vrany@labware.com>
Date: Wed, 25 Feb 2026 22:34:40 +0000
Subject: [PATCH] FIXUP: gdb: implement
 readnow_functions::find_pc_sect_compunit_symtab

---
 gdb/dwarf2/read.c | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 2ed8b78d596..824f5081105 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -2176,21 +2176,41 @@ readnow_functions::find_pc_sect_compunit_symtab
   /* This invariant is documented in read.h  */
   gdb_assert (per_bfd->index_table == nullptr);
 
-  /* Since we have no index, we simply walk all units until matching CU is
-     found (of there are no more CUs).  */
+  /* Since we have no index, we have to walk all CUs and find one with
+     best-matching block that contains PC.  For the purpose of this method,
+     a block B1 is considerent better matching than block B2 if B1 is not null
+     and B2 is either null or has larger total span than B1.  In other words,
+     smaller blocks are "better".  */
+
+  auto better = [&] (const block *b1, const block *b2)
+    {
+      if (b1 == nullptr)
+	return false;
+      if (b2 == nullptr)
+	return true;
+      return (b1->end () - b1->start ()) < (b2->end () - b2->start ());
+    };
+
+  compunit_symtab *best_cu = nullptr;
+  const block *best_bl = nullptr;
+
   for (int i = 0; i < per_bfd->all_units.size (); i++)
     {
       dwarf2_per_cu *data = per_bfd->all_units[i].get ();
 
       if (per_objfile->symtab_set_p (data))
 	{
-	  compunit_symtab *result = find_pc_sect_compunit_symtab_includes (
-	    per_objfile->get_symtab (data), pc);
-	  if (result != nullptr)
-	    return result;
+	  compunit_symtab *this_cu = per_objfile->get_symtab (data);
+	  const block *this_bl = this_cu->blockvector ()->lookup (pc);
+
+	  if (better (this_bl, best_bl))
+	    {
+	      best_cu = this_cu;
+	      best_bl = this_bl;
+	    }
 	}
     }
-  return nullptr;
+  return best_cu;
 }
 
 void
-- 
2.51.0