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, data + boffset, count, stream, options);
 243
 244       return 0;
 245     }
 246
 247   opts = *options;
 248   opts.deref_ref = 1;
 249   return common_val_print (val, stream, 0, &opts, current_language);
 250 }
 251
 252 /* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
 253    same meanings as in cp_print_value and c_val_print.
 254
 255    DONT_PRINT is an array of baseclass types that we
 256    should not print, or zero if called from top level.  */
 257
 258 static void
 259 java_print_value_fields (struct type *type, const gdb_byte *valaddr,
 260                          CORE_ADDR address, struct ui_file *stream,
 261                          int recurse,
 262                          const struct value *val,
 263                          const struct value_print_options *options)
 264 {
 265   int i, len, n_baseclasses;
 266
 267   CHECK_TYPEDEF (type);
 268
 269   fprintf_filtered (stream, "{");
 270   len = TYPE_NFIELDS (type);
 271   n_baseclasses = TYPE_N_BASECLASSES (type);
 272
 273   if (n_baseclasses > 0)
 274     {
 275       int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 276
 277       for (i = 0; i < n_baseclasses; i++)
 278         {
 279           int boffset;
 280           struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 281           char *basename = TYPE_NAME (baseclass);
 282           const gdb_byte *base_valaddr;
 283
 284           if (BASETYPE_VIA_VIRTUAL (type, i))
 285             continue;
 286
 287           if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
 288             continue;
 289
 290           boffset = 0;
 291
 292           if (options->pretty)
 293             {
 294               fprintf_filtered (stream, "\n");
 295               print_spaces_filtered (2 * (recurse + 1), stream);
 296             }
 297           fputs_filtered ("<", stream);
 298           /* Not sure what the best notation is in the case where there is no
 299              baseclass name.  */
 300           fputs_filtered (basename ? basename : "", stream);
 301           fputs_filtered ("> = ", stream);
 302
 303           base_valaddr = valaddr;
 304
 305           java_print_value_fields (baseclass, base_valaddr, address + boffset,
 306                                    stream, recurse + 1, val, options);
 307           fputs_filtered (", ", stream);
 308         }
 309
 310     }
 311
 312   if (!len && n_baseclasses == 1)
 313     fprintf_filtered (stream, "<No data fields>");
 314   else
 315     {
 316       int fields_seen = 0;
 317
 318       for (i = n_baseclasses; i < len; i++)
 319         {
 320           /* If requested, skip printing of static fields.  */
 321           if (field_is_static (&TYPE_FIELD (type, i)))
 322             {
 323               char *name = TYPE_FIELD_NAME (type, i);
 324
 325               if (!options->static_field_print)
 326                 continue;
 327               if (name != NULL && strcmp (name, "class") == 0)
 328                 continue;
 329             }
 330           if (fields_seen)
 331             fprintf_filtered (stream, ", ");
 332           else if (n_baseclasses > 0)
 333             {
 334               if (options->pretty)
 335                 {
 336                   fprintf_filtered (stream, "\n");
 337                   print_spaces_filtered (2 + 2 * recurse, stream);
 338                   fputs_filtered ("members of ", stream);
 339                   fputs_filtered (type_name_no_tag (type), stream);
 340                   fputs_filtered (": ", stream);
 341                 }
 342             }
 343           fields_seen = 1;
 344
 345           if (options->pretty)
 346             {
 347               fprintf_filtered (stream, "\n");
 348               print_spaces_filtered (2 + 2 * recurse, stream);
 349             }
 350           else
 351             {
 352               wrap_here (n_spaces (2 + 2 * recurse));
 353             }
 354           if (options->inspect_it)
 355             {
 356               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 357                 fputs_filtered ("\"( ptr \"", stream);
 358               else
 359                 fputs_filtered ("\"( nodef \"", stream);
 360               if (field_is_static (&TYPE_FIELD (type, i)))
 361                 fputs_filtered ("static ", stream);
 362               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 363                                        language_cplus,
 364                                        DMGL_PARAMS | DMGL_ANSI);
 365               fputs_filtered ("\" \"", stream);
 366               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 367                                        language_cplus,
 368                                        DMGL_PARAMS | DMGL_ANSI);
 369               fputs_filtered ("\") \"", stream);
 370             }
 371           else
 372             {
 373               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 374
 375               if (field_is_static (&TYPE_FIELD (type, i)))
 376                 fputs_filtered ("static ", stream);
 377               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 378                                        language_cplus,
 379                                        DMGL_PARAMS | DMGL_ANSI);
 380               annotate_field_name_end ();
 381               fputs_filtered (": ", stream);
 382               annotate_field_value ();
 383             }
 384
 385           if (!field_is_static (&TYPE_FIELD (type, i))
 386               && TYPE_FIELD_PACKED (type, i))
 387             {
 388               struct value *v;
 389
 390               /* Bitfields require special handling, especially due to byte
 391                  order problems.  */
 392               if (TYPE_FIELD_IGNORE (type, i))
 393                 {
 394                   fputs_filtered ("<optimized out or zero length>", stream);
 395                 }
 396               else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
 397                                           TYPE_FIELD_BITSIZE (type, i)))
 398                 {
 399                   fputs_filtered (_("<value optimized out>"), stream);
 400                 }
 401               else
 402                 {
 403                   struct value_print_options opts;
 404
 405                   v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 406                                    unpack_field_as_long (type, valaddr, i));
 407
 408                   opts = *options;
 409                   opts.deref_ref = 0;
 410                   common_val_print (v, stream, recurse + 1,
 411                                     &opts, current_language);
 412                 }
 413             }
 414           else
 415             {
 416               if (TYPE_FIELD_IGNORE (type, i))
 417                 {
 418                   fputs_filtered ("<optimized out or zero length>", stream);
 419                 }
 420               else if (field_is_static (&TYPE_FIELD (type, i)))
 421                 {
 422                   struct value *v = value_static_field (type, i);
 423
 424                   if (v == NULL)
 425                     fputs_filtered ("<optimized out>", stream);
 426                   else
 427                     {
 428                       struct value_print_options opts;
 429                       struct type *t = check_typedef (value_type (v));
 430
 431                       if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
 432                         v = value_addr (v);
 433                       opts = *options;
 434                       opts.deref_ref = 0;
 435                       common_val_print (v, stream, recurse + 1,
 436                                         &opts, current_language);
 437                     }
 438                 }
 439               else if (TYPE_FIELD_TYPE (type, i) == NULL)
 440                 fputs_filtered ("<unknown type>", stream);
 441               else
 442                 {
 443                   struct value_print_options opts = *options;
 444
 445                   opts.deref_ref = 0;
 446                   val_print (TYPE_FIELD_TYPE (type, i),
 447                              valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
 448                              address + TYPE_FIELD_BITPOS (type, i) / 8,
 449                              stream, recurse + 1, val, &opts,
 450                              current_language);
 451                 }
 452             }
 453           annotate_field_end ();
 454         }
 455
 456       if (options->pretty)
 457         {
 458           fprintf_filtered (stream, "\n");
 459           print_spaces_filtered (2 * recurse, stream);
 460         }
 461     }
 462   fprintf_filtered (stream, "}");
 463 }
 464
 465 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 466    the inferior at address ADDRESS, onto stdio stream STREAM according to
 467    OPTIONS.  The data at VALADDR is in target byte order.
 468
 469    If the data are a string pointer, returns the number of string characters
 470    printed.  */
 471
 472 int
 473 java_val_print (struct type *type, const gdb_byte *valaddr,
 474                 int embedded_offset, CORE_ADDR address,
 475                 struct ui_file *stream, int recurse,
 476                 const struct value *val,
 477                 const struct value_print_options *options)
 478 {
 479   struct gdbarch *gdbarch = get_type_arch (type);
 480   unsigned int i = 0;   /* Number of characters printed */
 481   struct type *target_type;
 482   CORE_ADDR addr;
 483
 484   CHECK_TYPEDEF (type);
 485   switch (TYPE_CODE (type))
 486     {
 487     case TYPE_CODE_PTR:
 488       if (options->format && options->format != 's')
 489         {
 490           print_scalar_formatted (valaddr, type, options, 0, stream);
 491           break;
 492         }
 493 #if 0
 494       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 495         {
 496           /* Print the unmangled name if desired.  */
 497           /* Print vtable entry - we only get here if we ARE using
 498              -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 499           /* Extract an address, assume that it is unsigned.  */
 500           print_address_demangle (gdbarch,
 501                                   extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
 502                                   stream, demangle);
 503           break;
 504         }
 505 #endif
 506       addr = unpack_pointer (type, valaddr);
 507       if (addr == 0)
 508         {
 509           fputs_filtered ("null", stream);
 510           return i;
 511         }
 512       target_type = check_typedef (TYPE_TARGET_TYPE (type));
 513
 514       if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
 515         {
 516           /* Try to print what function it points to.  */
 517           print_address_demangle (gdbarch, addr, stream, demangle);
 518           /* Return value is irrelevant except for string pointers.  */
 519           return (0);
 520         }
 521
 522       if (options->addressprint && options->format != 's')
 523         {
 524           fputs_filtered ("@", stream);
 525           print_longest (stream, 'x', 0, (ULONGEST) addr);
 526         }
 527
 528       return i;
 529
 530     case TYPE_CODE_CHAR:
 531     case TYPE_CODE_INT:
 532       /* Can't just call c_val_print because that prints bytes as C
 533          chars.  */
 534       if (options->format || options->output_format)
 535         {
 536           struct value_print_options opts = *options;
 537
 538           opts.format = (options->format ? options->format
 539                          : options->output_format);
 540           print_scalar_formatted (valaddr, type, &opts, 0, stream);
 541         }
 542       else if (TYPE_CODE (type) == TYPE_CODE_CHAR
 543                || (TYPE_CODE (type) == TYPE_CODE_INT
 544                    && TYPE_LENGTH (type) == 2
 545                    && strcmp (TYPE_NAME (type), "char") == 0))
 546         LA_PRINT_CHAR ((int) unpack_long (type, valaddr), type, stream);
 547       else
 548         val_print_type_code_int (type, valaddr, stream);
 549       break;
 550
 551     case TYPE_CODE_STRUCT:
 552       java_print_value_fields (type, valaddr, address, stream, recurse,
 553                                val, options);
 554       break;
 555
 556     default:
 557       return c_val_print (type, valaddr, embedded_offset, address, stream,
 558                           recurse, val, options);
 559     }
 560
 561   return 0;
 562 }