[PATCH v2 4/7] gdb: update blockvector::lookup to handle non-contiguous blocks

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

This commit updates blockvector::lookup to handle non-contiguous without
help of addrmap. It introduces a new method, block::contains(CORE_ADDR),
to check whether given block contains given address. This new method is
then used in blockvector::lookup instead of simply using block's
start and end addresses.

For this to work, it is essential that blocks' start address is the same
as start address of lowest range and similarly blocks' end address same
as end address of highest range.  Therefore this commit also adds assert
to DWARF reader to ensure that.

A unit test for non-contiguous blocks will come later in this series.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=33829
---
 gdb/block.c       | 24 +++++++++++++++++++++++-
 gdb/block.h       |  4 ++++
 gdb/dwarf2/read.c | 10 ++++++++++
 3 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/gdb/block.c b/gdb/block.c
index 730e4580a5b..b964674865b 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -85,6 +85,25 @@ block::contains (const struct block *a, bool allow_nested) const
 
 /* See block.h.  */
 
+bool
+block::contains (const CORE_ADDR addr) const
+{
+  if (addr >= start () && addr < end ())
+    {
+      if (is_contiguous ())
+	return true;
+
+      for (auto range : ranges ())
+	{
+	  if (range.start () <= addr && addr < range.end ())
+	    return true;
+	}
+    }
+  return false;
+}
+
+/* See block.h.  */
+
 struct symbol *
 block::linkage_function () const
 {
@@ -857,7 +876,10 @@ blockvector::lookup (CORE_ADDR addr) const
       if (b->start () > addr)
 	return nullptr;
       if (b->end () > addr)
-	return b;
+	{
+	  if (b->contains (addr))
+	    return b;
+	}
       bot--;
     }
 
diff --git a/gdb/block.h b/gdb/block.h
index b84ca12c35a..59cabbd620d 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -315,6 +315,10 @@ struct block : public allocate_on_obstack<block>
 
   bool contains (const struct block *a, bool allow_nested = false) const;
 
+  /* Return true if block contains address ADDR.  Return false otherwise.  */
+
+  bool contains (const CORE_ADDR addr) const;
+
   /* Relocate this block and all contained blocks.  OBJFILE is the
      objfile holding this block, and OFFSETS is the relocation offsets
      to use.  */
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 7c6f54449ba..c9b6bebdb86 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -9410,6 +9410,9 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block,
 	  if (die->tag != DW_TAG_compile_unit)
 	    ranges_offset += cu->gnu_ranges_base;
 
+	  CORE_ADDR lo = std::numeric_limits<CORE_ADDR>::max ();
+	  CORE_ADDR hi = std::numeric_limits<CORE_ADDR>::min ();
+
 	  std::vector<blockrange> blockvec;
 	  dwarf2_ranges_process (ranges_offset, cu, die->tag,
 				 [&] (unrelocated_addr start,
@@ -9417,10 +9420,17 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block,
 	  {
 	    CORE_ADDR abs_start = per_objfile->relocate (start);
 	    CORE_ADDR abs_end = per_objfile->relocate (end);
+
+	    lo = std::min (lo, abs_start);
+	    hi = std::max (hi, abs_end);
+
 	    dwarf2_maybe_record_inline_function (cu, block, end);
 	    blockvec.emplace_back (abs_start, abs_end);
 	  });
 
+	  gdb_assert (blockvec.size () == 0 || block->start () == lo);
+	  gdb_assert (blockvec.size () == 0 || block->end () == hi);
+
 	  block->set_ranges (make_blockranges (objfile, blockvec));
 	}
     }
-- 
2.51.0