gdb/typeprint.c

   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 \f
  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 \f
 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 \f
 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 | EXPRESSION\n\
 688 Argument may be any type (for example a type name defined by typedef,\n\
 689 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
 690 or \"enum ENUM-TAG\") or an expression.\n\
 691 The selected stack frame's lexical context is used to look up the name.\n\
 692 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
 693 \n\
 694 Available FLAGS are:\n\
 695   /r    print in \"raw\" form; do not substitute typedefs\n\
 696   /m    do not print methods defined in a class\n\
 697   /M    print methods defined in a class\n\
 698   /t    do not print typedefs defined in a class\n\
 699   /T    print typedefs defined in a class"));
 700   set_cmd_completer (c, expression_completer);
 701
 702   c = add_com ("whatis", class_vars, whatis_command,
 703                _("Print data type of expression EXP.\n\
 704 Only one level of typedefs is unrolled.  See also \"ptype\"."));
 705   set_cmd_completer (c, expression_completer);
 706
 707   add_prefix_cmd ("type", no_class, show_print_type,
 708                   _("Generic command for showing type-printing settings."),
 709                   &showprinttypelist, "show print type ", 0, &showprintlist);
 710   add_prefix_cmd ("type", no_class, set_print_type,
 711                   _("Generic command for setting how types print."),
 712                   &setprinttypelist, "show print type ", 0, &setprintlist);
 713
 714   add_setshow_boolean_cmd ("methods", no_class, &print_methods,
 715                            _("\
 716 Set printing of methods defined in classes."), _("\
 717 Show printing of methods defined in classes."), NULL,
 718                            set_print_type_methods,
 719                            show_print_type_methods,
 720                            &setprinttypelist, &showprinttypelist);
 721   add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
 722                            _("\
 723 Set printing of typedefs defined in classes."), _("\
 724 Show printing of typedefs defined in classes."), NULL,
 725                            set_print_type_typedefs,
 726                            show_print_type_typedefs,
 727                            &setprinttypelist, &showprinttypelist);
 728 }