1 /* Language independent support for printing types for GDB, the GNU debugger. 2 3 Copyright (C) 1986-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 "gdb_obstack.h" 22 #include "bfd.h" /* Binary File Description */ 23 #include "symtab.h" 24 #include "gdbtypes.h" 25 #include "expression.h" 26 #include "value.h" 27 #include "gdbcore.h" 28 #include "command.h" 29 #include "gdbcmd.h" 30 #include "target.h" 31 #include "language.h" 32 #include "cp-abi.h" 33 #include "typeprint.h" 34 #include "gdb_string.h" 35 #include "exceptions.h" 36 #include "valprint.h" 37 #include <errno.h> 38 #include <ctype.h> 39 #include "cli/cli-utils.h" 40 #include "python/python.h" 41 #include "completer.h" 42 43 extern void _initialize_typeprint (void); 44 45 static void ptype_command (char *, int); 46 47 static void whatis_command (char *, int); 48 49 static void whatis_exp (char *, int); 50 51 const struct type_print_options type_print_raw_options = 52 { 53 1, /* raw */ 54 1, /* print_methods */ 55 1, /* print_typedefs */ 56 NULL, /* local_typedefs */ 57 NULL, /* global_table */ 58 NULL /* global_printers */ 59 }; 60 61 /* The default flags for 'ptype' and 'whatis'. */ 62 63 static struct type_print_options default_ptype_flags = 64 { 65 0, /* raw */ 66 1, /* print_methods */ 67 1, /* print_typedefs */ 68 NULL, /* local_typedefs */ 69 NULL, /* global_table */ 70 NULL /* global_printers */ 71 }; 72 73 74 75 /* A hash table holding typedef_field objects. This is more 76 complicated than an ordinary hash because it must also track the 77 lifetime of some -- but not all -- of the contained objects. */ 78 79 struct typedef_hash_table 80 { 81 /* The actual hash table. */ 82 htab_t table; 83 84 /* Storage for typedef_field objects that must be synthesized. */ 85 struct obstack storage; 86 }; 87 88 /* A hash function for a typedef_field. */ 89 90 static hashval_t 91 hash_typedef_field (const void *p) 92 { 93 const struct typedef_field *tf = p; 94 struct type *t = check_typedef (tf->type); 95 96 return htab_hash_string (TYPE_SAFE_NAME (t)); 97 } 98 99 /* An equality function for a typedef field. */ 100 101 static int 102 eq_typedef_field (const void *a, const void *b) 103 { 104 const struct typedef_field *tfa = a; 105 const struct typedef_field *tfb = b; 106 107 return types_equal (tfa->type, tfb->type); 108 } 109 110 /* Add typedefs from T to the hash table TABLE. */ 111 112 void 113 recursively_update_typedef_hash (struct typedef_hash_table *table, 114 struct type *t) 115 { 116 int i; 117 118 if (table == NULL) 119 return; 120 121 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i) 122 { 123 struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i); 124 void **slot; 125 126 slot = htab_find_slot (table->table, tdef, INSERT); 127 /* Only add a given typedef name once. Really this shouldn't 128 happen; but it is safe enough to do the updates breadth-first 129 and thus use the most specific typedef. */ 130 if (*slot == NULL) 131 *slot = tdef; 132 } 133 134 /* Recurse into superclasses. */ 135 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i) 136 recursively_update_typedef_hash (table, TYPE_BASECLASS (t, i)); 137 } 138 139 /* Add template parameters from T to the typedef hash TABLE. */ 140 141 void 142 add_template_parameters (struct typedef_hash_table *table, struct type *t) 143 { 144 int i; 145 146 if (table == NULL) 147 return; 148 149 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i) 150 { 151 struct typedef_field *tf; 152 void **slot; 153 154 /* We only want type-valued template parameters in the hash. */ 155 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF) 156 continue; 157 158 tf = XOBNEW (&table->storage, struct typedef_field); 159 tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i)); 160 tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i)); 161 162 slot = htab_find_slot (table->table, tf, INSERT); 163 if (*slot == NULL) 164 *slot = tf; 165 } 166 } 167 168 /* Create a new typedef-lookup hash table. */ 169 170 struct typedef_hash_table * 171 create_typedef_hash (void) 172 { 173 struct typedef_hash_table *result; 174 175 result = XNEW (struct typedef_hash_table); 176 result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field, 177 NULL, xcalloc, xfree); 178 obstack_init (&result->storage); 179 180 return result; 181 } 182 183 /* Free a typedef field table. */ 184 185 void 186 free_typedef_hash (struct typedef_hash_table *table) 187 { 188 if (table != NULL) 189 { 190 htab_delete (table->table); 191 obstack_free (&table->storage, NULL); 192 xfree (table); 193 } 194 } 195 196 /* A cleanup for freeing a typedef_hash_table. */ 197 198 static void 199 do_free_typedef_hash (void *arg) 200 { 201 free_typedef_hash (arg); 202 } 203 204 /* Return a new cleanup that frees TABLE. */ 205 206 struct cleanup * 207 make_cleanup_free_typedef_hash (struct typedef_hash_table *table) 208 { 209 return make_cleanup (do_free_typedef_hash, table); 210 } 211 212 /* Helper function for copy_typedef_hash. */ 213 214 static int 215 copy_typedef_hash_element (void **slot, void *nt) 216 { 217 htab_t new_table = nt; 218 void **new_slot; 219 220 new_slot = htab_find_slot (new_table, *slot, INSERT); 221 if (*new_slot == NULL) 222 *new_slot = *slot; 223 224 return 1; 225 } 226 227 /* Copy a typedef hash. */ 228 229 struct typedef_hash_table * 230 copy_typedef_hash (struct typedef_hash_table *table) 231 { 232 struct typedef_hash_table *result; 233 234 if (table == NULL) 235 return NULL; 236 237 result = create_typedef_hash (); 238 htab_traverse_noresize (table->table, copy_typedef_hash_element, 239 result->table); 240 return result; 241 } 242 243 /* A cleanup to free the global typedef hash. */ 244 245 static void 246 do_free_global_table (void *arg) 247 { 248 struct type_print_options *flags = arg; 249 250 free_typedef_hash (flags->global_typedefs); 251 free_type_printers (flags->global_printers); 252 } 253 254 /* Create the global typedef hash. */ 255 256 static struct cleanup * 257 create_global_typedef_table (struct type_print_options *flags) 258 { 259 gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL); 260 flags->global_typedefs = create_typedef_hash (); 261 flags->global_printers = start_type_printers (); 262 return make_cleanup (do_free_global_table, flags); 263 } 264 265 /* Look up the type T in the global typedef hash. If it is found, 266 return the typedef name. If it is not found, apply the 267 type-printers, if any, given by start_type_printers and return the 268 result. A NULL return means that the name was not found. */ 269 270 static const char * 271 find_global_typedef (const struct type_print_options *flags, 272 struct type *t) 273 { 274 char *applied; 275 void **slot; 276 struct typedef_field tf, *new_tf; 277 278 if (flags->global_typedefs == NULL) 279 return NULL; 280 281 tf.name = NULL; 282 tf.type = t; 283 284 slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT); 285 if (*slot != NULL) 286 { 287 new_tf = *slot; 288 return new_tf->name; 289 } 290 291 /* Put an entry into the hash table now, in case apply_type_printers 292 recurses. */ 293 new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field); 294 new_tf->name = NULL; 295 new_tf->type = t; 296 297 *slot = new_tf; 298 299 applied = apply_type_printers (flags->global_printers, t); 300 301 if (applied != NULL) 302 { 303 new_tf->name = obstack_copy0 (&flags->global_typedefs->storage, applied, 304 strlen (applied)); 305 xfree (applied); 306 } 307 308 return new_tf->name; 309 } 310 311 /* Look up the type T in the typedef hash table in with FLAGS. If T 312 is in the table, return its short (class-relative) typedef name. 313 Otherwise return NULL. If the table is NULL, this always returns 314 NULL. */ 315 316 const char * 317 find_typedef_in_hash (const struct type_print_options *flags, struct type *t) 318 { 319 if (flags->local_typedefs != NULL) 320 { 321 struct typedef_field tf, *found; 322 323 tf.name = NULL; 324 tf.type = t; 325 found = htab_find (flags->local_typedefs->table, &tf); 326 327 if (found != NULL) 328 return found->name; 329 } 330 331 return find_global_typedef (flags, t); 332 } 333 334 335 336 /* Print a description of a type in the format of a 337 typedef for the current language. 338 NEW is the new name for a type TYPE. */ 339 340 void 341 typedef_print (struct type *type, struct symbol *new, struct ui_file *stream) 342 { 343 LA_PRINT_TYPEDEF (type, new, stream); 344 } 345 346 /* The default way to print a typedef. */ 347 348 void 349 default_print_typedef (struct type *type, struct symbol *new_symbol, 350 struct ui_file *stream) 351 { 352 error (_("Language not supported.")); 353 } 354 355 /* Print a description of a type TYPE in the form of a declaration of a 356 variable named VARSTRING. (VARSTRING is demangled if necessary.) 357 Output goes to STREAM (via stdio). 358 If SHOW is positive, we show the contents of the outermost level 359 of structure even if there is a type name that could be used instead. 360 If SHOW is negative, we never show the details of elements' types. */ 361 362 void 363 type_print (struct type *type, const char *varstring, struct ui_file *stream, 364 int show) 365 { 366 LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags); 367 } 368 369 /* Print TYPE to a string, returning it. The caller is responsible for 370 freeing the string. */ 371 372 char * 373 type_to_string (struct type *type) 374 { 375 char *s = NULL; 376 struct ui_file *stb; 377 struct cleanup *old_chain; 378 volatile struct gdb_exception except; 379 380 stb = mem_fileopen (); 381 old_chain = make_cleanup_ui_file_delete (stb); 382 383 TRY_CATCH (except, RETURN_MASK_ALL) 384 { 385 type_print (type, "", stb, -1); 386 s = ui_file_xstrdup (stb, NULL); 387 } 388 if (except.reason < 0) 389 s = NULL; 390 391 do_cleanups (old_chain); 392 393 return s; 394 } 395 396 /* Print type of EXP, or last thing in value history if EXP == NULL. 397 show is passed to type_print. */ 398 399 static void 400 whatis_exp (char *exp, int show) 401 { 402 struct expression *expr; 403 struct value *val; 404 struct cleanup *old_chain; 405 struct type *real_type = NULL; 406 struct type *type; 407 int full = 0; 408 int top = -1; 409 int using_enc = 0; 410 struct value_print_options opts; 411 struct type_print_options flags = default_ptype_flags; 412 413 old_chain = make_cleanup (null_cleanup, NULL); 414 415 if (exp) 416 { 417 if (*exp == '/') 418 { 419 int seen_one = 0; 420 421 for (++exp; *exp && !isspace (*exp); ++exp) 422 { 423 switch (*exp) 424 { 425 case 'r': 426 flags.raw = 1; 427 break; 428 case 'm': 429 flags.print_methods = 0; 430 break; 431 case 'M': 432 flags.print_methods = 1; 433 break; 434 case 't': 435 flags.print_typedefs = 0; 436 break; 437 case 'T': 438 flags.print_typedefs = 1; 439 break; 440 default: 441 error (_("unrecognized flag '%c'"), *exp); 442 } 443 seen_one = 1; 444 } 445 446 if (!*exp && !seen_one) 447 error (_("flag expected")); 448 if (!isspace (*exp)) 449 error (_("expected space after format")); 450 exp = skip_spaces (exp); 451 } 452 453 expr = parse_expression (exp); 454 make_cleanup (free_current_contents, &expr); 455 val = evaluate_type (expr); 456 } 457 else 458 val = access_value_history (0); 459 460 type = value_type (val); 461 462 get_user_print_options (&opts); 463 if (opts.objectprint) 464 { 465 if (((TYPE_CODE (type) == TYPE_CODE_PTR) 466 || (TYPE_CODE (type) == TYPE_CODE_REF)) 467 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS)) 468 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc); 469 else if (TYPE_CODE (type) == TYPE_CODE_CLASS) 470 real_type = value_rtti_type (val, &full, &top, &using_enc); 471 } 472 473 printf_filtered ("type = "); 474 475 if (!flags.raw) 476 create_global_typedef_table (&flags); 477 478 if (real_type) 479 { 480 printf_filtered ("/* real type = "); 481 type_print (real_type, "", gdb_stdout, -1); 482 if (! full) 483 printf_filtered (" (incomplete object)"); 484 printf_filtered (" */\n"); 485 } 486 487 LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags); 488 printf_filtered ("\n"); 489 490 do_cleanups (old_chain); 491 } 492 493 static void 494 whatis_command (char *exp, int from_tty) 495 { 496 /* Most of the time users do not want to see all the fields 497 in a structure. If they do they can use the "ptype" command. 498 Hence the "-1" below. */ 499 whatis_exp (exp, -1); 500 } 501 502 /* TYPENAME is either the name of a type, or an expression. */ 503 504 static void 505 ptype_command (char *typename, int from_tty) 506 { 507 whatis_exp (typename, 1); 508 } 509 510 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM. 511 Used to print data from type structures in a specified type. For example, 512 array bounds may be characters or booleans in some languages, and this 513 allows the ranges to be printed in their "natural" form rather than as 514 decimal integer values. 515 516 FIXME: This is here simply because only the type printing routines 517 currently use it, and it wasn't clear if it really belonged somewhere 518 else (like printcmd.c). There are a lot of other gdb routines that do 519 something similar, but they are generally concerned with printing values 520 that come from the inferior in target byte order and target size. */ 521 522 void 523 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream) 524 { 525 unsigned int i; 526 unsigned len; 527 528 CHECK_TYPEDEF (type); 529 530 switch (TYPE_CODE (type)) 531 { 532 533 case TYPE_CODE_ENUM: 534 len = TYPE_NFIELDS (type); 535 for (i = 0; i < len; i++) 536 { 537 if (TYPE_FIELD_ENUMVAL (type, i) == val) 538 { 539 break; 540 } 541 } 542 if (i < len) 543 { 544 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 545 } 546 else 547 { 548 print_longest (stream, 'd', 0, val); 549 } 550 break; 551 552 case TYPE_CODE_INT: 553 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val); 554 break; 555 556 case TYPE_CODE_CHAR: 557 LA_PRINT_CHAR ((unsigned char) val, type, stream); 558 break; 559 560 case TYPE_CODE_BOOL: 561 fprintf_filtered (stream, val ? "TRUE" : "FALSE"); 562 break; 563 564 case TYPE_CODE_RANGE: 565 print_type_scalar (TYPE_TARGET_TYPE (type), val, stream); 566 return; 567 568 case TYPE_CODE_UNDEF: 569 case TYPE_CODE_PTR: 570 case TYPE_CODE_ARRAY: 571 case TYPE_CODE_STRUCT: 572 case TYPE_CODE_UNION: 573 case TYPE_CODE_FUNC: 574 case TYPE_CODE_FLT: 575 case TYPE_CODE_VOID: 576 case TYPE_CODE_SET: 577 case TYPE_CODE_STRING: 578 case TYPE_CODE_ERROR: 579 case TYPE_CODE_MEMBERPTR: 580 case TYPE_CODE_METHODPTR: 581 case TYPE_CODE_METHOD: 582 case TYPE_CODE_REF: 583 case TYPE_CODE_NAMESPACE: 584 error (_("internal error: unhandled type in print_type_scalar")); 585 break; 586 587 default: 588 error (_("Invalid type code in symbol table.")); 589 } 590 gdb_flush (stream); 591 } 592 593 /* Dump details of a type specified either directly or indirectly. 594 Uses the same sort of type lookup mechanism as ptype_command() 595 and whatis_command(). */ 596 597 void 598 maintenance_print_type (char *typename, int from_tty) 599 { 600 struct value *val; 601 struct type *type; 602 struct cleanup *old_chain; 603 struct expression *expr; 604 605 if (typename != NULL) 606 { 607 expr = parse_expression (typename); 608 old_chain = make_cleanup (free_current_contents, &expr); 609 if (expr->elts[0].opcode == OP_TYPE) 610 { 611 /* The user expression names a type directly, just use that type. */ 612 type = expr->elts[1].type; 613 } 614 else 615 { 616 /* The user expression may name a type indirectly by naming an 617 object of that type. Find that indirectly named type. */ 618 val = evaluate_type (expr); 619 type = value_type (val); 620 } 621 if (type != NULL) 622 { 623 recursive_dump_type (type, 0); 624 } 625 do_cleanups (old_chain); 626 } 627 } 628 629 630 struct cmd_list_element *setprinttypelist; 631 632 struct cmd_list_element *showprinttypelist; 633 634 static void 635 set_print_type (char *arg, int from_tty) 636 { 637 printf_unfiltered ( 638 "\"set print type\" must be followed by the name of a subcommand.\n"); 639 help_list (setprintlist, "set print type ", -1, gdb_stdout); 640 } 641 642 static void 643 show_print_type (char *args, int from_tty) 644 { 645 cmd_show_list (showprinttypelist, from_tty, ""); 646 } 647 648 static int print_methods = 1; 649 650 static void 651 set_print_type_methods (char *args, int from_tty, struct cmd_list_element *c) 652 { 653 default_ptype_flags.print_methods = print_methods; 654 } 655 656 static void 657 show_print_type_methods (struct ui_file *file, int from_tty, 658 struct cmd_list_element *c, const char *value) 659 { 660 fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"), 661 value); 662 } 663 664 static int print_typedefs = 1; 665 666 static void 667 set_print_type_typedefs (char *args, int from_tty, struct cmd_list_element *c) 668 { 669 default_ptype_flags.print_typedefs = print_typedefs; 670 } 671 672 static void 673 show_print_type_typedefs (struct ui_file *file, int from_tty, 674 struct cmd_list_element *c, const char *value) 675 { 676 fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"), 677 value); 678 } 679 680 void 681 _initialize_typeprint (void) 682 { 683 struct cmd_list_element *c; 684 685 c = add_com ("ptype", class_vars, ptype_command, _("\ 686 Print definition of type TYPE.\n\ 687 Usage: ptype[/FLAGS] TYPE-NAME | EXPRESSION\n\ 688 Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\ 689 or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\ 690 The selected stack frame's lexical context is used to look up the name.\n\ 691 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\ 692 \n\ 693 Available FLAGS are:\n\ 694 /r print in \"raw\" form; do not substitute typedefs\n\ 695 /m do not print methods defined in a class\n\ 696 /M print methods defined in a class\n\ 697 /t do not print typedefs defined in a class\n\ 698 /T print typedefs defined in a class")); 699 set_cmd_completer (c, expression_completer); 700 701 c = add_com ("whatis", class_vars, whatis_command, 702 _("Print data type of expression EXP.\n\ 703 Only one level of typedefs is unrolled. See also \"ptype\".")); 704 set_cmd_completer (c, expression_completer); 705 706 add_prefix_cmd ("type", no_class, show_print_type, 707 _("Generic command for showing type-printing settings."), 708 &showprinttypelist, "show print type ", 0, &showprintlist); 709 add_prefix_cmd ("type", no_class, set_print_type, 710 _("Generic command for setting how types print."), 711 &setprinttypelist, "show print type ", 0, &setprintlist); 712 713 add_setshow_boolean_cmd ("methods", no_class, &print_methods, 714 _("\ 715 Set printing of methods defined in classes."), _("\ 716 Show printing of methods defined in classes."), NULL, 717 set_print_type_methods, 718 show_print_type_methods, 719 &setprinttypelist, &showprinttypelist); 720 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs, 721 _("\ 722 Set printing of typedefs defined in classes."), _("\ 723 Show printing of typedefs defined in classes."), NULL, 724 set_print_type_typedefs, 725 show_print_type_typedefs, 726 &setprinttypelist, &showprinttypelist); 727 } 728