gdb/typeprint.c

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