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