2011-01-24 Pedro Alves <pedro@codesourcery.com>
authorPedro Alves <palves@redhat.com>
Mon, 24 Jan 2011 18:54:17 +0000 (18:54 +0000)
committerPedro Alves <palves@redhat.com>
Mon, 24 Jan 2011 18:54:17 +0000 (18:54 +0000)
Don't lose embedded_offset in printing routines throughout.

gdb/
* valprint.h (val_print_array_elements): Change prototype.
* valprint.c (val_print_array_elements): Add `embedded_offset'
parameter, and adjust to pass it down to val_print, while passing
`valaddr' or `address' unmodified.  Take embedded_offset into
account when checking repetitions.
* c-valprint.c (c_val_print): Pass embedded_offset to
val_print_array_elements instead of adjusting `valaddr' and
`address'.
* m2-valprint.c (m2_print_array_contents, m2_val_print): Pass
embedded_offset to val_print_array_elements instead of adjusting
`valaddr'.
* p-lang.h (pascal_object_print_value_fields): Adjust prototype.
* p-valprint.c (pascal_val_print): Pass embedded_offset to
val_print_array_elements and pascal_object_print_value_fields
instead of adjusting `valaddr'.
(pascal_object_print_value_fields): Add `offset' parameter, and
adjust to use it.
(pascal_object_print_value): Add `offset' parameter, and adjust to
use it.
(pascal_object_print_static_field): Use
value_contents_for_printing/value_embedded_offset, rather than
value_contents.
* ada-valprint.c (val_print_packed_array_elements): Add `offset'
parameter, and adjust to use it.  Use
value_contents_for_printing/value_embedded_offset, rather than
value_contents.
(ada_val_print): Rename `valaddr0' parameter to `valaddr'.
(ada_val_print_array): Add `offset' parameter, and adjust to use
it.
(ada_val_print_1): Rename `valaddr0' parameter to `valaddr', and
`embedded_offset' to `offset'.  Don't re-adjust `valaddr'.
Instead work with offsets.  Use
value_contents_for_printing/value_embedded_offset, rather than
value_contents.  Change `defer_val_int' local type to CORE_ADDR,
and use value_from_pointer to extract a target pointer, rather
than value_from_longest.
(print_variant_part): Add `offset' parameter.  Replace
`outer_valaddr' parameter by a new `outer_offset' parameter.
Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
(ada_value_print): Use
value_contents_for_printing/value_embedded_offset, rather than
value_contents.
(print_record): Add `offset' parameter, and adjust to pass it
down.
(print_field_values): Add `offset' parameter.  Replace
`outer_valaddr' parameter by a new `outer_offset' parameter.
Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
Use value_contents_for_printing/value_embedded_offset, rather than
value_contents.
* d-valprint.c (dynamic_array_type): Use
value_contents_for_printing/value_embedded_offset, rather than
value_contents.
* jv-valprint.c (java_print_value_fields): Add `offset' parameter.
Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
(java_print_value_fields): Take `offset' into account.  Don't
re-adjust `valaddr'.  Instead pass down adjusted offsets.
(java_val_print): Take `embedded_offset' into account.  Pass it to
java_print_value_fields.
* f-valprint.c (f77_print_array_1): Add `embedded_offset'
parameter.  Don't re-adjust `valaddr' or `address'.  Instead pass
down adjusted offsets.
(f77_print_array): Add `embedded_offset' parameter.  Pass it down.
(f_val_print): Take `embedded_offset' into account.

gdb/testsuite/
* gdb.base/printcmds.c (some_struct): New struct and instance.
* gdb.base/printcmds.exp (test_print_repeats_embedded_array): New
procedure.
<global scope>: Call it.

14 files changed:
gdb/ChangeLog
gdb/ada-valprint.c
gdb/c-valprint.c
gdb/d-valprint.c
gdb/f-valprint.c
gdb/jv-valprint.c
gdb/m2-valprint.c
gdb/p-lang.h
gdb/p-valprint.c
gdb/testsuite/ChangeLog
gdb/testsuite/gdb.base/printcmds.c
gdb/testsuite/gdb.base/printcmds.exp
gdb/valprint.c
gdb/valprint.h

index 0e430d1..68798b6 100644 (file)
@@ -1,3 +1,71 @@
+2011-01-24  Pedro Alves  <pedro@codesourcery.com>
+
+       Don't lose embedded_offset in printing routines throughout.
+
+       * valprint.h (val_print_array_elements): Change prototype.
+       * valprint.c (val_print_array_elements): Add `embedded_offset'
+       parameter, and adjust to pass it down to val_print, while passing
+       `valaddr' or `address' unmodified.  Take embedded_offset into
+       account when checking repetitions.
+       * c-valprint.c (c_val_print): Pass embedded_offset to
+       val_print_array_elements instead of adjusting `valaddr' and
+       `address'.
+       * m2-valprint.c (m2_print_array_contents, m2_val_print): Pass
+       embedded_offset to val_print_array_elements instead of adjusting
+       `valaddr'.
+       * p-lang.h (pascal_object_print_value_fields): Adjust prototype.
+       * p-valprint.c (pascal_val_print): Pass embedded_offset to
+       val_print_array_elements and pascal_object_print_value_fields
+       instead of adjusting `valaddr'.
+       (pascal_object_print_value_fields): Add `offset' parameter, and
+       adjust to use it.
+       (pascal_object_print_value): Add `offset' parameter, and adjust to
+       use it.
+       (pascal_object_print_static_field): Use
+       value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.
+       * ada-valprint.c (val_print_packed_array_elements): Add `offset'
+       parameter, and adjust to use it.  Use
+       value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.
+       (ada_val_print): Rename `valaddr0' parameter to `valaddr'.
+       (ada_val_print_array): Add `offset' parameter, and adjust to use
+       it.
+       (ada_val_print_1): Rename `valaddr0' parameter to `valaddr', and
+       `embedded_offset' to `offset'.  Don't re-adjust `valaddr'.
+       Instead work with offsets.  Use
+       value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.  Change `defer_val_int' local type to CORE_ADDR,
+       and use value_from_pointer to extract a target pointer, rather
+       than value_from_longest.
+       (print_variant_part): Add `offset' parameter.  Replace
+       `outer_valaddr' parameter by a new `outer_offset' parameter.
+       Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
+       (ada_value_print): Use
+       value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.
+       (print_record): Add `offset' parameter, and adjust to pass it
+       down.
+       (print_field_values): Add `offset' parameter.  Replace
+       `outer_valaddr' parameter by a new `outer_offset' parameter.
+       Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
+       Use value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.
+       * d-valprint.c (dynamic_array_type): Use
+       value_contents_for_printing/value_embedded_offset, rather than
+       value_contents.
+       * jv-valprint.c (java_print_value_fields): Add `offset' parameter.
+       Don't re-adjust `valaddr'.  Instead pass down adjusted offsets.
+       (java_print_value_fields): Take `offset' into account.  Don't
+       re-adjust `valaddr'.  Instead pass down adjusted offsets.
+       (java_val_print): Take `embedded_offset' into account.  Pass it to
+       java_print_value_fields.
+       * f-valprint.c (f77_print_array_1): Add `embedded_offset'
+       parameter.  Don't re-adjust `valaddr' or `address'.  Instead pass
+       down adjusted offsets.
+       (f77_print_array): Add `embedded_offset' parameter.  Pass it down.
+       (f_val_print): Take `embedded_offset' into account.
+
 2011-01-21  Joel Brobecker  <brobecker@adacore.com>
 
        * inflow.c: Include "gdbcmd.h".
index c08daeb..2b5aa44 100644 (file)
 #include "exceptions.h"
 #include "objfiles.h"
 
-static void print_record (struct type *, const gdb_byte *, struct ui_file *,
+static void print_record (struct type *, const gdb_byte *, int,
+                         struct ui_file *,
                          int,
                          const struct value *,
                          const struct value_print_options *);
 
 static int print_field_values (struct type *, const gdb_byte *,
+                              int,
                               struct ui_file *, int,
                               const struct value *,
                               const struct value_print_options *,
-                              int, struct type *,
-                              const gdb_byte *);
+                              int, struct type *, int);
 
 static void adjust_type_signedness (struct type *);
 
@@ -134,6 +135,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type,
 
 static void
 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
+                                int offset,
                                 int bitoffset, struct ui_file *stream,
                                 int recurse,
                                 const struct value *val,
@@ -185,7 +187,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
       maybe_print_array_index (index_type, i + low, stream, options);
 
       i0 = i;
-      v0 = ada_value_primitive_packed_val (NULL, valaddr,
+      v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
                                           (i0 * bitsize) / HOST_CHAR_BIT,
                                           (i0 * bitsize) % HOST_CHAR_BIT,
                                           bitsize, elttype);
@@ -194,7 +196,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
          i += 1;
          if (i >= len)
            break;
-         v1 = ada_value_primitive_packed_val (NULL, valaddr,
+         v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
                                               (i * bitsize) / HOST_CHAR_BIT,
                                               (i * bitsize) % HOST_CHAR_BIT,
                                               bitsize, elttype);
@@ -207,7 +209,8 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
          struct value_print_options opts = *options;
 
          opts.deref_ref = 0;
-         val_print (elttype, value_contents (v0), 0, 0, stream,
+         val_print (elttype, value_contents_for_printing (v0),
+                    value_embedded_offset (v0), 0, stream,
                     recurse + 1, val, &opts, current_language);
          annotate_elt_rep (i - i0);
          fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
@@ -237,7 +240,8 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
                  maybe_print_array_index (index_type, j + low,
                                           stream, options);
                }
-             val_print (elttype, value_contents (v0), 0, 0, stream,
+             val_print (elttype, value_contents_for_printing (v0),
+                        value_embedded_offset (v0), 0, stream,
                         recurse + 1, val, &opts, current_language);
              annotate_elt ();
            }
@@ -571,7 +575,7 @@ ada_printstr (struct ui_file *stream, struct type *type,
    continuation lines; this amount is roughly twice the value of RECURSE.  */
 
 int
-ada_val_print (struct type *type, const gdb_byte *valaddr0,
+ada_val_print (struct type *type, const gdb_byte *valaddr,
               int embedded_offset, CORE_ADDR address,
               struct ui_file *stream, int recurse,
               const struct value *val,
@@ -580,9 +584,10 @@ ada_val_print (struct type *type, const gdb_byte *valaddr0,
   volatile struct gdb_exception except;
   int result = 0;
 
+  /* XXX: this catches QUIT/ctrl-c as well.  Isn't that busted?  */
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
-      result = ada_val_print_1 (type, valaddr0, embedded_offset, address,
+      result = ada_val_print_1 (type, valaddr, embedded_offset, address,
                                stream, recurse, val, options);
     }
 
@@ -599,7 +604,8 @@ ada_val_print (struct type *type, const gdb_byte *valaddr0,
 
 static int
 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
-                    CORE_ADDR address, struct ui_file *stream, int recurse,
+                    int offset, CORE_ADDR address,
+                    struct ui_file *stream, int recurse,
                     const struct value *val,
                     const struct value_print_options *options)
 {
@@ -636,12 +642,13 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
           for (temp_len = 0;
                (temp_len < len
                 && temp_len < options->print_max
-                && char_at (valaddr, temp_len, eltlen, byte_order) != 0);
+                && char_at (valaddr + offset,
+                           temp_len, eltlen, byte_order) != 0);
                temp_len += 1);
           len = temp_len;
         }
 
-      printstr (stream, elttype, valaddr, len, 0, eltlen, options);
+      printstr (stream, elttype, valaddr + offset, len, 0, eltlen, options);
       result = len;
     }
   else
@@ -649,11 +656,11 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
       fprintf_filtered (stream, "(");
       print_optional_low_bound (stream, type, options);
       if (TYPE_FIELD_BITSIZE (type, 0) > 0)
-        val_print_packed_array_elements (type, valaddr, 0, stream,
-                                         recurse, val, options);
+        val_print_packed_array_elements (type, valaddr, offset,
+                                        0, stream, recurse, val, options);
       else
-        val_print_array_elements (type, valaddr, address, stream,
-                                  recurse, val, options, 0);
+        val_print_array_elements (type, valaddr, offset, address,
+                                 stream, recurse, val, options, 0);
       fprintf_filtered (stream, ")");
     }
 
@@ -664,8 +671,8 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
    does not catch evaluation errors (leaving that to ada_val_print).  */
 
 static int
-ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
-                int embedded_offset, CORE_ADDR address,
+ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
+                int offset, CORE_ADDR address,
                 struct ui_file *stream, int recurse,
                 const struct value *original_value,
                 const struct value_print_options *options)
@@ -674,7 +681,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
   int i;
   struct type *elttype;
   LONGEST val;
-  const gdb_byte *valaddr = valaddr0 + embedded_offset;
+  int offset_aligned;
 
   type = ada_check_typedef (type);
 
@@ -685,7 +692,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
       struct value *mark = value_mark ();
       struct value *val;
 
-      val = value_from_contents_and_address (type, valaddr, address);
+      val = value_from_contents_and_address (type, valaddr + offset, address);
       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)  /* array access type.  */
        val = ada_coerce_to_simple_array_ptr (val);
       else
@@ -697,32 +704,35 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
          retn = 0;
        }
       else
-       retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
+       retn = ada_val_print_1 (value_type (val),
+                               value_contents_for_printing (val),
+                               value_embedded_offset (val),
                                value_address (val), stream, recurse,
                                NULL, options);
       value_free_to_mark (mark);
       return retn;
     }
 
-  valaddr = ada_aligned_value_addr (type, valaddr);
-  embedded_offset -= valaddr - valaddr0 - embedded_offset;
-  type = printable_val_type (type, valaddr);
+  offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
+  type = printable_val_type (type, valaddr + offset_aligned);
 
   switch (TYPE_CODE (type))
     {
     default:
-      return c_val_print (type, valaddr0, embedded_offset, address, stream,
+      return c_val_print (type, valaddroffset, address, stream,
                          recurse, original_value, options);
 
     case TYPE_CODE_PTR:
       {
-       int ret = c_val_print (type, valaddr0, embedded_offset, address, 
+       int ret = c_val_print (type, valaddr, offset, address,
                               stream, recurse, original_value, options);
 
        if (ada_is_tag_type (type))
          {
-           struct value *val = 
-             value_from_contents_and_address (type, valaddr, address);
+           struct value *val =
+             value_from_contents_and_address (type,
+                                              valaddr + offset_aligned,
+                                              address + offset_aligned);
            const char *name = ada_tag_name (val);
 
            if (name != NULL) 
@@ -736,7 +746,7 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
     case TYPE_CODE_RANGE:
       if (ada_is_fixed_point_type (type))
        {
-         LONGEST v = unpack_long (type, valaddr);
+         LONGEST v = unpack_long (type, valaddr + offset_aligned);
          int len = TYPE_LENGTH (type);
 
          fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
@@ -753,16 +763,18 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
                 its base type.  Perform a conversion, or we will get a
                 nonsense value.  Actually, we could use the same
                 code regardless of lengths; I'm just avoiding a cast.  */
-             struct value *v = value_cast (target_type,
-                                           value_from_contents_and_address
-                                           (type, valaddr, 0));
-
-             return ada_val_print_1 (target_type, value_contents (v), 0, 0,
-                                     stream, recurse + 1, NULL, options);
+             struct value *v1
+               = value_from_contents_and_address (type, valaddr + offset, 0);
+             struct value *v = value_cast (target_type, v1);
+
+             return ada_val_print_1 (target_type,
+                                     value_contents_for_printing (v),
+                                     value_embedded_offset (v), 0,
+                                     stream, recurse + 1, NULL, options);
            }
          else
            return ada_val_print_1 (TYPE_TARGET_TYPE (type),
-                                   valaddr0, embedded_offset,
+                                   valaddroffset,
                                    address, stream, recurse,
                                    original_value, options);
        }
@@ -776,7 +788,8 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
              struct value_print_options opts = *options;
 
              opts.format = format;
-             print_scalar_formatted (valaddr, type, &opts, 0, stream);
+             print_scalar_formatted (valaddr + offset_aligned,
+                                     type, &opts, 0, stream);
            }
           else if (ada_is_system_address_type (type))
             {
@@ -788,7 +801,8 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
 
              struct gdbarch *gdbarch = get_type_arch (type);
              struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
-             CORE_ADDR addr = extract_typed_address (valaddr, ptr_type);
+             CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
+                                                     ptr_type);
 
               fprintf_filtered (stream, "(");
               type_print (type, "", stream, -1);
@@ -797,11 +811,14 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
             }
          else
            {
-             val_print_type_code_int (type, valaddr, stream);
+             val_print_type_code_int (type, valaddr + offset_aligned, stream);
              if (ada_is_character_type (type))
                {
+                 LONGEST c;
+
                  fputs_filtered (" ", stream);
-                 ada_printchar (unpack_long (type, valaddr), type, stream);
+                 c = unpack_long (type, valaddr + offset_aligned);
+                 ada_printchar (c, type, stream);
                }
            }
          return 0;
@@ -810,11 +827,12 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
     case TYPE_CODE_ENUM:
       if (options->format)
        {
-         print_scalar_formatted (valaddr, type, options, 0, stream);
+         print_scalar_formatted (valaddr + offset_aligned,
+                                 type, options, 0, stream);
          break;
        }
       len = TYPE_NFIELDS (type);
-      val = unpack_long (type, valaddr);
+      val = unpack_long (type, valaddr + offset_aligned);
       for (i = 0; i < len; i++)
        {
          QUIT;
@@ -840,17 +858,18 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
 
     case TYPE_CODE_FLAGS:
       if (options->format)
-       print_scalar_formatted (valaddr, type, options, 0, stream);
+       print_scalar_formatted (valaddr + offset_aligned,
+                               type, options, 0, stream);
       else
-       val_print_type_code_flags (type, valaddr, stream);
+       val_print_type_code_flags (type, valaddr + offset_aligned, stream);
       break;
 
     case TYPE_CODE_FLT:
       if (options->format)
-       return c_val_print (type, valaddr0, embedded_offset, address, stream,
+       return c_val_print (type, valaddroffset, address, stream,
                            recurse, original_value, options);
       else
-       ada_print_floating (valaddr0 + embedded_offset, type, stream);
+       ada_print_floating (valaddr + offset, type, stream);
       break;
 
     case TYPE_CODE_UNION:
@@ -862,14 +881,15 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
        }
       else
        {
-         print_record (type, valaddr, stream, recurse, original_value,
-                       options);
+         print_record (type, valaddr, offset_aligned,
+                       stream, recurse, original_value, options);
          return 0;
        }
 
     case TYPE_CODE_ARRAY:
-      return ada_val_print_array (type, valaddr, address, stream,
-                                 recurse, original_value, options);
+      return ada_val_print_array (type, valaddr, offset_aligned,
+                                 address, stream, recurse, original_value,
+                                 options);
 
     case TYPE_CODE_REF:
       /* For references, the debugger is expected to print the value as
@@ -881,17 +901,19 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
       
       if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
         {
-          LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
+          CORE_ADDR deref_val_int
+           = unpack_pointer (type, valaddr + offset_aligned);
 
           if (deref_val_int != 0)
             {
               struct value *deref_val =
-                ada_value_ind (value_from_longest
+                ada_value_ind (value_from_pointer
                                (lookup_pointer_type (elttype),
                                 deref_val_int));
 
               val_print (value_type (deref_val),
-                         value_contents (deref_val), 0,
+                         value_contents_for_printing (deref_val),
+                         value_embedded_offset (deref_val),
                          value_address (deref_val), stream, recurse + 1,
                         original_value, options, current_language);
             }
@@ -908,25 +930,28 @@ ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
 }
 
 static int
-print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
+print_variant_part (struct type *type, int field_num,
+                   const gdb_byte *valaddr, int offset,
                    struct ui_file *stream, int recurse,
                    const struct value *val,
                    const struct value_print_options *options,
                    int comma_needed,
-                   struct type *outer_type, const gdb_byte *outer_valaddr)
+                   struct type *outer_type, int outer_offset)
 {
   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
-  int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
+  int which = ada_which_variant_applies (var_type, outer_type,
+                                        valaddr + outer_offset);
 
   if (which < 0)
     return 0;
   else
     return print_field_values
       (TYPE_FIELD_TYPE (var_type, which),
-       valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
+       valaddr,
+       offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
        + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
        stream, recurse, val, options,
-       comma_needed, outer_type, outer_valaddr);
+       comma_needed, outer_type, outer_offset);
 }
 
 int
@@ -974,12 +999,14 @@ ada_value_print (struct value *val0, struct ui_file *stream,
 
   opts = *options;
   opts.deref_ref = 1;
-  return (val_print (type, value_contents (val), 0, address,
+  return (val_print (type, value_contents_for_printing (val),
+                    value_embedded_offset (val), address,
                     stream, 0, val, &opts, current_language));
 }
 
 static void
 print_record (struct type *type, const gdb_byte *valaddr,
+             int offset,
              struct ui_file *stream, int recurse,
              const struct value *val,
              const struct value_print_options *options)
@@ -988,8 +1015,9 @@ print_record (struct type *type, const gdb_byte *valaddr,
 
   fprintf_filtered (stream, "(");
 
-  if (print_field_values (type, valaddr, stream, recurse, val, options,
-                         0, type, valaddr) != 0 && options->pretty)
+  if (print_field_values (type, valaddr, offset,
+                         stream, recurse, val, options,
+                         0, type, offset) != 0 && options->pretty)
     {
       fprintf_filtered (stream, "\n");
       print_spaces_filtered (2 * recurse, stream);
@@ -1014,11 +1042,11 @@ print_record (struct type *type, const gdb_byte *valaddr,
 
 static int
 print_field_values (struct type *type, const gdb_byte *valaddr,
-                   struct ui_file *stream, int recurse,
+                   int offset, struct ui_file *stream, int recurse,
                    const struct value *val,
                    const struct value_print_options *options,
                    int comma_needed,
-                   struct type *outer_type, const gdb_byte *outer_valaddr)
+                   struct type *outer_type, int outer_offset)
 {
   int i, len;
 
@@ -1033,18 +1061,20 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
        {
          comma_needed =
            print_field_values (TYPE_FIELD_TYPE (type, i),
-                               valaddr
-                               + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
+                               valaddr,
+                               (offset
+                                + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
                                stream, recurse, val, options,
-                               comma_needed, type, valaddr);
+                               comma_needed, type, offset);
          continue;
        }
       else if (ada_is_variant_part (type, i))
        {
          comma_needed =
            print_variant_part (type, i, valaddr,
-                               stream, recurse, val, options, comma_needed,
-                               outer_type, outer_valaddr);
+                               offset, stream, recurse, val,
+                               options, comma_needed,
+                               outer_type, outer_offset);
          continue;
        }
 
@@ -1102,14 +1132,16 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
              struct value_print_options opts;
 
              adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
-             v = ada_value_primitive_packed_val (NULL, valaddr,
-                                                 bit_pos / HOST_CHAR_BIT,
-                                                 bit_pos % HOST_CHAR_BIT,
-                                                 bit_size,
-                                                 TYPE_FIELD_TYPE (type, i));
+             v = ada_value_primitive_packed_val
+                   (NULL, valaddr,
+                    offset + bit_pos / HOST_CHAR_BIT,
+                    bit_pos % HOST_CHAR_BIT,
+                    bit_size, TYPE_FIELD_TYPE (type, i));
              opts = *options;
              opts.deref_ref = 0;
-             val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
+             val_print (TYPE_FIELD_TYPE (type, i),
+                        value_contents_for_printing (v),
+                        value_embedded_offset (v), 0,
                         stream, recurse + 1, v,
                         &opts, current_language);
            }
@@ -1120,8 +1152,10 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
 
          opts.deref_ref = 0;
          ada_val_print (TYPE_FIELD_TYPE (type, i),
-                        valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
-                        0, 0, stream, recurse + 1, val, &opts);
+                        valaddr,
+                        (offset
+                         + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
+                        0, stream, recurse + 1, val, &opts);
        }
       annotate_field_end ();
     }
index c6d3eae..bbe5588 100644 (file)
@@ -233,10 +233,9 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
                {
                  i = 0;
                }
-             val_print_array_elements (type, valaddr + embedded_offset,
-                                       address + embedded_offset,
-                                       stream, recurse,
-                                       original_value, options, i);
+             val_print_array_elements (type, valaddr, embedded_offset,
+                                       address, stream,
+                                       recurse, original_value, options, i);
              fprintf_filtered (stream, "}");
            }
          break;
index 9577a2e..969cfe2 100644 (file)
@@ -45,7 +45,6 @@ dynamic_array_type (struct type *type, const gdb_byte *valaddr,
       struct type *elttype;
       struct type *true_type;
       struct type *ptr_type;
-      const gdb_byte *ptraddr;
       struct value *val;
       int length;
 
@@ -60,10 +59,11 @@ dynamic_array_type (struct type *type, const gdb_byte *valaddr,
 
       true_type = lookup_array_range_type (true_type, 0, length - 1);
       val = value_at (true_type, addr);
-      ptraddr = value_contents (val);
 
-      return d_val_print (true_type, ptraddr, 0, addr, stream, recurse + 1,
-                         NULL, options);
+      return d_val_print (true_type,
+                         value_contents_for_printing (val),
+                         value_embedded_offset (val), addr,
+                         stream, recurse + 1, val, options);
     }
   return -1;
 }
index 4d26ade..94a70a1 100644 (file)
@@ -163,7 +163,8 @@ f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
 
 static void
 f77_print_array_1 (int nss, int ndimensions, struct type *type,
-                  const gdb_byte *valaddr, CORE_ADDR address,
+                  const gdb_byte *valaddr,
+                  int embedded_offset, CORE_ADDR address,
                   struct ui_file *stream, int recurse,
                   const struct value *val,
                   const struct value_print_options *options,
@@ -179,8 +180,9 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,
        {
          fprintf_filtered (stream, "( ");
          f77_print_array_1 (nss + 1, ndimensions, TYPE_TARGET_TYPE (type),
-                            valaddr + i * F77_DIM_OFFSET (nss),
-                            address + i * F77_DIM_OFFSET (nss),
+                            valaddr,
+                            embedded_offset + i * F77_DIM_OFFSET (nss),
+                            address,
                             stream, recurse, val, options, elts);
          fprintf_filtered (stream, ") ");
        }
@@ -193,10 +195,10 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,
           i++, (*elts)++)
        {
          val_print (TYPE_TARGET_TYPE (type),
-                    valaddr + i * F77_DIM_OFFSET (ndimensions),
-                    0,
-                    address + i * F77_DIM_OFFSET (ndimensions),
-                    stream, recurse, val, options, current_language);
+                    valaddr,
+                    embedded_offset + i * F77_DIM_OFFSET (ndimensions),
+                    address, stream, recurse,
+                    val, options, current_language);
 
          if (i != (F77_DIM_SIZE (nss) - 1))
            fprintf_filtered (stream, ", ");
@@ -213,6 +215,7 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,
 
 static void
 f77_print_array (struct type *type, const gdb_byte *valaddr,
+                int embedded_offset,
                 CORE_ADDR address, struct ui_file *stream,
                 int recurse,
                 const struct value *val,
@@ -234,8 +237,8 @@ Type node corrupt! F77 arrays cannot have %d subscripts (%d Max)"),
 
   f77_create_arrayprint_offset_tbl (type, stream);
 
-  f77_print_array_1 (1, ndimensions, type, valaddr, address, stream,
-                    recurse, val, options, &elts);
+  f77_print_array_1 (1, ndimensions, type, valaddr, embedded_offset,
+                    address, stream, recurse, val, options, &elts);
 }
 \f
 
@@ -266,25 +269,27 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
     case TYPE_CODE_STRING:
       f77_get_dynamic_length_of_aggregate (type);
       LA_PRINT_STRING (stream, builtin_type (gdbarch)->builtin_char,
-                      valaddr, TYPE_LENGTH (type), NULL, 0, options);
+                      valaddr + embedded_offset,
+                      TYPE_LENGTH (type), NULL, 0, options);
       break;
 
     case TYPE_CODE_ARRAY:
       fprintf_filtered (stream, "(");
-      f77_print_array (type, valaddr, address, stream,
-                      recurse, original_value, options);
+      f77_print_array (type, valaddr, embedded_offset,
+                      address, stream, recurse, original_value, options);
       fprintf_filtered (stream, ")");
       break;
 
     case TYPE_CODE_PTR:
       if (options->format && options->format != 's')
        {
-         print_scalar_formatted (valaddr, type, options, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, options, 0, stream);
          break;
        }
       else
        {
-         addr = unpack_pointer (type, valaddr);
+         addr = unpack_pointer (type, valaddr + embedded_offset);
          elttype = check_typedef (TYPE_TARGET_TYPE (type));
 
          if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
@@ -347,7 +352,8 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
     case TYPE_CODE_FUNC:
       if (options->format)
        {
-         print_scalar_formatted (valaddr, type, options, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, options, 0, stream);
          break;
        }
       /* FIXME, we should consider, at least for ANSI C language, eliminating
@@ -366,36 +372,41 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 
          opts.format = (options->format ? options->format
                         : options->output_format);
-         print_scalar_formatted (valaddr, type, &opts, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, &opts, 0, stream);
        }
       else
        {
-         val_print_type_code_int (type, valaddr, stream);
+         val_print_type_code_int (type, valaddr + embedded_offset, stream);
          /* C and C++ has no single byte int type, char is used instead.
             Since we don't know whether the value is really intended to
             be used as an integer or a character, print the character
             equivalent as well.  */
          if (TYPE_LENGTH (type) == 1)
            {
+             LONGEST c;
+
              fputs_filtered (" ", stream);
-             LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
-                            type, stream);
+             c = unpack_long (type, valaddr + embedded_offset);
+             LA_PRINT_CHAR ((unsigned char) c, type, stream);
            }
        }
       break;
 
     case TYPE_CODE_FLAGS:
       if (options->format)
-         print_scalar_formatted (valaddr, type, options, 0, stream);
+       print_scalar_formatted (valaddr + embedded_offset,
+                               type, options, 0, stream);
       else
-       val_print_type_code_flags (type, valaddr, stream);
+       val_print_type_code_flags (type, valaddr + embedded_offset, stream);
       break;
 
     case TYPE_CODE_FLT:
       if (options->format)
-       print_scalar_formatted (valaddr, type, options, 0, stream);
+       print_scalar_formatted (valaddr + embedded_offset,
+                               type, options, 0, stream);
       else
-       print_floating (valaddr, type, stream);
+       print_floating (valaddr + embedded_offset, type, stream);
       break;
 
     case TYPE_CODE_VOID:
@@ -418,11 +429,12 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 
          opts.format = (options->format ? options->format
                         : options->output_format);
-         print_scalar_formatted (valaddr, type, &opts, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, &opts, 0, stream);
        }
       else
        {
-         val = extract_unsigned_integer (valaddr,
+         val = extract_unsigned_integer (valaddr + embedded_offset,
                                          TYPE_LENGTH (type), byte_order);
          if (val == 0)
            fprintf_filtered (stream, ".FALSE.");
@@ -433,7 +445,8 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
            {
              /* Bash the type code temporarily.  */
              TYPE_CODE (type) = TYPE_CODE_INT;
-             val_print (type, valaddr, 0, address, stream, recurse,
+             val_print (type, valaddr, embedded_offset,
+                        address, stream, recurse,
                         original_value, options, current_language);
              /* Restore the type code so later uses work as intended.  */
              TYPE_CODE (type) = TYPE_CODE_BOOL;
@@ -444,9 +457,10 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
     case TYPE_CODE_COMPLEX:
       type = TYPE_TARGET_TYPE (type);
       fputs_filtered ("(", stream);
-      print_floating (valaddr, type, stream);
+      print_floating (valaddr + embedded_offset, type, stream);
       fputs_filtered (",", stream);
-      print_floating (valaddr + TYPE_LENGTH (type), type, stream);
+      print_floating (valaddr + embedded_offset + TYPE_LENGTH (type),
+                     type, stream);
       fputs_filtered (")", stream);
       break;
 
@@ -466,8 +480,9 @@ f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
         {
           int offset = TYPE_FIELD_BITPOS (type, index) / 8;
 
-          val_print (TYPE_FIELD_TYPE (type, index), valaddr + offset,
-                    embedded_offset, address, stream, recurse + 1,
+          val_print (TYPE_FIELD_TYPE (type, index), valaddr,
+                    embedded_offset + offset,
+                    address, stream, recurse + 1,
                     original_value, options, current_language);
           if (index != TYPE_NFIELDS (type) - 1)
             fputs_filtered (", ", stream);
index d345685..f948fff 100644 (file)
@@ -259,6 +259,7 @@ java_value_print (struct value *val, struct ui_file *stream,
 
 static void
 java_print_value_fields (struct type *type, const gdb_byte *valaddr,
+                        int offset,
                         CORE_ADDR address, struct ui_file *stream,
                         int recurse,
                         const struct value *val,
@@ -304,11 +305,11 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,
 
          base_valaddr = valaddr;
 
-         java_print_value_fields (baseclass, base_valaddr, address + boffset,
+         java_print_value_fields (baseclass, base_valaddr,
+                                  offset + boffset, address,
                                   stream, recurse + 1, val, options);
          fputs_filtered (", ", stream);
        }
-
     }
 
   if (!len && n_baseclasses == 1)
@@ -412,8 +413,9 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,
                {
                  struct value_print_options opts;
 
-                 v = value_from_longest (TYPE_FIELD_TYPE (type, i),
-                                  unpack_field_as_long (type, valaddr, i));
+                 v = value_from_longest
+                   (TYPE_FIELD_TYPE (type, i),
+                    unpack_field_as_long (type, valaddr + offset, i));
 
                  opts = *options;
                  opts.deref_ref = 0;
@@ -454,9 +456,9 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,
 
                  opts.deref_ref = 0;
                  val_print (TYPE_FIELD_TYPE (type, i),
-                            valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
-                            address + TYPE_FIELD_BITPOS (type, i) / 8,
-                            stream, recurse + 1, val, &opts,
+                            valaddr,
+                            offset + TYPE_FIELD_BITPOS (type, i) / 8,
+                            address, stream, recurse + 1, val, &opts,
                             current_language);
                }
            }
@@ -497,7 +499,8 @@ java_val_print (struct type *type, const gdb_byte *valaddr,
     case TYPE_CODE_PTR:
       if (options->format && options->format != 's')
        {
-         print_scalar_formatted (valaddr, type, options, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, options, 0, stream);
          break;
        }
 #if 0
@@ -507,14 +510,15 @@ java_val_print (struct type *type, const gdb_byte *valaddr,
          /* Print vtable entry - we only get here if we ARE using
             -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.)  */
          /* Extract an address, assume that it is unsigned.  */
-         print_address_demangle (gdbarch,
-                                 extract_unsigned_integer (valaddr,
-                                                           TYPE_LENGTH (type)),
-                                 stream, demangle);
+         print_address_demangle
+           (gdbarch,
+            extract_unsigned_integer (valaddr + embedded_offset,
+                                      TYPE_LENGTH (type)),
+            stream, demangle);
          break;
        }
 #endif
-      addr = unpack_pointer (type, valaddr);
+      addr = unpack_pointer (type, valaddr + embedded_offset);
       if (addr == 0)
        {
          fputs_filtered ("null", stream);
@@ -548,20 +552,22 @@ java_val_print (struct type *type, const gdb_byte *valaddr,
 
          opts.format = (options->format ? options->format
                         : options->output_format);
-         print_scalar_formatted (valaddr, type, &opts, 0, stream);
+         print_scalar_formatted (valaddr + embedded_offset,
+                                 type, &opts, 0, stream);
        }
       else if (TYPE_CODE (type) == TYPE_CODE_CHAR
               || (TYPE_CODE (type) == TYPE_CODE_INT
                   && TYPE_LENGTH (type) == 2
                   && strcmp (TYPE_NAME (type), "char") == 0))
-       LA_PRINT_CHAR ((int) unpack_long (type, valaddr), type, stream);
+       LA_PRINT_CHAR ((int) unpack_long (type, valaddr + embedded_offset),
+                      type, stream);
       else
-       val_print_type_code_int (type, valaddr, stream);
+       val_print_type_code_int (type, valaddr + embedded_offset, stream);
       break;
 
     case TYPE_CODE_STRUCT:
-      java_print_value_fields (type, valaddr, address, stream, recurse,
-                              val, options);
+      java_print_value_fields (type, valaddr, embedded_offset,
+                              address, stream, recurse, val, options);
       break;
 
     default:
index 8980940..0cf9602 100644 (file)
@@ -300,7 +300,7 @@ m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
       else
        {
          fprintf_filtered (stream, "{");
-         val_print_array_elements (type, valaddr + embedded_offset,
+         val_print_array_elements (type, valaddr, embedded_offset,
                                    address, stream, recurse, val,
                                    options, 0);
          fprintf_filtered (stream, "}");
@@ -370,7 +370,7 @@ m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
          else
            {
              fprintf_filtered (stream, "{");
-             val_print_array_elements (type, valaddr + embedded_offset,
+             val_print_array_elements (type, valaddr, embedded_offset,
                                        address, stream,
                                        recurse, original_value,
                                        options, 0);
index eb85d0d..a5ecb37 100644 (file)
@@ -70,6 +70,7 @@ extern void
   pascal_type_print_varspec_prefix (struct type *, struct ui_file *, int, int);
 
 extern void pascal_object_print_value_fields (struct type *, const gdb_byte *,
+                                             int,
                                              CORE_ADDR, struct ui_file *,
                                              int,
                                              const struct value *,
index e993c05..34decb9 100644 (file)
@@ -125,7 +125,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
                {
                  i = 0;
                }
-             val_print_array_elements (type, valaddr + embedded_offset,
+             val_print_array_elements (type, valaddr, embedded_offset,
                                        address, stream, recurse,
                                        original_value, options, i);
              fprintf_filtered (stream, "}");
@@ -327,7 +327,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
                               len, NULL, 0, options);
            }
          else
-           pascal_object_print_value_fields (type, valaddr + embedded_offset,
+           pascal_object_print_value_fields (type, valaddr, embedded_offset,
                                              address, stream, recurse,
                                              original_value, options,
                                              NULL, 0);
@@ -629,6 +629,7 @@ static void pascal_object_print_static_field (struct value *,
                                              const struct value_print_options *);
 
 static void pascal_object_print_value (struct type *, const gdb_byte *,
+                                      int,
                                       CORE_ADDR, struct ui_file *, int,
                                       const struct value *,
                                       const struct value_print_options *,
@@ -687,6 +688,7 @@ pascal_object_is_vtbl_member (struct type *type)
 
 void
 pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
+                                 int offset,
                                  CORE_ADDR address, struct ui_file *stream,
                                  int recurse,
                                  const struct value *val,
@@ -706,8 +708,9 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
   /* Print out baseclasses such that we don't print
      duplicates of virtual baseclasses.  */
   if (n_baseclasses > 0)
-    pascal_object_print_value (type, valaddr, address, stream,
-                              recurse + 1, val, options, dont_print_vb);
+    pascal_object_print_value (type, valaddr, offset, address,
+                              stream, recurse + 1, val,
+                              options, dont_print_vb);
 
   if (!len && n_baseclasses == 1)
     fprintf_filtered (stream, "<No data fields>");
@@ -814,7 +817,8 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
                  struct value_print_options opts = *options;
 
                  v = value_from_longest (TYPE_FIELD_TYPE (type, i),
-                                  unpack_field_as_long (type, valaddr, i));
+                                  unpack_field_as_long (type,
+                                                        valaddr + offset, i));
 
                  opts.deref_ref = 0;
                  common_val_print (v, stream, recurse + 1, &opts,
@@ -833,8 +837,9 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
                     v4.17 specific.  */
                  struct value *v;
 
-                 v = value_from_longest (TYPE_FIELD_TYPE (type, i),
-                                  unpack_field_as_long (type, valaddr, i));
+                 v = value_from_longest
+                   (TYPE_FIELD_TYPE (type, i),
+                    unpack_field_as_long (type, valaddr + offset, i));
 
                  if (v == NULL)
                    fputs_filtered ("<optimized out>", stream);
@@ -852,9 +857,8 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
                     address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
                     stream, format, 0, recurse + 1, pretty); */
                  val_print (TYPE_FIELD_TYPE (type, i),
-                            valaddr, TYPE_FIELD_BITPOS (type, i) / 8,
-                            address + TYPE_FIELD_BITPOS (type, i) / 8,
-                            stream, recurse + 1, val, &opts,
+                            valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
+                            address, stream, recurse + 1, val, &opts,
                             current_language);
                }
            }
@@ -883,6 +887,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
 
 static void
 pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
+                          int offset,
                           CORE_ADDR address, struct ui_file *stream,
                           int recurse,
                           const struct value *val,
@@ -909,6 +914,7 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
       char *basename = type_name_no_tag (baseclass);
       const gdb_byte *base_valaddr;
+      int thisoffset;
 
       if (BASETYPE_VIA_VIRTUAL (type, i))
        {
@@ -925,7 +931,9 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
          obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
        }
 
-      boffset = baseclass_offset (type, i, valaddr, address);
+      thisoffset = offset;
+
+      boffset = baseclass_offset (type, i, valaddr + offset, address + offset);
 
       if (options->pretty)
        {
@@ -952,16 +960,19 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
          if (target_read_memory (address + boffset, buf,
                                  TYPE_LENGTH (baseclass)) != 0)
            boffset = -1;
+         address = address + boffset;
+         thisoffset = 0;
+         boffset = 0;
        }
       else
-       base_valaddr = valaddr + boffset;
+       base_valaddr = valaddr;
 
       if (boffset == -1)
        fprintf_filtered (stream, "<invalid address>");
       else
        pascal_object_print_value_fields (baseclass, base_valaddr,
-                                         address + boffset, stream,
-                                         recurse, val, options,
+                                         thisoffset + boffset, address,
+                                         stream, recurse, val, options,
                     (struct type **) obstack_base (&dont_print_vb_obstack),
                                          0);
       fputs_filtered (", ", stream);
@@ -1025,9 +1036,12 @@ pascal_object_print_static_field (struct value *val,
                    sizeof (CORE_ADDR));
 
       CHECK_TYPEDEF (type);
-      pascal_object_print_value_fields (type, value_contents (val), addr,
-                                       stream, recurse, NULL, options,
-                                       NULL, 1);
+      pascal_object_print_value_fields (type,
+                                       value_contents_for_printing (val),
+                                       value_embedded_offset (val),
+                                       addr,
+                                       stream, recurse,
+                                       val, options, NULL, 1);
       return;
     }
 
index 9edc9d6..6a0259e 100644 (file)
@@ -1,3 +1,10 @@
+2011-01-24  Pedro Alves  <pedro@codesourcery.com>
+
+       * gdb.base/printcmds.c (some_struct): New struct and instance.
+       * gdb.base/printcmds.exp (test_print_repeats_embedded_array): New
+       procedure.
+       <global scope>: Call it.
+
 2011-01-21  Ken Werner  <ken.werner@de.ibm.com>
 
        * lib/opencl.exp (skip_opencl_tests): Add missing compile_flags
index 2d6668a..b3841ae 100644 (file)
@@ -96,6 +96,28 @@ enum some_volatile_enum { enumvolval1, enumvolval2 };
    name.  See PR11827.  */
 volatile enum some_volatile_enum some_volatile_enum = enumvolval1;
 
+/* A structure with an embedded array at an offset > 0.  The array has
+   all elements with the same repeating value, which must not be the
+   same as the value of the preceding fields in the structure for the
+   test to be effective.  This tests whether GDB uses the correct
+   element content offsets (relative to the complete `some_struct'
+   value) when counting value repetitions.  */
+struct some_struct
+{
+  int a;
+  int b;
+  unsigned char array[20];
+} some_struct = {
+  0x12345678,
+  0x87654321,
+  {
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa
+  }
+};
+
 /* -- */
 
 int main ()
index d3ea9a5..89705ee 100644 (file)
@@ -474,6 +474,18 @@ proc test_print_repeats_10 {} {
     }
 }
 
+# This tests whether GDB uses the correct element content offsets
+# (relative to the complete `some_struct' value) when counting value
+# repetitions.
+
+proc test_print_repeats_embedded_array {} {
+    global gdb_prompt
+
+    gdb_test_escape_braces "p/x some_struct" \
+       "= {a = 0x12345678, b = 0x87654321, array = {0xaa <repeats 20 times>}}" \
+       "correct element repeats in array embedded at offset > 0"
+}
+
 proc test_print_strings {} {
     global gdb_prompt
 
@@ -818,6 +830,7 @@ test_float_rejected
 test_character_literals_accepted
 test_print_all_chars
 test_print_repeats_10
+test_print_repeats_embedded_array
 test_print_strings
 test_print_int_arrays
 test_print_typedef_arrays
index f65fe27..c98e315 100644 (file)
@@ -1108,7 +1108,8 @@ maybe_print_array_index (struct type *index_type, LONGEST index,
    perhaps we should try to use that notation when appropriate.  */
 
 void
-val_print_array_elements (struct type *type, const gdb_byte *valaddr,
+val_print_array_elements (struct type *type,
+                         const gdb_byte *valaddr, int embedded_offset,
                          CORE_ADDR address, struct ui_file *stream,
                          int recurse,
                          const struct value *val,
@@ -1171,8 +1172,10 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
 
       rep1 = i + 1;
       reps = 1;
-      while ((rep1 < len) &&
-            !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
+      while (rep1 < len
+            && memcmp (valaddr + embedded_offset + i * eltlen,
+                       valaddr + embedded_offset + rep1 * eltlen,
+                       eltlen) == 0)
        {
          ++reps;
          ++rep1;
@@ -1180,8 +1183,9 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
 
       if (reps > options->repeat_count_threshold)
        {
-         val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
-                    stream, recurse + 1, val, options, current_language);
+         val_print (elttype, valaddr, embedded_offset + i * eltlen,
+                    address, stream, recurse + 1, val, options,
+                    current_language);
          annotate_elt_rep (reps);
          fprintf_filtered (stream, " <repeats %u times>", reps);
          annotate_elt_rep_end ();
@@ -1191,7 +1195,8 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
        }
       else
        {
-         val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
+         val_print (elttype, valaddr, embedded_offset + i * eltlen,
+                    address,
                     stream, recurse + 1, val, options, current_language);
          annotate_elt ();
          things_printed++;
index 3764aca..94feb06 100644 (file)
@@ -113,7 +113,7 @@ extern void maybe_print_array_index (struct type *index_type, LONGEST index,
                                      struct ui_file *stream,
                                     const struct value_print_options *);
 
-extern void val_print_array_elements (struct type *, const gdb_byte *,
+extern void val_print_array_elements (struct type *, const gdb_byte *, int,
                                      CORE_ADDR, struct ui_file *, int,
                                      const struct value *,
                                      const struct value_print_options *,