1 /* Support for printing C++ values for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 4 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "gdb_obstack.h" 24 #include "symtab.h" 25 #include "gdbtypes.h" 26 #include "expression.h" 27 #include "value.h" 28 #include "command.h" 29 #include "gdbcmd.h" 30 #include "demangle.h" 31 #include "annotate.h" 32 #include "gdb_string.h" 33 #include "c-lang.h" 34 #include "target.h" 35 #include "cp-abi.h" 36 #include "valprint.h" 37 #include "cp-support.h" 38 #include "language.h" 39 #include "python/python.h" 40 #include "exceptions.h" 41 42 /* Controls printing of vtbl's. */ 43 static void 44 show_vtblprint (struct ui_file *file, int from_tty, 45 struct cmd_list_element *c, const char *value) 46 { 47 fprintf_filtered (file, _("\ 48 Printing of C++ virtual function tables is %s.\n"), 49 value); 50 } 51 52 /* Controls looking up an object's derived type using what we find in 53 its vtables. */ 54 static void 55 show_objectprint (struct ui_file *file, int from_tty, 56 struct cmd_list_element *c, 57 const char *value) 58 { 59 fprintf_filtered (file, _("\ 60 Printing of object's derived type based on vtable info is %s.\n"), 61 value); 62 } 63 64 static void 65 show_static_field_print (struct ui_file *file, int from_tty, 66 struct cmd_list_element *c, 67 const char *value) 68 { 69 fprintf_filtered (file, 70 _("Printing of C++ static members is %s.\n"), 71 value); 72 } 73 74 75 static struct obstack dont_print_vb_obstack; 76 static struct obstack dont_print_statmem_obstack; 77 static struct obstack dont_print_stat_array_obstack; 78 79 extern void _initialize_cp_valprint (void); 80 81 static void cp_print_static_field (struct type *, struct value *, 82 struct ui_file *, int, 83 const struct value_print_options *); 84 85 static void cp_print_value (struct type *, struct type *, 86 const gdb_byte *, int, 87 CORE_ADDR, struct ui_file *, 88 int, const struct value *, 89 const struct value_print_options *, 90 struct type **); 91 92 93 /* GCC versions after 2.4.5 use this. */ 94 const char vtbl_ptr_name[] = "__vtbl_ptr_type"; 95 96 /* Return truth value for assertion that TYPE is of the type 97 "pointer to virtual function". */ 98 99 int 100 cp_is_vtbl_ptr_type (struct type *type) 101 { 102 char *typename = type_name_no_tag (type); 103 104 return (typename != NULL && !strcmp (typename, vtbl_ptr_name)); 105 } 106 107 /* Return truth value for the assertion that TYPE is of the type 108 "pointer to virtual function table". */ 109 110 int 111 cp_is_vtbl_member (struct type *type) 112 { 113 /* With older versions of g++, the vtbl field pointed to an array of 114 structures. Nowadays it points directly to the structure. */ 115 if (TYPE_CODE (type) == TYPE_CODE_PTR) 116 { 117 type = TYPE_TARGET_TYPE (type); 118 if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 119 { 120 type = TYPE_TARGET_TYPE (type); 121 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */ 122 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */ 123 { 124 /* Virtual functions tables are full of pointers 125 to virtual functions. */ 126 return cp_is_vtbl_ptr_type (type); 127 } 128 } 129 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */ 130 { 131 return cp_is_vtbl_ptr_type (type); 132 } 133 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */ 134 { 135 /* The type name of the thunk pointer is NULL when using 136 dwarf2. We could test for a pointer to a function, but 137 there is no type info for the virtual table either, so it 138 wont help. */ 139 return cp_is_vtbl_ptr_type (type); 140 } 141 } 142 return 0; 143 } 144 145 /* Mutually recursive subroutines of cp_print_value and c_val_print to 146 print out a structure's fields: cp_print_value_fields and 147 cp_print_value. 148 149 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same 150 meanings as in cp_print_value and c_val_print. 151 152 2nd argument REAL_TYPE is used to carry over the type of the 153 derived class across the recursion to base classes. 154 155 DONT_PRINT is an array of baseclass types that we should not print, 156 or zero if called from top level. */ 157 158 void 159 cp_print_value_fields (struct type *type, struct type *real_type, 160 const gdb_byte *valaddr, int offset, 161 CORE_ADDR address, struct ui_file *stream, 162 int recurse, const struct value *val, 163 const struct value_print_options *options, 164 struct type **dont_print_vb, 165 int dont_print_statmem) 166 { 167 int i, len, n_baseclasses; 168 int fields_seen = 0; 169 static int last_set_recurse = -1; 170 171 CHECK_TYPEDEF (type); 172 173 if (recurse == 0) 174 { 175 /* Any object can be left on obstacks only during an unexpected 176 error. */ 177 178 if (obstack_object_size (&dont_print_statmem_obstack) > 0) 179 { 180 obstack_free (&dont_print_statmem_obstack, NULL); 181 obstack_begin (&dont_print_statmem_obstack, 182 32 * sizeof (CORE_ADDR)); 183 } 184 if (obstack_object_size (&dont_print_stat_array_obstack) > 0) 185 { 186 obstack_free (&dont_print_stat_array_obstack, NULL); 187 obstack_begin (&dont_print_stat_array_obstack, 188 32 * sizeof (struct type *)); 189 } 190 } 191 192 fprintf_filtered (stream, "{"); 193 len = TYPE_NFIELDS (type); 194 n_baseclasses = TYPE_N_BASECLASSES (type); 195 196 /* First, print out baseclasses such that we don't print 197 duplicates of virtual baseclasses. */ 198 199 if (n_baseclasses > 0) 200 cp_print_value (type, real_type, valaddr, 201 offset, address, stream, 202 recurse + 1, val, options, 203 dont_print_vb); 204 205 /* Second, print out data fields */ 206 207 /* If there are no data fields, skip this part */ 208 if (len == n_baseclasses || !len) 209 fprintf_filtered (stream, "<No data fields>"); 210 else 211 { 212 int statmem_obstack_initial_size = 0; 213 int stat_array_obstack_initial_size = 0; 214 215 if (dont_print_statmem == 0) 216 { 217 statmem_obstack_initial_size = 218 obstack_object_size (&dont_print_statmem_obstack); 219 220 if (last_set_recurse != recurse) 221 { 222 stat_array_obstack_initial_size = 223 obstack_object_size (&dont_print_stat_array_obstack); 224 225 last_set_recurse = recurse; 226 } 227 } 228 229 for (i = n_baseclasses; i < len; i++) 230 { 231 /* If requested, skip printing of static fields. */ 232 if (!options->static_field_print 233 && field_is_static (&TYPE_FIELD (type, i))) 234 continue; 235 236 if (fields_seen) 237 fprintf_filtered (stream, ", "); 238 else if (n_baseclasses > 0) 239 { 240 if (options->pretty) 241 { 242 fprintf_filtered (stream, "\n"); 243 print_spaces_filtered (2 + 2 * recurse, stream); 244 fputs_filtered ("members of ", stream); 245 fputs_filtered (type_name_no_tag (type), stream); 246 fputs_filtered (": ", stream); 247 } 248 } 249 fields_seen = 1; 250 251 if (options->pretty) 252 { 253 fprintf_filtered (stream, "\n"); 254 print_spaces_filtered (2 + 2 * recurse, stream); 255 } 256 else 257 { 258 wrap_here (n_spaces (2 + 2 * recurse)); 259 } 260 if (options->inspect_it) 261 { 262 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR) 263 fputs_filtered ("\"( ptr \"", stream); 264 else 265 fputs_filtered ("\"( nodef \"", stream); 266 if (field_is_static (&TYPE_FIELD (type, i))) 267 fputs_filtered ("static ", stream); 268 fprintf_symbol_filtered (stream, 269 TYPE_FIELD_NAME (type, i), 270 current_language->la_language, 271 DMGL_PARAMS | DMGL_ANSI); 272 fputs_filtered ("\" \"", stream); 273 fprintf_symbol_filtered (stream, 274 TYPE_FIELD_NAME (type, i), 275 current_language->la_language, 276 DMGL_PARAMS | DMGL_ANSI); 277 fputs_filtered ("\") \"", stream); 278 } 279 else 280 { 281 annotate_field_begin (TYPE_FIELD_TYPE (type, i)); 282 283 if (field_is_static (&TYPE_FIELD (type, i))) 284 fputs_filtered ("static ", stream); 285 fprintf_symbol_filtered (stream, 286 TYPE_FIELD_NAME (type, i), 287 current_language->la_language, 288 DMGL_PARAMS | DMGL_ANSI); 289 annotate_field_name_end (); 290 /* Do not print leading '=' in case of anonymous 291 unions. */ 292 if (strcmp (TYPE_FIELD_NAME (type, i), "")) 293 fputs_filtered (" = ", stream); 294 annotate_field_value (); 295 } 296 297 if (!field_is_static (&TYPE_FIELD (type, i)) 298 && TYPE_FIELD_PACKED (type, i)) 299 { 300 struct value *v; 301 302 /* Bitfields require special handling, especially due to 303 byte order problems. */ 304 if (TYPE_FIELD_IGNORE (type, i)) 305 { 306 fputs_filtered ("<optimized out or zero length>", stream); 307 } 308 else if (value_bits_synthetic_pointer (val, 309 TYPE_FIELD_BITPOS (type, 310 i), 311 TYPE_FIELD_BITSIZE (type, 312 i))) 313 { 314 fputs_filtered (_("<synthetic pointer>"), stream); 315 } 316 else if (!value_bits_valid (val, 317 TYPE_FIELD_BITPOS (type, i), 318 TYPE_FIELD_BITSIZE (type, i))) 319 { 320 val_print_optimized_out (stream); 321 } 322 else 323 { 324 struct value_print_options opts = *options; 325 326 opts.deref_ref = 0; 327 328 v = value_field_bitfield (type, i, valaddr, offset, val); 329 330 common_val_print (v, stream, recurse + 1, &opts, 331 current_language); 332 } 333 } 334 else 335 { 336 if (TYPE_FIELD_IGNORE (type, i)) 337 { 338 fputs_filtered ("<optimized out or zero length>", 339 stream); 340 } 341 else if (field_is_static (&TYPE_FIELD (type, i))) 342 { 343 struct value *v = value_static_field (type, i); 344 345 if (v == NULL) 346 val_print_optimized_out (stream); 347 else 348 cp_print_static_field (TYPE_FIELD_TYPE (type, i), 349 v, stream, recurse + 1, 350 options); 351 } 352 else 353 { 354 struct value_print_options opts = *options; 355 356 opts.deref_ref = 0; 357 val_print (TYPE_FIELD_TYPE (type, i), 358 valaddr, 359 offset + TYPE_FIELD_BITPOS (type, i) / 8, 360 address, 361 stream, recurse + 1, val, &opts, 362 current_language); 363 } 364 } 365 annotate_field_end (); 366 } 367 368 if (dont_print_statmem == 0) 369 { 370 int obstack_final_size = 371 obstack_object_size (&dont_print_statmem_obstack); 372 373 if (obstack_final_size > statmem_obstack_initial_size) 374 { 375 /* In effect, a pop of the printed-statics stack. */ 376 377 void *free_to_ptr = 378 obstack_next_free (&dont_print_statmem_obstack) - 379 (obstack_final_size - statmem_obstack_initial_size); 380 381 obstack_free (&dont_print_statmem_obstack, 382 free_to_ptr); 383 } 384 385 if (last_set_recurse != recurse) 386 { 387 int obstack_final_size = 388 obstack_object_size (&dont_print_stat_array_obstack); 389 390 if (obstack_final_size > stat_array_obstack_initial_size) 391 { 392 void *free_to_ptr = 393 obstack_next_free (&dont_print_stat_array_obstack) 394 - (obstack_final_size 395 - stat_array_obstack_initial_size); 396 397 obstack_free (&dont_print_stat_array_obstack, 398 free_to_ptr); 399 } 400 last_set_recurse = -1; 401 } 402 } 403 404 if (options->pretty) 405 { 406 fprintf_filtered (stream, "\n"); 407 print_spaces_filtered (2 * recurse, stream); 408 } 409 } /* if there are data fields */ 410 411 fprintf_filtered (stream, "}"); 412 } 413 414 /* Like cp_print_value_fields, but find the runtime type of the object 415 and pass it as the `real_type' argument to cp_print_value_fields. 416 This function is a hack to work around the fact that 417 common_val_print passes the embedded offset to val_print, but not 418 the enclosing type. */ 419 420 void 421 cp_print_value_fields_rtti (struct type *type, 422 const gdb_byte *valaddr, int offset, 423 CORE_ADDR address, 424 struct ui_file *stream, int recurse, 425 const struct value *val, 426 const struct value_print_options *options, 427 struct type **dont_print_vb, 428 int dont_print_statmem) 429 { 430 struct type *real_type = NULL; 431 432 /* We require all bits to be valid in order to attempt a 433 conversion. */ 434 if (value_bits_valid (val, TARGET_CHAR_BIT * offset, 435 TARGET_CHAR_BIT * TYPE_LENGTH (type))) 436 { 437 struct value *value; 438 int full, top, using_enc; 439 440 /* Ugh, we have to convert back to a value here. */ 441 value = value_from_contents_and_address (type, valaddr + offset, 442 address + offset); 443 /* We don't actually care about most of the result here -- just 444 the type. We already have the correct offset, due to how 445 val_print was initially called. */ 446 real_type = value_rtti_type (value, &full, &top, &using_enc); 447 } 448 449 if (!real_type) 450 real_type = type; 451 452 cp_print_value_fields (type, real_type, valaddr, offset, 453 address, stream, recurse, val, options, 454 dont_print_vb, dont_print_statmem); 455 } 456 457 /* Special val_print routine to avoid printing multiple copies of 458 virtual baseclasses. */ 459 460 static void 461 cp_print_value (struct type *type, struct type *real_type, 462 const gdb_byte *valaddr, int offset, 463 CORE_ADDR address, struct ui_file *stream, 464 int recurse, const struct value *val, 465 const struct value_print_options *options, 466 struct type **dont_print_vb) 467 { 468 struct type **last_dont_print 469 = (struct type **) obstack_next_free (&dont_print_vb_obstack); 470 struct obstack tmp_obstack = dont_print_vb_obstack; 471 int i, n_baseclasses = TYPE_N_BASECLASSES (type); 472 int thisoffset; 473 struct type *thistype; 474 475 if (dont_print_vb == 0) 476 { 477 /* If we're at top level, carve out a completely fresh chunk of 478 the obstack and use that until this particular invocation 479 returns. */ 480 /* Bump up the high-water mark. Now alpha is omega. */ 481 obstack_finish (&dont_print_vb_obstack); 482 } 483 484 for (i = 0; i < n_baseclasses; i++) 485 { 486 int boffset = 0; 487 int skip; 488 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); 489 char *basename = TYPE_NAME (baseclass); 490 const gdb_byte *base_valaddr = NULL; 491 const struct value *base_val = NULL; 492 volatile struct gdb_exception ex; 493 494 if (BASETYPE_VIA_VIRTUAL (type, i)) 495 { 496 struct type **first_dont_print 497 = (struct type **) obstack_base (&dont_print_vb_obstack); 498 499 int j = (struct type **) 500 obstack_next_free (&dont_print_vb_obstack) - first_dont_print; 501 502 while (--j >= 0) 503 if (baseclass == first_dont_print[j]) 504 goto flush_it; 505 506 obstack_ptr_grow (&dont_print_vb_obstack, baseclass); 507 } 508 509 thisoffset = offset; 510 thistype = real_type; 511 512 TRY_CATCH (ex, RETURN_MASK_ERROR) 513 { 514 boffset = baseclass_offset (type, i, valaddr, offset, address, val); 515 } 516 if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR) 517 skip = -1; 518 else if (ex.reason < 0) 519 skip = 1; 520 else 521 { 522 skip = 0; 523 524 if (BASETYPE_VIA_VIRTUAL (type, i)) 525 { 526 /* The virtual base class pointer might have been 527 clobbered by the user program. Make sure that it 528 still points to a valid memory location. */ 529 530 if ((boffset + offset) < 0 531 || (boffset + offset) >= TYPE_LENGTH (real_type)) 532 { 533 /* FIXME (alloca): unsafe if baseclass is really 534 really large. */ 535 gdb_byte *buf = alloca (TYPE_LENGTH (baseclass)); 536 537 if (target_read_memory (address + boffset, buf, 538 TYPE_LENGTH (baseclass)) != 0) 539 skip = 1; 540 base_val = value_from_contents_and_address (baseclass, 541 buf, 542 address + boffset); 543 thisoffset = 0; 544 boffset = 0; 545 thistype = baseclass; 546 base_valaddr = value_contents_for_printing_const (base_val); 547 } 548 else 549 { 550 base_valaddr = valaddr; 551 base_val = val; 552 } 553 } 554 else 555 { 556 base_valaddr = valaddr; 557 base_val = val; 558 } 559 } 560 561 /* Now do the printing. */ 562 if (options->pretty) 563 { 564 fprintf_filtered (stream, "\n"); 565 print_spaces_filtered (2 * recurse, stream); 566 } 567 fputs_filtered ("<", stream); 568 /* Not sure what the best notation is in the case where there is 569 no baseclass name. */ 570 fputs_filtered (basename ? basename : "", stream); 571 fputs_filtered ("> = ", stream); 572 573 if (skip < 0) 574 val_print_unavailable (stream); 575 else if (skip > 0) 576 val_print_invalid_address (stream); 577 else 578 { 579 int result = 0; 580 581 /* Attempt to run the Python pretty-printers on the 582 baseclass if possible. */ 583 if (!options->raw) 584 result = apply_val_pretty_printer (baseclass, base_valaddr, 585 thisoffset + boffset, 586 value_address (base_val), 587 stream, recurse, base_val, 588 options, current_language); 589 590 591 592 if (!result) 593 cp_print_value_fields (baseclass, thistype, base_valaddr, 594 thisoffset + boffset, 595 value_address (base_val), 596 stream, recurse, base_val, options, 597 ((struct type **) 598 obstack_base (&dont_print_vb_obstack)), 599 0); 600 } 601 fputs_filtered (", ", stream); 602 603 flush_it: 604 ; 605 } 606 607 if (dont_print_vb == 0) 608 { 609 /* Free the space used to deal with the printing 610 of this type from top level. */ 611 obstack_free (&dont_print_vb_obstack, last_dont_print); 612 /* Reset watermark so that we can continue protecting 613 ourselves from whatever we were protecting ourselves. */ 614 dont_print_vb_obstack = tmp_obstack; 615 } 616 } 617 618 /* Print value of a static member. To avoid infinite recursion when 619 printing a class that contains a static instance of the class, we 620 keep the addresses of all printed static member classes in an 621 obstack and refuse to print them more than once. 622 623 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS 624 have the same meanings as in c_val_print. */ 625 626 static void 627 cp_print_static_field (struct type *type, 628 struct value *val, 629 struct ui_file *stream, 630 int recurse, 631 const struct value_print_options *options) 632 { 633 struct value_print_options opts; 634 635 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 636 { 637 CORE_ADDR *first_dont_print; 638 CORE_ADDR addr; 639 int i; 640 641 first_dont_print 642 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack); 643 i = obstack_object_size (&dont_print_statmem_obstack) 644 / sizeof (CORE_ADDR); 645 646 while (--i >= 0) 647 { 648 if (value_address (val) == first_dont_print[i]) 649 { 650 fputs_filtered ("<same as static member of an already" 651 " seen type>", 652 stream); 653 return; 654 } 655 } 656 657 addr = value_address (val); 658 obstack_grow (&dont_print_statmem_obstack, (char *) &addr, 659 sizeof (CORE_ADDR)); 660 CHECK_TYPEDEF (type); 661 cp_print_value_fields (type, value_enclosing_type (val), 662 value_contents_for_printing (val), 663 value_embedded_offset (val), addr, 664 stream, recurse, val, 665 options, NULL, 1); 666 return; 667 } 668 669 if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 670 { 671 struct type **first_dont_print; 672 int i; 673 struct type *target_type = TYPE_TARGET_TYPE (type); 674 675 first_dont_print 676 = (struct type **) obstack_base (&dont_print_stat_array_obstack); 677 i = obstack_object_size (&dont_print_stat_array_obstack) 678 / sizeof (struct type *); 679 680 while (--i >= 0) 681 { 682 if (target_type == first_dont_print[i]) 683 { 684 fputs_filtered ("<same as static member of an already" 685 " seen type>", 686 stream); 687 return; 688 } 689 } 690 691 obstack_grow (&dont_print_stat_array_obstack, 692 (char *) &target_type, 693 sizeof (struct type *)); 694 } 695 696 opts = *options; 697 opts.deref_ref = 0; 698 val_print (type, value_contents_for_printing (val), 699 value_embedded_offset (val), 700 value_address (val), 701 stream, recurse, val, 702 &opts, current_language); 703 } 704 705 706 /* Find the field in *DOMAIN, or its non-virtual base classes, with 707 bit offset OFFSET. Set *DOMAIN to the containing type and *FIELDNO 708 to the containing field number. If OFFSET is not exactly at the 709 start of some field, set *DOMAIN to NULL. */ 710 711 static void 712 cp_find_class_member (struct type **domain_p, int *fieldno, 713 LONGEST offset) 714 { 715 struct type *domain; 716 unsigned int i; 717 unsigned len; 718 719 *domain_p = check_typedef (*domain_p); 720 domain = *domain_p; 721 len = TYPE_NFIELDS (domain); 722 723 for (i = TYPE_N_BASECLASSES (domain); i < len; i++) 724 { 725 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i); 726 727 QUIT; 728 if (offset == bitpos) 729 { 730 *fieldno = i; 731 return; 732 } 733 } 734 735 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++) 736 { 737 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i); 738 LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i)); 739 740 if (offset >= bitpos && offset < bitpos + bitsize) 741 { 742 *domain_p = TYPE_FIELD_TYPE (domain, i); 743 cp_find_class_member (domain_p, fieldno, offset - bitpos); 744 return; 745 } 746 } 747 748 *domain_p = NULL; 749 } 750 751 void 752 cp_print_class_member (const gdb_byte *valaddr, struct type *type, 753 struct ui_file *stream, char *prefix) 754 { 755 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 756 757 /* VAL is a byte offset into the structure type DOMAIN. 758 Find the name of the field for that offset and 759 print it. */ 760 struct type *domain = TYPE_DOMAIN_TYPE (type); 761 LONGEST val; 762 unsigned int fieldno; 763 764 val = extract_signed_integer (valaddr, 765 TYPE_LENGTH (type), 766 byte_order); 767 768 /* Pointers to data members are usually byte offsets into an object. 769 Because a data member can have offset zero, and a NULL pointer to 770 member must be distinct from any valid non-NULL pointer to 771 member, either the value is biased or the NULL value has a 772 special representation; both are permitted by ISO C++. HP aCC 773 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x 774 and other compilers which use the Itanium ABI use -1 as the NULL 775 value. GDB only supports that last form; to add support for 776 another form, make this into a cp-abi hook. */ 777 778 if (val == -1) 779 { 780 fprintf_filtered (stream, "NULL"); 781 return; 782 } 783 784 cp_find_class_member (&domain, &fieldno, val << 3); 785 786 if (domain != NULL) 787 { 788 char *name; 789 790 fputs_filtered (prefix, stream); 791 name = type_name_no_tag (domain); 792 if (name) 793 fputs_filtered (name, stream); 794 else 795 c_type_print_base (domain, stream, 0, 0); 796 fprintf_filtered (stream, "::"); 797 fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream); 798 } 799 else 800 fprintf_filtered (stream, "%ld", (long) val); 801 } 802 803 804 void 805 _initialize_cp_valprint (void) 806 { 807 add_setshow_boolean_cmd ("static-members", class_support, 808 &user_print_options.static_field_print, _("\ 809 Set printing of C++ static members."), _("\ 810 Show printing of C++ static members."), NULL, 811 NULL, 812 show_static_field_print, 813 &setprintlist, &showprintlist); 814 815 add_setshow_boolean_cmd ("vtbl", class_support, 816 &user_print_options.vtblprint, _("\ 817 Set printing of C++ virtual function tables."), _("\ 818 Show printing of C++ virtual function tables."), NULL, 819 NULL, 820 show_vtblprint, 821 &setprintlist, &showprintlist); 822 823 add_setshow_boolean_cmd ("object", class_support, 824 &user_print_options.objectprint, _("\ 825 Set printing of object's derived type based on vtable info."), _("\ 826 Show printing of object's derived type based on vtable info."), NULL, 827 NULL, 828 show_objectprint, 829 &setprintlist, &showprintlist); 830 831 obstack_begin (&dont_print_stat_array_obstack, 832 32 * sizeof (struct type *)); 833 obstack_begin (&dont_print_statmem_obstack, 834 32 * sizeof (CORE_ADDR)); 835 obstack_begin (&dont_print_vb_obstack, 836 32 * sizeof (struct type *)); 837 } 838