2011-01-24 Pedro Alves <pedro@codesourcery.com>

[deliverable/binutils-gdb.git] / gdb / f-valprint.c

diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 4d26ade8c6e78256319a25d8f26c17fd793ad39c..94a70a15e0dadb32d42f67cf68c94f17194d9e38 100644 (file)
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -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);