2010-07-13 Emmanuel Thomé <Emmanuel.Thome@gmail.com>

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

diff --git a/gdb/valprint.c b/gdb/valprint.c
index 5659f99245f4ecfaf13f4409c411a1ab8952bb16..ad6268e2c48b90ca4d7ddfadf1b859a7a85ee26c 100644 (file)
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -2,7 +2,7 @@
 
    Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
 
    Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

-   2009 Free Software Foundation, Inc.
+   2009, 2010 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -34,6 +34,8 @@
 #include "doublest.h"
 #include "exceptions.h"
 #include "dfp.h"
 #include "doublest.h"
 #include "exceptions.h"
 #include "dfp.h"

+#include "python/python.h"
+#include "ada-lang.h"

 
 #include <errno.h>
 
 
 #include <errno.h>
 


@@ -80,7 +82,9 @@ struct value_print_options user_print_options =
   0,                           /* print_array_indexes */
   0,                           /* deref_ref */
   1,                           /* static_field_print */
   0,                           /* print_array_indexes */
   0,                           /* deref_ref */
   1,                           /* static_field_print */

-  1                            /* pascal_static_field_print */
+  1,                           /* pascal_static_field_print */
+  0,                           /* raw */
+  0                            /* summary */

 };
 
 /* Initialize *OPTS to be a copy of the user print options.  */
 };
 
 /* Initialize *OPTS to be a copy of the user print options.  */


@@ -214,6 +218,66 @@ show_addressprint (struct ui_file *file, int from_tty,
 }
 \f
 
 }
 \f
 

+/* A helper function for val_print.  When printing in "summary" mode,
+   we want to print scalar arguments, but not aggregate arguments.
+   This function distinguishes between the two.  */
+
+static int
+scalar_type_p (struct type *type)
+{
+  CHECK_TYPEDEF (type);
+  while (TYPE_CODE (type) == TYPE_CODE_REF)
+    {
+      type = TYPE_TARGET_TYPE (type);
+      CHECK_TYPEDEF (type);
+    }
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_SET:
+    case TYPE_CODE_STRING:
+    case TYPE_CODE_BITSTRING:
+      return 0;
+    default:
+      return 1;
+    }
+}
+
+/* Helper function to check the validity of some bits of a value.
+
+   If TYPE represents some aggregate type (e.g., a structure), return 1.
+   
+   Otherwise, any of the bytes starting at OFFSET and extending for
+   TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
+   return 0.  The checking is done using FUNCS.
+   
+   Otherwise, return 1.  */
+
+static int
+valprint_check_validity (struct ui_file *stream,
+                        struct type *type,
+                        int offset,
+                        const struct value *val)
+{
+  CHECK_TYPEDEF (type);
+
+  if (TYPE_CODE (type) != TYPE_CODE_UNION
+      && TYPE_CODE (type) != TYPE_CODE_STRUCT
+      && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+    {
+      if (! value_bits_valid (val, TARGET_CHAR_BIT * offset,
+                             TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+       {
+         fprintf_filtered (stream, _("<value optimized out>"));
+         return 0;
+       }
+    }
+
+  return 1;
+}
+

 /* Print using the given LANGUAGE the data of type TYPE located at VALADDR
    (within GDB), which came from the inferior at address ADDRESS, onto
    stdio stream STREAM according to OPTIONS.
 /* Print using the given LANGUAGE the data of type TYPE located at VALADDR
    (within GDB), which came from the inferior at address ADDRESS, onto
    stdio stream STREAM according to OPTIONS.


@@ -232,6 +296,7 @@ show_addressprint (struct ui_file *file, int from_tty,
 int
 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
           CORE_ADDR address, struct ui_file *stream, int recurse,
 int
 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,

           const struct value_print_options *options,
           const struct language_defn *language)
 {
           const struct value_print_options *options,
           const struct language_defn *language)
 {


@@ -252,15 +317,36 @@ val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 
   if (TYPE_STUB (real_type))
     {
 
   if (TYPE_STUB (real_type))
     {

-      fprintf_filtered (stream, "<incomplete type>");
+      fprintf_filtered (stream, _("<incomplete type>"));

       gdb_flush (stream);
       return (0);
     }
 
       gdb_flush (stream);
       return (0);
     }
 

+  if (!valprint_check_validity (stream, real_type, embedded_offset, val))
+    return 0;
+
+  if (!options->raw)
+    {
+      ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
+                                     address, stream, recurse,
+                                     val, options, language);
+      if (ret)
+       return ret;
+    }
+
+  /* Handle summary mode.  If the value is a scalar, print it;
+     otherwise, print an ellipsis.  */
+  if (options->summary && !scalar_type_p (type))
+    {
+      fprintf_filtered (stream, "...");
+      return 0;
+    }
+

   TRY_CATCH (except, RETURN_MASK_ERROR)
     {
       ret = language->la_val_print (type, valaddr, embedded_offset, address,
   TRY_CATCH (except, RETURN_MASK_ERROR)
     {
       ret = language->la_val_print (type, valaddr, embedded_offset, address,

-                                   stream, recurse, &local_opts);
+                                   stream, recurse, val,
+                                   &local_opts);

     }
   if (except.reason < 0)
     fprintf_filtered (stream, _("<error reading variable>"));
     }
   if (except.reason < 0)
     fprintf_filtered (stream, _("<error reading variable>"));


@@ -281,7 +367,7 @@ value_check_printable (struct value *val, struct ui_file *stream)
       return 0;
     }
 
       return 0;
     }
 

-  if (value_optimized_out (val))
+  if (value_entirely_optimized_out (val))

     {
       fprintf_filtered (stream, _("<value optimized out>"));
       return 0;
     {
       fprintf_filtered (stream, _("<value optimized out>"));
       return 0;


@@ -314,15 +400,24 @@ common_val_print (struct value *val, struct ui_file *stream, int recurse,
   if (!value_check_printable (val, stream))
     return 0;
 
   if (!value_check_printable (val, stream))
     return 0;
 

-  return val_print (value_type (val), value_contents_all (val),
+  if (language->la_language == language_ada)
+    /* The value might have a dynamic type, which would cause trouble
+       below when trying to extract the value contents (since the value
+       size is determined from the type size which is unknown).  So
+       get a fixed representation of our value.  */
+    val = ada_to_fixed_value (val);
+
+  return val_print (value_type (val), value_contents_for_printing (val),

                    value_embedded_offset (val), value_address (val),
                    value_embedded_offset (val), value_address (val),

-                   stream, recurse, options, language);
+                   stream, recurse,
+                   val, options, language);

 }
 
 }
 

-/* Print the value VAL in C-ish syntax on stream STREAM according to
-   OPTIONS.
-   If the object printed is a string pointer, returns
-   the number of string bytes printed.  */
+/* Print on stream STREAM the value VAL according to OPTIONS.  The value
+   is printed using the current_language syntax.
+
+   If the object printed is a string pointer, return the number of string
+   bytes printed.  */

 
 int
 value_print (struct value *val, struct ui_file *stream,
 
 int
 value_print (struct value *val, struct ui_file *stream,


@@ -331,6 +426,19 @@ value_print (struct value *val, struct ui_file *stream,
   if (!value_check_printable (val, stream))
     return 0;
 
   if (!value_check_printable (val, stream))
     return 0;
 

+  if (!options->raw)
+    {
+      int r = apply_val_pretty_printer (value_type (val),
+                                       value_contents_for_printing (val),
+                                       value_embedded_offset (val),
+                                       value_address (val),
+                                       stream, 0,
+                                       val, options, current_language);
+
+      if (r)
+       return r;
+    }
+

   return LA_VALUE_PRINT (val, stream, options);
 }
 
   return LA_VALUE_PRINT (val, stream, options);
 }
 


@@ -342,7 +450,7 @@ void
 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
                         struct ui_file *stream)
 {
 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
                         struct ui_file *stream)
 {

-  enum bfd_endian byte_order = gdbarch_byte_order (current_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));

 
   if (TYPE_LENGTH (type) > sizeof (LONGEST))
     {
 
   if (TYPE_LENGTH (type) > sizeof (LONGEST))
     {


@@ -350,7 +458,7 @@ val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
 
       if (TYPE_UNSIGNED (type)
          && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
 
       if (TYPE_UNSIGNED (type)
          && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),

-                                           &val))
+                                           byte_order, &val))

        {
          print_longest (stream, 'u', 0, val);
        }
        {
          print_longest (stream, 'u', 0, val);
        }


@@ -546,10 +654,11 @@ void
 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
                        struct ui_file *stream)
 {
 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
                        struct ui_file *stream)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));

   char decstr[MAX_DECIMAL_STRING];
   unsigned len = TYPE_LENGTH (type);
 
   char decstr[MAX_DECIMAL_STRING];
   unsigned len = TYPE_LENGTH (type);
 

-  decimal_to_string (valaddr, len, decstr);
+  decimal_to_string (valaddr, len, byte_order, decstr);

   fputs_filtered (decstr, stream);
   return;
 }
   fputs_filtered (decstr, stream);
   return;
 }


@@ -964,44 +1073,27 @@ print_char_chars (struct ui_file *stream, struct type *type,
 
    Return 1 if the operation was successful. Return zero otherwise,
    in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
 
    Return 1 if the operation was successful. Return zero otherwise,
    in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.

-   
-   Computing the array upper and lower bounds is pretty easy, but this
-   function does some additional verifications before returning them.
-   If something incorrect is detected, it is better to return a status
-   rather than throwing an error, making it easier for the caller to
-   implement an error-recovery plan.  For instance, it may decide to
-   warn the user that the bounds were not found and then use some
-   default values instead.  */
+  
+   We now simply use get_discrete_bounds call to get the values
+   of the low and high bounds. 
+   get_discrete_bounds can return three values:
+   1, meaning that index is a range,
+   0, meaning that index is a discrete type,
+   or -1 for failure.  */

 
 int
 
 int

-get_array_bounds (struct type *type, long *low_bound, long *high_bound)
+get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)

 {
   struct type *index = TYPE_INDEX_TYPE (type);
 {
   struct type *index = TYPE_INDEX_TYPE (type);

-  long low = 0;
-  long high = 0;
-                                  
+  LONGEST low = 0;
+  LONGEST high = 0;
+  int res;
+                                

   if (index == NULL)
     return 0;
 
   if (index == NULL)
     return 0;
 

-  if (TYPE_CODE (index) == TYPE_CODE_RANGE)
-    {
-      low = TYPE_LOW_BOUND (index);
-      high = TYPE_HIGH_BOUND (index);
-    }
-  else if (TYPE_CODE (index) == TYPE_CODE_ENUM)
-    {
-      const int n_enums = TYPE_NFIELDS (index);
-
-      low = TYPE_FIELD_BITPOS (index, 0);
-      high = TYPE_FIELD_BITPOS (index, n_enums - 1);
-    }
-  else
-    return 0;
-
-  /* Abort if the lower bound is greater than the higher bound, except
-     when low = high + 1.  This is a very common idiom used in Ada when
-     defining empty ranges (for instance "range 1 .. 0").  */
-  if (low > high + 1)
+  res = get_discrete_bounds (index, &low, &high);
+  if (res == -1)

     return 0;
 
   if (low_bound)
     return 0;
 
   if (low_bound)


@@ -1044,6 +1136,7 @@ void
 val_print_array_elements (struct type *type, const gdb_byte *valaddr,
                          CORE_ADDR address, struct ui_file *stream,
                          int recurse,
 val_print_array_elements (struct type *type, const gdb_byte *valaddr,
                          CORE_ADDR address, struct ui_file *stream,
                          int recurse,

+                         const struct value *val,

                          const struct value_print_options *options,
                          unsigned int i)
 {
                          const struct value_print_options *options,
                          unsigned int i)
 {


@@ -1056,7 +1149,7 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
   unsigned int rep1;
   /* Number of repetitions we have detected so far.  */
   unsigned int reps;
   unsigned int rep1;
   /* Number of repetitions we have detected so far.  */
   unsigned int reps;

-  long low_bound_index = 0;
+  LONGEST low_bound_index = 0;

 
   elttype = TYPE_TARGET_TYPE (type);
   eltlen = TYPE_LENGTH (check_typedef (elttype));
 
   elttype = TYPE_TARGET_TYPE (type);
   eltlen = TYPE_LENGTH (check_typedef (elttype));


@@ -1071,7 +1164,8 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
     len = TYPE_LENGTH (type) / eltlen;
   else
     {
     len = TYPE_LENGTH (type) / eltlen;
   else
     {

-      long low, hi;
+      LONGEST low, hi;
+

       if (get_array_bounds (type, &low, &hi))
         len = hi - low + 1;
       else
       if (get_array_bounds (type, &low, &hi))
         len = hi - low + 1;
       else


@@ -1121,7 +1215,7 @@ 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,
       if (reps > options->repeat_count_threshold)
        {
          val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,

-                    stream, recurse + 1, options, current_language);
+                    stream, recurse + 1, val, options, current_language);

          annotate_elt_rep (reps);
          fprintf_filtered (stream, " <repeats %u times>", reps);
          annotate_elt_rep_end ();
          annotate_elt_rep (reps);
          fprintf_filtered (stream, " <repeats %u times>", reps);
          annotate_elt_rep_end ();


@@ -1132,7 +1226,7 @@ val_print_array_elements (struct type *type, const gdb_byte *valaddr,
       else
        {
          val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
       else
        {
          val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,

-                    stream, recurse + 1, options, current_language);
+                    stream, recurse + 1, val, options, current_language);

          annotate_elt ();
          things_printed++;
        }
          annotate_elt ();
          things_printed++;
        }


@@ -1209,7 +1303,7 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr
 
 int
 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
 
 int
 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,

-            gdb_byte **buffer, int *bytes_read)
+            enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)

 {
   int found_nul;               /* Non-zero if we found the nul char.  */
   int errcode;                 /* Errno returned from bad reads.  */
 {
   int found_nul;               /* Non-zero if we found the nul char.  */
   int errcode;                 /* Errno returned from bad reads.  */


@@ -1281,7 +1375,7 @@ read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
            {
              unsigned long c;
 
            {
              unsigned long c;
 

-             c = extract_unsigned_integer (bufptr, width);
+             c = extract_unsigned_integer (bufptr, width, byte_order);

              addr += width;
              bufptr += width;
              if (c == 0)
              addr += width;
              bufptr += width;
              if (c == 0)


@@ -1334,6 +1428,8 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
   int bytes_read;
   gdb_byte *buffer = NULL;     /* Dynamically growable fetch buffer.  */
   struct cleanup *old_chain = NULL;    /* Top of the old cleanup chain.  */
   int bytes_read;
   gdb_byte *buffer = NULL;     /* Dynamically growable fetch buffer.  */
   struct cleanup *old_chain = NULL;    /* Top of the old cleanup chain.  */

+  struct gdbarch *gdbarch = get_type_arch (elttype);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   int width = TYPE_LENGTH (elttype);
 
   /* First we need to figure out the limit on the number of characters we are
   int width = TYPE_LENGTH (elttype);
 
   /* First we need to figure out the limit on the number of characters we are


@@ -1346,7 +1442,8 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
 
   fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
 
 
   fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
 

-  errcode = read_string (addr, len, width, fetchlimit, &buffer, &bytes_read);
+  errcode = read_string (addr, len, width, fetchlimit, byte_order,
+                        &buffer, &bytes_read);

   old_chain = make_cleanup (xfree, buffer);
 
   addr += bytes_read;
   old_chain = make_cleanup (xfree, buffer);
 
   addr += bytes_read;


@@ -1355,8 +1452,8 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
      terminated early due to an error or finding a null char when LEN is -1.  */
 
   /* Determine found_nul by looking at the last character read.  */
      terminated early due to an error or finding a null char when LEN is -1.  */
 
   /* Determine found_nul by looking at the last character read.  */

-  found_nul = extract_unsigned_integer (buffer + bytes_read - width, width) == 0;
-
+  found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
+                                       byte_order) == 0;

   if (len == -1 && !found_nul)
     {
       gdb_byte *peekbuf;
   if (len == -1 && !found_nul)
     {
       gdb_byte *peekbuf;


@@ -1368,7 +1465,7 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
       peekbuf = (gdb_byte *) alloca (width);
 
       if (target_read_memory (addr, peekbuf, width) == 0
       peekbuf = (gdb_byte *) alloca (width);
 
       if (target_read_memory (addr, peekbuf, width) == 0

-         && extract_unsigned_integer (peekbuf, width) != 0)
+         && extract_unsigned_integer (peekbuf, width, byte_order) != 0)

        force_ellipsis = 1;
     }
   else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
        force_ellipsis = 1;
     }
   else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))


@@ -1388,7 +1485,8 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
        {
          fputs_filtered (" ", stream);
        }
        {
          fputs_filtered (" ", stream);
        }

-      LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width, force_ellipsis, options);
+      LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
+                      NULL, force_ellipsis, options);

     }
 
   if (errcode != 0)
     }
 
   if (errcode != 0)


@@ -1396,13 +1494,13 @@ val_print_string (struct type *elttype, CORE_ADDR addr, int len,
       if (errcode == EIO)
        {
          fprintf_filtered (stream, " <Address ");
       if (errcode == EIO)
        {
          fprintf_filtered (stream, " <Address ");

-         fputs_filtered (paddress (addr), stream);
+         fputs_filtered (paddress (gdbarch, addr), stream);

          fprintf_filtered (stream, " out of bounds>");
        }
       else
        {
          fprintf_filtered (stream, " <Error reading address ");
          fprintf_filtered (stream, " out of bounds>");
        }
       else
        {
          fprintf_filtered (stream, " <Error reading address ");

-         fputs_filtered (paddress (addr), stream);
+         fputs_filtered (paddress (gdbarch, addr), stream);

          fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
        }
     }
          fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
        }
     }


@@ -1558,8 +1656,6 @@ show_print (char *args, int from_tty)
 void
 _initialize_valprint (void)
 {
 void
 _initialize_valprint (void)
 {

-  struct cmd_list_element *c;
-

   add_prefix_cmd ("print", no_class, set_print,
                  _("Generic command for setting how things print."),
                  &setprintlist, "set print ", 0, &setlist);
   add_prefix_cmd ("print", no_class, set_print,
                  _("Generic command for setting how things print."),
                  &setprintlist, "set print ", 0, &setlist);