[binutils-gdb] (Ada) change tagged types base_address computation

[Joel Brobecker <brobecke at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=08f49010a10b1fc98f65aada96e788c87c56ad85

commit 08f49010a10b1fc98f65aada96e788c87c56ad85
Author: Xavier Roirand <roirand@adacore.com>
Date:   Mon Dec 11 00:22:14 2017 -0500

    (Ada) change tagged types base_address computation
    
    There was a difference between C++ dispatch table and Ada's in the
    way the Offset_To_Top field is used to determined the base address
    of an object:
    
    * in C++ it is a negative offset, so converting abstract interface to
    deriving object requires adding this offset to â??thisâ??;
    
    * in Ada, it was a positive offset, so the same conversion required
    subtracting the offset value.
    
    So in ada, the base address for a tagged type was computed using this formula:
    
    base_address = value_address (obj) - offset_to_top;
    
    The offset_to_top value was previously set to 0 or a positive value.
    With recent version of AdaCore's GNAT compiler, the offset has been
    changed to match C++, which means it's set to zero or a negative value
    
    As a result, the new formula has to be:
    
    base_address = value_address (obj) + offset_to_top;
    
    Because we want to support old code compiled before GNAT compiler change
    done in 19.0w (20171023-64) with this version and future versions of gdb,
    then we change the sign of the offset_to_top if required. Required here
    means if offset_to_top is positive since it indicates that the code has
    been compiled with an old GNAT compiler.
    
    This patch changes the formula as described above.
    
    Also, one side-effect of offset_to_top now being negative is that
    we now have to worry about the sign when we read its value from the
    inferior. Up to now, we have been reading its value using the data
    address builtin type. But since addresses are not always signed, we
    now need to make sure we use the proper type (type Storage_Offset
    from System.Storage_Elements). Ideally, we would be looking this type
    up from the inferior, and then use that type. However, it is not
    guaranteed that this type always be described in the debugging
    information, so this patch just builds our own, adding it to Ada's
    list of primitive types.
    
    gdb/ChangeLog:
    
            * ada-lang.c (ada_tag_value_at_base_address): Change the way
            tagged type base address is computed.
            (enum ada_primitive_types) <ada_primitive_type_storage_offset>:
            New enumerate.
            (ada_language_arch_info): Set the ada_primitive_type_storage_offset
            element of lai->primitive_type_vector.
    
    Tested on x86_64-linux. Fixes the following tests when using the newer
    version of the compiler.
    
        gdb.ada/iwide.exp: print My_Drawable
        gdb.ada/iwide.exp: print d_access.all
        gdb.ada/iwide.exp: print dp_access.all
        gdb.ada/mi_interface.exp: create ggg1 varobj (unexpected output)
        gdb.ada/mi_interface.exp: list ggg1's children (unexpected output)
        gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:63 (set breakpoint) (unexpected output)
        gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:63 (set breakpoint)

Diff:
---
 gdb/ChangeLog  | 10 ++++++++++
 gdb/ada-lang.c | 29 +++++++++++++++++++++++++++--
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 1d38113..1c67e41 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+2017-12-11  Xavier Roirand <roirand@adacore.com>
+	    Joel Brobecker  <brobecker@adacore.com>
+
+	* ada-lang.c (ada_tag_value_at_base_address): Change the way
+	tagged type base address is computed.
+	(enum ada_primitive_types) <ada_primitive_type_storage_offset>:
+	New enumerate.
+	(ada_language_arch_info): Set the ada_primitive_type_storage_offset
+	element of lai->primitive_type_vector.
+
 2017-12-08  Pedro Alves  <palves@redhat.com>
 
 	* dwarf2read.c (mock_mapped_index): Reimplement as an extension of
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index d6f7ef4..9e637eb 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -6761,7 +6761,8 @@ ada_tag_value_at_base_address (struct value *obj)
   if (is_ada95_tag (tag))
     return obj;
 
-  ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
+  ptr_type = language_lookup_primitive_type
+    (language_def (language_ada), target_gdbarch(), "storage_offset");
   ptr_type = lookup_pointer_type (ptr_type);
   val = value_cast (ptr_type, tag);
   if (!val)
@@ -6795,7 +6796,18 @@ ada_tag_value_at_base_address (struct value *obj)
   if (offset_to_top == -1)
     return obj;
 
-  base_address = value_address (obj) - offset_to_top;
+  /* OFFSET_TO_TOP used to be a positive value to be subtracted
+     from the base address.  This was however incompatible with
+     C++ dispatch table: C++ uses a *negative* value to *add*
+     to the base address.  Ada's convention has therefore been
+     changed in GNAT 19.0w 20171023: since then, C++ and Ada
+     use the same convention.  Here, we support both cases by
+     checking the sign of OFFSET_TO_TOP.  */
+
+  if (offset_to_top > 0)
+    offset_to_top = -offset_to_top;
+
+  base_address = value_address (obj) + offset_to_top;
   tag = value_tag_from_contents_and_address (obj_type, NULL, base_address);
 
   /* Make sure that we have a proper tag at the new address.
@@ -13866,6 +13878,7 @@ enum ada_primitive_types {
   ada_primitive_type_natural,
   ada_primitive_type_positive,
   ada_primitive_type_system_address,
+  ada_primitive_type_storage_offset,
   nr_ada_primitive_types
 };
 
@@ -13918,6 +13931,18 @@ ada_language_arch_info (struct gdbarch *gdbarch,
   TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address])
     = "system__address";
 
+  /* Create the equivalent of the System.Storage_Elements.Storage_Offset
+     type.  This is a signed integral type whose size is the same as
+     the size of addresses.  */
+  {
+    unsigned int addr_length = TYPE_LENGTH
+      (lai->primitive_type_vector [ada_primitive_type_system_address]);
+
+    lai->primitive_type_vector [ada_primitive_type_storage_offset]
+      = arch_integer_type (gdbarch, addr_length * HOST_CHAR_BIT, 0,
+			   "storage_offset");
+  }
+
   lai->bool_type_symbol = NULL;
   lai->bool_type_default = builtin->builtin_bool;
 }