gdb/typeprint.c

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