[RFA] fetch result of locdesc expressions as integer (not address)

[Joel Brobecker <brobecker at adacore dot com>]

This is a problem that showed up on AVR as well. The debugger
crashes while trying to print the contents of any struct value.
I was able to reduce the testcase as follow:

    % cat foo.c
    struct blob
    {
      int a;
      int b;
    };

    struct blob global_blob = {1234, 5678};

    int
    main (void)
    {
      global_blob.a++;  /* Stop here */
      return 0;
    }

To reproduce:

    % gdb foo
    (gdb) target sim
    (gdb) load foo
    (gdb) start
    Starting program: /[...]/foo

    Temporary breakpoint 1, main () at foo.c:13
    13        global_blob.a++;
    (gdb) p global_blob
    [SEGV]

The problem is that the debugger is treating the result of
the DWARF location expressions as addresses, whereas this is
just an offset in this case.  I think that this was an unintentional
side-effect of simplifying the code that fetches the result
from the DWARF expression computation stack. We had a bit of
code that used to fetch it, and turn it into a struct value.
And we replaced it by one call to a function that seemed to
be doing the same: dwarf_expr_fetch_address. The problem is
that dwarf_expr_fetch_address treats the result as an address,
and thus applies the integer_to_address gdbarch method. We do
not want that for struct field offsets...

gdb/ChangeLog:

        * dwarf2read.c (decode_locdesc): Fetch the result of
        the expression evaluation as an integer rather than
        an address.

Tested on x86_64-linux, no regression.
Is that OK?

Thanks,
-- 
Joel

---
 gdb/dwarf2read.c |   14 +++++++++++++-
 1 files changed, 13 insertions(+), 1 deletions(-)

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index fc6a4d5..6f768a4 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -14175,7 +14175,19 @@ decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
       case DWARF_VALUE_MEMORY:
       case DWARF_VALUE_STACK:
 	{
-	  CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
+	  /* Fetch the result of the expression as an integer,
+	     not as an address.  We don't know whether it is an
+	     address or not; for instance, it could be an expression
+	     that returns the offset of a field inside a struct.
+	     If we were to fetch the result as an address, we would
+	     end up applying the integer_to_address gdbarch method.
+	     That would be wrong in the case of an offset.  */
+	  struct value *val = dwarf_expr_fetch (ctx, 0);
+	  enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+	  CORE_ADDR address =
+	    extract_unsigned_integer (value_contents (val),
+				      TYPE_LENGTH (value_type (val)),
+				      byte_order);
 
 	  do_cleanups (old_chain);
 	  return address;
-- 
1.7.1