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