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