[PATCHv3 6/7] gdb: record block end addresses while parsing DIEs

[Andrew Burgess <aburgess@redhat.com>]

Continuing to work towards the goal of improving GDB's ability to
debug optimised code,  this commit stores a map from the end address
of a block (or a block's sub-range) to the block pointer.  This
information is collected while parsing the DIEs.

This new map is required as a consequence of the previous commit.  The
optimised code fix ups require that we can map from an address back to
a block, something that the address map was perfect for, but the
previous commit deferred building the address map until later on.

The problem is that the optimised code fixes in the next commit
require the address to block map, but also adjust block ranges, which
invalidates the address to block map.  We could try to build the full
address to block early on, and then update it as the optimised code
fixes are performed, but this is expensive.

The solution I propose is to build a light weight, partial map, that
only holds the interesting (inline) blocks.  This partial map is only
needed between reading the DIE and applying the optimised code fixes,
after which it is done with, and as a consequence we don't need to
update this map as the optimised code fixes adjust block ranges, this
makes the partial map cheaper.

This commit is all about building the new partial map.  Currently,
nothing is done with this information; the information is recorded as
the block ranges are parsed, and then discarded after the line table
has been built.  But in the next commit, this will be used to help
adjust the ranges of some inline blocks, and this will improve GDB's
ability to debug optimised code.

There should be no user visible changes after this commit.
---
 gdb/dwarf2/cu.h   | 7 +++++++
 gdb/dwarf2/read.c | 8 ++++++++
 2 files changed, 15 insertions(+)

diff --git a/gdb/dwarf2/cu.h b/gdb/dwarf2/cu.h
index 68010a060cc..6d16dd1512e 100644
--- a/gdb/dwarf2/cu.h
+++ b/gdb/dwarf2/cu.h
@@ -274,6 +274,13 @@ struct dwarf2_cu
     return m_producer;
   }
 
+  /* The end addresses for some inline blocks.  For blocks with multiple
+     sub-ranges, this is the end address of every sub-range within the
+     block.  These are the inclusive end addresses, that is, these are the
+     last addresses inside the block's ranges.  Only the first block that
+     ends at any given address will be recorded.  */
+  gdb::unordered_map<unrelocated_addr, struct block *> inline_block_ends;
+
 private:
   const char *m_producer = nullptr;
 
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 023cb07edd8..fe8b202c6b2 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -6153,6 +6153,10 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
       && cu->line_header != nullptr)
     dwarf_decode_lines (cu, unrel_low);
 
+  /* We no longer need to track the inline block end addresses.  Release
+     memory associated with this.  */
+  cu->inline_block_ends.clear ();
+
   /* Decode macro information, if present.  Dwarf 2 macro information
      refers to information in the line number info statement program
      header, so we can only read it if we've read the header
@@ -9952,6 +9956,10 @@ dwarf2_record_single_block_range (struct dwarf2_cu *cu, struct block *block,
 				  CORE_ADDR low, CORE_ADDR high,
 				  unrelocated_addr unrel_high)
 {
+  /* If this is the end of an inline block, then record its end address.  */
+  if (block->inlined_p () && block->function () != nullptr)
+    cu->inline_block_ends.insert ({unrel_high, block});
+
   cu->get_builder ()->record_block_range (block, low, high);
 }
 
-- 
2.47.1