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_synthetic_pointer (val,
 398                                                      TYPE_FIELD_BITPOS (type,
 399                                                                         i),
 400                                                      TYPE_FIELD_BITSIZE (type,
 401                                                                          i)))
 402                 {
 403                   fputs_filtered (_("<synthetic pointer>"), stream);
 404                 }
 405               else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
 406                                           TYPE_FIELD_BITSIZE (type, i)))
 407                 {
 408                   fputs_filtered (_("<value optimized out>"), stream);
 409                 }
 410               else
 411                 {
 412                   struct value_print_options opts;
 413
 414                   v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 415                                    unpack_field_as_long (type, valaddr, i));
 416
 417                   opts = *options;
 418                   opts.deref_ref = 0;
 419                   common_val_print (v, stream, recurse + 1,
 420                                     &opts, current_language);
 421                 }
 422             }
 423           else
 424             {
 425               if (TYPE_FIELD_IGNORE (type, i))
 426                 {
 427                   fputs_filtered ("<optimized out or zero length>", stream);
 428                 }
 429               else if (field_is_static (&TYPE_FIELD (type, i)))
 430                 {
 431                   struct value *v = value_static_field (type, i);
 432
 433                   if (v == NULL)
 434                     fputs_filtered ("<optimized out>", stream);
 435                   else
 436                     {
 437                       struct value_print_options opts;
 438                       struct type *t = check_typedef (value_type (v));
 439
 440                       if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
 441                         v = value_addr (v);
 442                       opts = *options;
 443                       opts.deref_ref = 0;
 444                       common_val_print (v, stream, recurse + 1,
 445                                         &opts, current_language);
 446                     }
 447                 }
 448               else if (TYPE_FIELD_TYPE (type, i) == NULL)
 449                 fputs_filtered ("<unknown type>", stream);
 450               else
 451                 {
 452                   struct value_print_options opts = *options;
 453
 454                   opts.deref_ref = 0;
 455                   val_print (TYPE_FIELD_TYPE (type, i),
 456                              valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
 457                              address + TYPE_FIELD_BITPOS (type, i) / 8,
 458                              stream, recurse + 1, val, &opts,
 459                              current_language);
 460                 }
 461             }
 462           annotate_field_end ();
 463         }
 464
 465       if (options->pretty)
 466         {
 467           fprintf_filtered (stream, "\n");
 468           print_spaces_filtered (2 * recurse, stream);
 469         }
 470     }
 471   fprintf_filtered (stream, "}");
 472 }
 473
 474 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 475    the inferior at address ADDRESS, onto stdio stream STREAM according to
 476    OPTIONS.  The data at VALADDR is in target byte order.
 477
 478    If the data are a string pointer, returns the number of string characters
 479    printed.  */
 480
 481 int
 482 java_val_print (struct type *type, const gdb_byte *valaddr,
 483                 int embedded_offset, CORE_ADDR address,
 484                 struct ui_file *stream, int recurse,
 485                 const struct value *val,
 486                 const struct value_print_options *options)
 487 {
 488   struct gdbarch *gdbarch = get_type_arch (type);
 489   unsigned int i = 0;   /* Number of characters printed */
 490   struct type *target_type;
 491   CORE_ADDR addr;
 492
 493   CHECK_TYPEDEF (type);
 494   switch (TYPE_CODE (type))
 495     {
 496     case TYPE_CODE_PTR:
 497       if (options->format && options->format != 's')
 498         {
 499           print_scalar_formatted (valaddr, type, options, 0, stream);
 500           break;
 501         }
 502 #if 0
 503       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 504         {
 505           /* Print the unmangled name if desired.  */
 506           /* Print vtable entry - we only get here if we ARE using
 507              -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 508           /* Extract an address, assume that it is unsigned.  */
 509           print_address_demangle (gdbarch,
 510                                   extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
 511                                   stream, demangle);
 512           break;
 513         }
 514 #endif
 515       addr = unpack_pointer (type, valaddr);
 516       if (addr == 0)
 517         {
 518           fputs_filtered ("null", stream);
 519           return i;
 520         }
 521       target_type = check_typedef (TYPE_TARGET_TYPE (type));
 522
 523       if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
 524         {
 525           /* Try to print what function it points to.  */
 526           print_address_demangle (gdbarch, addr, stream, demangle);
 527           /* Return value is irrelevant except for string pointers.  */
 528           return (0);
 529         }
 530
 531       if (options->addressprint && options->format != 's')
 532         {
 533           fputs_filtered ("@", stream);
 534           print_longest (stream, 'x', 0, (ULONGEST) addr);
 535         }
 536
 537       return i;
 538
 539     case TYPE_CODE_CHAR:
 540     case TYPE_CODE_INT:
 541       /* Can't just call c_val_print because that prints bytes as C
 542          chars.  */
 543       if (options->format || options->output_format)
 544         {
 545           struct value_print_options opts = *options;
 546
 547           opts.format = (options->format ? options->format
 548                          : options->output_format);
 549           print_scalar_formatted (valaddr, type, &opts, 0, stream);
 550         }
 551       else if (TYPE_CODE (type) == TYPE_CODE_CHAR
 552                || (TYPE_CODE (type) == TYPE_CODE_INT
 553                    && TYPE_LENGTH (type) == 2
 554                    && strcmp (TYPE_NAME (type), "char") == 0))
 555         LA_PRINT_CHAR ((int) unpack_long (type, valaddr), type, stream);
 556       else
 557         val_print_type_code_int (type, valaddr, stream);
 558       break;
 559
 560     case TYPE_CODE_STRUCT:
 561       java_print_value_fields (type, valaddr, address, stream, recurse,
 562                                val, options);
 563       break;
 564
 565     default:
 566       return c_val_print (type, valaddr, embedded_offset, address, stream,
 567                           recurse, val, options);
 568     }
 569
 570   return 0;
 571 }