gdb/jv-valprint.c

   1 /* Support for printing Java values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007,
   4    2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "gdbcore.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "demangle.h"
  28 #include "valprint.h"
  29 #include "language.h"
  30 #include "jv-lang.h"
  31 #include "c-lang.h"
  32 #include "annotate.h"
  33 #include "gdb_string.h"
  34
  35 /* Local functions */
  36
  37 int
  38 java_value_print (struct value *val, struct ui_file *stream,
  39                   const struct value_print_options *options)
  40 {
  41   struct gdbarch *gdbarch = get_type_arch (value_type (val));
  42   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  43   struct type *type;
  44   CORE_ADDR address;
  45   int i;
  46   char *name;
  47   struct value_print_options opts;
  48
  49   type = value_type (val);
  50   address = value_address (val);
  51
  52   if (is_object_type (type))
  53     {
  54       CORE_ADDR obj_addr;
  55
  56       /* Get the run-time type, and cast the object into that */
  57
  58       obj_addr = unpack_pointer (type, value_contents (val));
  59
  60       if (obj_addr != 0)
  61         {
  62           type = type_from_class (gdbarch, java_class_from_object (val));
  63           type = lookup_pointer_type (type);
  64
  65           val = value_at (type, address);
  66         }
  67     }
  68
  69   if (TYPE_CODE (type) == TYPE_CODE_PTR && !value_logical_not (val))
  70     type_print (TYPE_TARGET_TYPE (type), "", stream, -1);
  71
  72   name = TYPE_TAG_NAME (type);
  73   if (TYPE_CODE (type) == TYPE_CODE_STRUCT && name != NULL
  74       && (i = strlen (name), name[i - 1] == ']'))
  75     {
  76       gdb_byte buf4[4];
  77       long length;
  78       unsigned int things_printed = 0;
  79       int reps;
  80       struct type *el_type
  81         = java_primitive_type_from_name (gdbarch, name, i - 2);
  82
  83       i = 0;
  84       read_memory (address + get_java_object_header_size (gdbarch), buf4, 4);
  85
  86       length = (long) extract_signed_integer (buf4, 4, byte_order);
  87       fprintf_filtered (stream, "{length: %ld", length);
  88
  89       if (el_type == NULL)
  90         {
  91           CORE_ADDR element;
  92           CORE_ADDR next_element = -1; /* dummy initial value */
  93
  94           /* Skip object header and length. */
  95           address += get_java_object_header_size (gdbarch) + 4;
  96
  97           while (i < length && things_printed < options->print_max)
  98             {
  99               gdb_byte *buf;
 100
 101               buf = alloca (gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT);
 102               fputs_filtered (", ", stream);
 103               wrap_here (n_spaces (2));
 104
 105               if (i > 0)
 106                 element = next_element;
 107               else
 108                 {
 109                   read_memory (address, buf, sizeof (buf));
 110                   address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT;
 111                   /* FIXME: cagney/2003-05-24: Bogus or what.  It
 112                      pulls a host sized pointer out of the target and
 113                      then extracts that as an address (while assuming
 114                      that the address is unsigned)!  */
 115                   element = extract_unsigned_integer (buf, sizeof (buf),
 116                                                       byte_order);
 117                 }
 118
 119               for (reps = 1; i + reps < length; reps++)
 120                 {
 121                   read_memory (address, buf, sizeof (buf));
 122                   address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT;
 123                   /* FIXME: cagney/2003-05-24: Bogus or what.  It
 124                      pulls a host sized pointer out of the target and
 125                      then extracts that as an address (while assuming
 126                      that the address is unsigned)!  */
 127                   next_element = extract_unsigned_integer (buf, sizeof (buf),
 128                                                            byte_order);
 129                   if (next_element != element)
 130                     break;
 131                 }
 132
 133               if (reps == 1)
 134                 fprintf_filtered (stream, "%d: ", i);
 135               else
 136                 fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
 137
 138               if (element == 0)
 139                 fprintf_filtered (stream, "null");
 140               else
 141                 fprintf_filtered (stream, "@%s", paddress (gdbarch, element));
 142
 143               things_printed++;
 144               i += reps;
 145             }
 146         }
 147       else
 148         {
 149           struct value *v = allocate_value (el_type);
 150           struct value *next_v = allocate_value (el_type);
 151
 152           set_value_address (v, (address
 153                                  + get_java_object_header_size (gdbarch) + 4));
 154           set_value_address (next_v, value_raw_address (v));
 155
 156           while (i < length && things_printed < options->print_max)
 157             {
 158               fputs_filtered (", ", stream);
 159               wrap_here (n_spaces (2));
 160
 161               if (i > 0)
 162                 {
 163                   struct value *tmp;
 164
 165                   tmp = next_v;
 166                   next_v = v;
 167                   v = tmp;
 168                 }
 169               else
 170                 {
 171                   set_value_lazy (v, 1);
 172                   set_value_offset (v, 0);
 173                 }
 174
 175               set_value_offset (next_v, value_offset (v));
 176
 177               for (reps = 1; i + reps < length; reps++)
 178                 {
 179                   set_value_lazy (next_v, 1);
 180                   set_value_offset (next_v, value_offset (next_v) + TYPE_LENGTH (el_type));
 181                   if (memcmp (value_contents (v), value_contents (next_v),
 182                               TYPE_LENGTH (el_type)) != 0)
 183                     break;
 184                 }
 185
 186               if (reps == 1)
 187                 fprintf_filtered (stream, "%d: ", i);
 188               else
 189                 fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
 190
 191               opts = *options;
 192               opts.deref_ref = 1;
 193               common_val_print (v, stream, 1, &opts, current_language);
 194
 195               things_printed++;
 196               i += reps;
 197             }
 198         }
 199
 200       if (i < length)
 201         fprintf_filtered (stream, "...");
 202
 203       fprintf_filtered (stream, "}");
 204
 205       return 0;
 206     }
 207
 208   /* If it's type String, print it */
 209
 210   if (TYPE_CODE (type) == TYPE_CODE_PTR
 211       && TYPE_TARGET_TYPE (type)
 212       && TYPE_TAG_NAME (TYPE_TARGET_TYPE (type))
 213       && strcmp (TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)),
 214                  "java.lang.String") == 0
 215       && (options->format == 0 || options->format == 's')
 216       && address != 0
 217       && value_as_address (val) != 0)
 218     {
 219       struct type *char_type;
 220       struct value *data_val;
 221       CORE_ADDR data;
 222       struct value *boffset_val;
 223       unsigned long boffset;
 224       struct value *count_val;
 225       unsigned long count;
 226       struct value *mark;
 227
 228       mark = value_mark ();     /* Remember start of new values */
 229
 230       data_val = value_struct_elt (&val, NULL, "data", NULL, NULL);
 231       data = value_as_address (data_val);
 232
 233       boffset_val = value_struct_elt (&val, NULL, "boffset", NULL, NULL);
 234       boffset = value_as_address (boffset_val);
 235
 236       count_val = value_struct_elt (&val, NULL, "count", NULL, NULL);
 237       count = value_as_address (count_val);
 238
 239       value_free_to_mark (mark);        /* Release unnecessary values */
 240
 241       char_type = builtin_java_type (gdbarch)->builtin_char;
 242       val_print_string (char_type, NULL, data + boffset, count, stream,
 243                         options);
 244
 245       return 0;
 246     }
 247
 248   opts = *options;
 249   opts.deref_ref = 1;
 250   return common_val_print (val, stream, 0, &opts, current_language);
 251 }
 252
 253 /* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
 254    same meanings as in cp_print_value and c_val_print.
 255
 256    DONT_PRINT is an array of baseclass types that we
 257    should not print, or zero if called from top level.  */
 258
 259 static void
 260 java_print_value_fields (struct type *type, const gdb_byte *valaddr,
 261                          CORE_ADDR address, struct ui_file *stream,
 262                          int recurse,
 263                          const struct value *val,
 264                          const struct value_print_options *options)
 265 {
 266   int i, len, n_baseclasses;
 267
 268   CHECK_TYPEDEF (type);
 269
 270   fprintf_filtered (stream, "{");
 271   len = TYPE_NFIELDS (type);
 272   n_baseclasses = TYPE_N_BASECLASSES (type);
 273
 274   if (n_baseclasses > 0)
 275     {
 276       int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 277
 278       for (i = 0; i < n_baseclasses; i++)
 279         {
 280           int boffset;
 281           struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 282           char *basename = TYPE_NAME (baseclass);
 283           const gdb_byte *base_valaddr;
 284
 285           if (BASETYPE_VIA_VIRTUAL (type, i))
 286             continue;
 287
 288           if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
 289             continue;
 290
 291           boffset = 0;
 292
 293           if (options->pretty)
 294             {
 295               fprintf_filtered (stream, "\n");
 296               print_spaces_filtered (2 * (recurse + 1), stream);
 297             }
 298           fputs_filtered ("<", stream);
 299           /* Not sure what the best notation is in the case where there is no
 300              baseclass name.  */
 301           fputs_filtered (basename ? basename : "", stream);
 302           fputs_filtered ("> = ", stream);
 303
 304           base_valaddr = valaddr;
 305
 306           java_print_value_fields (baseclass, base_valaddr, address + boffset,
 307                                    stream, recurse + 1, val, options);
 308           fputs_filtered (", ", stream);
 309         }
 310
 311     }
 312
 313   if (!len && n_baseclasses == 1)
 314     fprintf_filtered (stream, "<No data fields>");
 315   else
 316     {
 317       int fields_seen = 0;
 318
 319       for (i = n_baseclasses; i < len; i++)
 320         {
 321           /* If requested, skip printing of static fields.  */
 322           if (field_is_static (&TYPE_FIELD (type, i)))
 323             {
 324               char *name = TYPE_FIELD_NAME (type, i);
 325
 326               if (!options->static_field_print)
 327                 continue;
 328               if (name != NULL && strcmp (name, "class") == 0)
 329                 continue;
 330             }
 331           if (fields_seen)
 332             fprintf_filtered (stream, ", ");
 333           else if (n_baseclasses > 0)
 334             {
 335               if (options->pretty)
 336                 {
 337                   fprintf_filtered (stream, "\n");
 338                   print_spaces_filtered (2 + 2 * recurse, stream);
 339                   fputs_filtered ("members of ", stream);
 340                   fputs_filtered (type_name_no_tag (type), stream);
 341                   fputs_filtered (": ", stream);
 342                 }
 343             }
 344           fields_seen = 1;
 345
 346           if (options->pretty)
 347             {
 348               fprintf_filtered (stream, "\n");
 349               print_spaces_filtered (2 + 2 * recurse, stream);
 350             }
 351           else
 352             {
 353               wrap_here (n_spaces (2 + 2 * recurse));
 354             }
 355           if (options->inspect_it)
 356             {
 357               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 358                 fputs_filtered ("\"( ptr \"", stream);
 359               else
 360                 fputs_filtered ("\"( nodef \"", stream);
 361               if (field_is_static (&TYPE_FIELD (type, i)))
 362                 fputs_filtered ("static ", stream);
 363               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 364                                        language_cplus,
 365                                        DMGL_PARAMS | DMGL_ANSI);
 366               fputs_filtered ("\" \"", stream);
 367               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 368                                        language_cplus,
 369                                        DMGL_PARAMS | DMGL_ANSI);
 370               fputs_filtered ("\") \"", stream);
 371             }
 372           else
 373             {
 374               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 375
 376               if (field_is_static (&TYPE_FIELD (type, i)))
 377                 fputs_filtered ("static ", stream);
 378               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 379                                        language_cplus,
 380                                        DMGL_PARAMS | DMGL_ANSI);
 381               annotate_field_name_end ();
 382               fputs_filtered (": ", stream);
 383               annotate_field_value ();
 384             }
 385
 386           if (!field_is_static (&TYPE_FIELD (type, i))
 387               && TYPE_FIELD_PACKED (type, i))
 388             {
 389               struct value *v;
 390
 391               /* Bitfields require special handling, especially due to byte
 392                  order problems.  */
 393               if (TYPE_FIELD_IGNORE (type, i))
 394                 {
 395                   fputs_filtered ("<optimized out or zero length>", stream);
 396                 }
 397               else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
 398                                           TYPE_FIELD_BITSIZE (type, i)))
 399                 {
 400                   fputs_filtered (_("<value optimized out>"), stream);
 401                 }
 402               else
 403                 {
 404                   struct value_print_options opts;
 405
 406                   v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 407                                    unpack_field_as_long (type, valaddr, i));
 408
 409                   opts = *options;
 410                   opts.deref_ref = 0;
 411                   common_val_print (v, stream, recurse + 1,
 412                                     &opts, current_language);
 413                 }
 414             }
 415           else
 416             {
 417               if (TYPE_FIELD_IGNORE (type, i))
 418                 {
 419                   fputs_filtered ("<optimized out or zero length>", stream);
 420                 }
 421               else if (field_is_static (&TYPE_FIELD (type, i)))
 422                 {
 423                   struct value *v = value_static_field (type, i);
 424
 425                   if (v == NULL)
 426                     fputs_filtered ("<optimized out>", stream);
 427                   else
 428                     {
 429                       struct value_print_options opts;
 430                       struct type *t = check_typedef (value_type (v));
 431
 432                       if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
 433                         v = value_addr (v);
 434                       opts = *options;
 435                       opts.deref_ref = 0;
 436                       common_val_print (v, stream, recurse + 1,
 437                                         &opts, current_language);
 438                     }
 439                 }
 440               else if (TYPE_FIELD_TYPE (type, i) == NULL)
 441                 fputs_filtered ("<unknown type>", stream);
 442               else
 443                 {
 444                   struct value_print_options opts = *options;
 445
 446                   opts.deref_ref = 0;
 447                   val_print (TYPE_FIELD_TYPE (type, i),
 448                              valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
 449                              address + TYPE_FIELD_BITPOS (type, i) / 8,
 450                              stream, recurse + 1, val, &opts,
 451                              current_language);
 452                 }
 453             }
 454           annotate_field_end ();
 455         }
 456
 457       if (options->pretty)
 458         {
 459           fprintf_filtered (stream, "\n");
 460           print_spaces_filtered (2 * recurse, stream);
 461         }
 462     }
 463   fprintf_filtered (stream, "}");
 464 }
 465
 466 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 467    the inferior at address ADDRESS, onto stdio stream STREAM according to
 468    OPTIONS.  The data at VALADDR is in target byte order.
 469
 470    If the data are a string pointer, returns the number of string characters
 471    printed.  */
 472
 473 int
 474 java_val_print (struct type *type, const gdb_byte *valaddr,
 475                 int embedded_offset, CORE_ADDR address,
 476                 struct ui_file *stream, int recurse,
 477                 const struct value *val,
 478                 const struct value_print_options *options)
 479 {
 480   struct gdbarch *gdbarch = get_type_arch (type);
 481   unsigned int i = 0;   /* Number of characters printed */
 482   struct type *target_type;
 483   CORE_ADDR addr;
 484
 485   CHECK_TYPEDEF (type);
 486   switch (TYPE_CODE (type))
 487     {
 488     case TYPE_CODE_PTR:
 489       if (options->format && options->format != 's')
 490         {
 491           print_scalar_formatted (valaddr, type, options, 0, stream);
 492           break;
 493         }
 494 #if 0
 495       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 496         {
 497           /* Print the unmangled name if desired.  */
 498           /* Print vtable entry - we only get here if we ARE using
 499              -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 500           /* Extract an address, assume that it is unsigned.  */
 501           print_address_demangle (gdbarch,
 502                                   extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
 503                                   stream, demangle);
 504           break;
 505         }
 506 #endif
 507       addr = unpack_pointer (type, valaddr);
 508       if (addr == 0)
 509         {
 510           fputs_filtered ("null", stream);
 511           return i;
 512         }
 513       target_type = check_typedef (TYPE_TARGET_TYPE (type));
 514
 515       if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
 516         {
 517           /* Try to print what function it points to.  */
 518           print_address_demangle (gdbarch, addr, stream, demangle);
 519           /* Return value is irrelevant except for string pointers.  */
 520           return (0);
 521         }
 522
 523       if (options->addressprint && options->format != 's')
 524         {
 525           fputs_filtered ("@", stream);
 526           print_longest (stream, 'x', 0, (ULONGEST) addr);
 527         }
 528
 529       return i;
 530
 531     case TYPE_CODE_CHAR:
 532     case TYPE_CODE_INT:
 533       /* Can't just call c_val_print because that prints bytes as C
 534          chars.  */
 535       if (options->format || options->output_format)
 536         {
 537           struct value_print_options opts = *options;
 538
 539           opts.format = (options->format ? options->format
 540                          : options->output_format);
 541           print_scalar_formatted (valaddr, type, &opts, 0, stream);
 542         }
 543       else if (TYPE_CODE (type) == TYPE_CODE_CHAR
 544                || (TYPE_CODE (type) == TYPE_CODE_INT
 545                    && TYPE_LENGTH (type) == 2
 546                    && strcmp (TYPE_NAME (type), "char") == 0))
 547         LA_PRINT_CHAR ((int) unpack_long (type, valaddr), type, stream);
 548       else
 549         val_print_type_code_int (type, valaddr, stream);
 550       break;
 551
 552     case TYPE_CODE_STRUCT:
 553       java_print_value_fields (type, valaddr, address, stream, recurse,
 554                                val, options);
 555       break;
 556
 557     default:
 558       return c_val_print (type, valaddr, embedded_offset, address, stream,
 559                           recurse, val, options);
 560     }
 561
 562   return 0;
 563 }