[RFC v5 02/18] gdb: introduce compunit_symtab::maybe_contains

[Jan Vrany <jan.vrany@labware.com>]

This commit introduces new method - compunit_symtab::maybe_contains -
returning true if a compunit_symtab may contain given address or false
if it definitely cannot. This means, compunit_symtab::maybe_contains
may return true even if in fact the compunit does not contain the
address.

This may happen for native ecoff format, as described in a comment in
find_pc_sect_compunit_symtab (symtab.c).

The second case described in that command (when objfiles that have their
functions reordered) should be handled, in that DWARF reader sets
blockvector's map accordingly and maybe_contains consults that map.

Approved-By: Tom Tromey <tom@tromey.com>
---
 gdb/block.c  | 23 +++++++++++++++++++++++
 gdb/block.h  |  4 ++++
 gdb/symtab.c | 26 ++++++++++++--------------
 gdb/symtab.h |  4 ++++
 4 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/gdb/block.c b/gdb/block.c
index fdf209c86a2..54d768d7255 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -821,6 +821,29 @@ make_blockranges (struct objfile *objfile,
   return blr;
 }
 
+/* See block.h.  */
+
+bool blockvector::maybe_contains (CORE_ADDR addr) const
+{
+  const CORE_ADDR start = global_block ()->start ();
+  const CORE_ADDR end = global_block ()->end ();
+
+  /* Check if given address falls into global block.  If not, this compunit
+     definitely does not contain ADDR.  */
+  if (addr < start || end <= addr)
+    return false;
+
+  /* A compunit may span over multiple disjoint regions (see comment in
+     find_pc_sect_compunit_symtab).  DWARF reader sets address map mapping
+     addresses to blocks.  So if the map is set and there is no block
+     mapped at ADDR, this compunit definitely does not contain ADDR.  */
+  if (map () != nullptr && map ()->find (addr) == nullptr)
+    return false;
+
+  /* Otherwise, this compunit may or may not contain ADDR.  */
+  return true;
+}
+
 /* Implement 'maint info blocks' command.  If passed an argument then
    print a list of all blocks at the given address.  With no arguments
    then list all blocks at the current address of the current inferior.  */
diff --git a/gdb/block.h b/gdb/block.h
index 76fa203697c..4a962eff30e 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -483,6 +483,10 @@ struct blockvector
   void set_map (addrmap_fixed *map)
   { m_map = map; }
 
+  /* True if this blockvector contains block at ADDR, false if
+     it definitely does not.  */
+  bool maybe_contains (CORE_ADDR addr) const;
+
 private:
   /* An address map mapping addresses to blocks in this blockvector.
      This pointer is zero if the blocks' start and end addresses are
diff --git a/gdb/symtab.c b/gdb/symtab.c
index b2de990143d..506e21eeac4 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -529,6 +529,14 @@ compunit_symtab::forget_cached_source_info ()
 
 /* See symtab.h.  */
 
+bool
+compunit_symtab::maybe_contains (CORE_ADDR addr) const
+{
+  return this->blockvector ()->maybe_contains (addr);
+}
+
+/* See symtab.h.  */
+
 void
 compunit_symtab::finalize ()
 {
@@ -2931,23 +2939,13 @@ find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
     {
       for (compunit_symtab *cust : obj_file->compunits ())
 	{
-	  const struct blockvector *bv = cust->blockvector ();
-	  const struct block *global_block = bv->global_block ();
-	  CORE_ADDR start = global_block->start ();
-	  CORE_ADDR end = global_block->end ();
-	  bool in_range_p = start <= pc && pc < end;
-	  if (!in_range_p)
+	  if (!cust->maybe_contains (pc))
 	    continue;
 
-	  if (bv->map () != nullptr)
-	    {
-	      if (bv->map ()->find (pc) == nullptr)
-		continue;
-
-	      return cust;
-	    }
+	  const struct blockvector *bv = cust->blockvector ();
+	  CORE_ADDR range =
+	    bv->global_block ()->end () - bv->global_block ()->start ();
 
-	  CORE_ADDR range = end - start;
 	  if (best_cust != nullptr
 	      && range >= best_cust_range)
 	    /* Cust doesn't have a smaller range than best_cust, skip it.  */
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 0a57be5ed80..7f084cef691 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1963,6 +1963,10 @@ struct compunit_symtab
      compunit_symtab objects are allocated on an obstack.  */
   void finalize ();
 
+  /* True if ADDR may be in this compunit_symtab, false if
+     definitely is not.  */
+  bool maybe_contains (CORE_ADDR addr) const;
+
   /* Unordered chain of all compunit symtabs of this objfile.  */
   struct compunit_symtab *next;
 
-- 
2.47.2