gdb/typeprint.c

   1 /* Language independent support for printing types for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2019 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 const struct type_print_options type_print_raw_options =
  41 {
  42   1,                            /* raw */
  43   1,                            /* print_methods */
  44   1,                            /* print_typedefs */
  45   0,                            /* print_offsets */
  46   0,                            /* print_nested_type_limit  */
  47   NULL,                         /* local_typedefs */
  48   NULL,                         /* global_table */
  49   NULL                          /* global_printers */
  50 };
  51
  52 /* The default flags for 'ptype' and 'whatis'.  */
  53
  54 static struct type_print_options default_ptype_flags =
  55 {
  56   0,                            /* raw */
  57   1,                            /* print_methods */
  58   1,                            /* print_typedefs */
  59   0,                            /* print_offsets */
  60   0,                            /* print_nested_type_limit  */
  61   NULL,                         /* local_typedefs */
  62   NULL,                         /* global_table */
  63   NULL                          /* global_printers */
  64 };
  65
  66 \f
  67
  68 /* See typeprint.h.  */
  69
  70 const int print_offset_data::indentation = 23;
  71
  72
  73 /* See typeprint.h.  */
  74
  75 void
  76 print_offset_data::maybe_print_hole (struct ui_file *stream,
  77                                      unsigned int bitpos,
  78                                      const char *for_what)
  79 {
  80   /* We check for END_BITPOS > 0 because there is a specific
  81      scenario when END_BITPOS can be zero and BITPOS can be >
  82      0: when we are dealing with a struct/class with a virtual method.
  83      Because of the vtable, the first field of the struct/class will
  84      have an offset of sizeof (void *) (the size of the vtable).  If
  85      we do not check for END_BITPOS > 0 here, GDB will report
  86      a hole before the first field, which is not accurate.  */
  87   if (end_bitpos > 0 && end_bitpos < bitpos)
  88     {
  89       /* If END_BITPOS is smaller than the current type's
  90          bitpos, it means there's a hole in the struct, so we report
  91          it here.  */
  92       unsigned int hole = bitpos - end_bitpos;
  93       unsigned int hole_byte = hole / TARGET_CHAR_BIT;
  94       unsigned int hole_bit = hole % TARGET_CHAR_BIT;
  95
  96       if (hole_bit > 0)
  97         fprintf_filtered (stream, "/* XXX %2u-bit %s  */\n", hole_bit,
  98                           for_what);
  99
 100       if (hole_byte > 0)
 101         fprintf_filtered (stream, "/* XXX %2u-byte %s */\n", hole_byte,
 102                           for_what);
 103     }
 104 }
 105
 106 /* See typeprint.h.  */
 107
 108 void
 109 print_offset_data::update (struct type *type, unsigned int field_idx,
 110                            struct ui_file *stream)
 111 {
 112   if (field_is_static (&TYPE_FIELD (type, field_idx)))
 113     {
 114       print_spaces_filtered (indentation, stream);
 115       return;
 116     }
 117
 118   struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx));
 119   if (TYPE_CODE (type) == TYPE_CODE_UNION)
 120     {
 121       /* Since union fields don't have the concept of offsets, we just
 122          print their sizes.  */
 123       fprintf_filtered (stream, "/*              %4s */",
 124                         pulongest (TYPE_LENGTH (ftype)));
 125       return;
 126     }
 127
 128   unsigned int bitpos = TYPE_FIELD_BITPOS (type, field_idx);
 129   unsigned int fieldsize_byte = TYPE_LENGTH (ftype);
 130   unsigned int fieldsize_bit = fieldsize_byte * TARGET_CHAR_BIT;
 131
 132   maybe_print_hole (stream, bitpos, "hole");
 133
 134   if (TYPE_FIELD_PACKED (type, field_idx))
 135     {
 136       /* We're dealing with a bitfield.  Print how many bits are left
 137          to be used.  */
 138       unsigned int bitsize = TYPE_FIELD_BITSIZE (type, field_idx);
 139       /* The bitpos relative to the beginning of our container
 140          field.  */
 141       unsigned int relative_bitpos;
 142
 143       /* The following was copied from
 144          value.c:value_primitive_field.  */
 145       if ((bitpos % fieldsize_bit) + bitsize <= fieldsize_bit)
 146         relative_bitpos = bitpos % fieldsize_bit;
 147       else
 148         relative_bitpos = bitpos % TARGET_CHAR_BIT;
 149
 150       /* This is the exact offset (in bits) of this bitfield.  */
 151       unsigned int bit_offset
 152         = (bitpos - relative_bitpos) + offset_bitpos;
 153
 154       /* The position of the field, relative to the beginning of the
 155          struct, and how many bits are left to be used in this
 156          container.  */
 157       fprintf_filtered (stream, "/* %4u:%2u", bit_offset / TARGET_CHAR_BIT,
 158                         fieldsize_bit - (relative_bitpos + bitsize));
 159       fieldsize_bit = bitsize;
 160     }
 161   else
 162     {
 163       /* The position of the field, relative to the beginning of the
 164          struct.  */
 165       fprintf_filtered (stream, "/* %4u",
 166                         (bitpos + offset_bitpos) / TARGET_CHAR_BIT);
 167
 168       fprintf_filtered (stream, "   ");
 169     }
 170
 171   fprintf_filtered (stream, "   |  %4u */", fieldsize_byte);
 172
 173   end_bitpos = bitpos + fieldsize_bit;
 174 }
 175
 176 /* See typeprint.h.  */
 177
 178 void
 179 print_offset_data::finish (struct type *type, int level,
 180                            struct ui_file *stream)
 181 {
 182   unsigned int bitpos = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
 183   maybe_print_hole (stream, bitpos, "padding");
 184
 185   fputs_filtered ("\n", stream);
 186   print_spaces_filtered (level + 4 + print_offset_data::indentation, stream);
 187   fprintf_filtered (stream, "/* total size (bytes): %4s */\n",
 188                     pulongest (TYPE_LENGTH (type)));
 189 }
 190
 191 \f
 192
 193 /* A hash function for a typedef_field.  */
 194
 195 static hashval_t
 196 hash_typedef_field (const void *p)
 197 {
 198   const struct decl_field *tf = (const struct decl_field *) p;
 199   struct type *t = check_typedef (tf->type);
 200
 201   return htab_hash_string (TYPE_SAFE_NAME (t));
 202 }
 203
 204 /* An equality function for a typedef field.  */
 205
 206 static int
 207 eq_typedef_field (const void *a, const void *b)
 208 {
 209   const struct decl_field *tfa = (const struct decl_field *) a;
 210   const struct decl_field *tfb = (const struct decl_field *) b;
 211
 212   return types_equal (tfa->type, tfb->type);
 213 }
 214
 215 /* See typeprint.h.  */
 216
 217 void
 218 typedef_hash_table::recursively_update (struct type *t)
 219 {
 220   int i;
 221
 222   for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
 223     {
 224       struct decl_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
 225       void **slot;
 226
 227       slot = htab_find_slot (m_table, tdef, INSERT);
 228       /* Only add a given typedef name once.  Really this shouldn't
 229          happen; but it is safe enough to do the updates breadth-first
 230          and thus use the most specific typedef.  */
 231       if (*slot == NULL)
 232         *slot = tdef;
 233     }
 234
 235   /* Recurse into superclasses.  */
 236   for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
 237     recursively_update (TYPE_BASECLASS (t, i));
 238 }
 239
 240 /* See typeprint.h.  */
 241
 242 void
 243 typedef_hash_table::add_template_parameters (struct type *t)
 244 {
 245   int i;
 246
 247   for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
 248     {
 249       struct decl_field *tf;
 250       void **slot;
 251
 252       /* We only want type-valued template parameters in the hash.  */
 253       if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
 254         continue;
 255
 256       tf = XOBNEW (&m_storage, struct decl_field);
 257       tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
 258       tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
 259
 260       slot = htab_find_slot (m_table, tf, INSERT);
 261       if (*slot == NULL)
 262         *slot = tf;
 263     }
 264 }
 265
 266 /* See typeprint.h.  */
 267
 268 typedef_hash_table::typedef_hash_table ()
 269 {
 270   m_table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
 271                                NULL, xcalloc, xfree);
 272 }
 273
 274 /* Free a typedef field table.  */
 275
 276 typedef_hash_table::~typedef_hash_table ()
 277 {
 278   htab_delete (m_table);
 279 }
 280
 281 /* Helper function for typedef_hash_table::copy.  */
 282
 283 static int
 284 copy_typedef_hash_element (void **slot, void *nt)
 285 {
 286   htab_t new_table = (htab_t) nt;
 287   void **new_slot;
 288
 289   new_slot = htab_find_slot (new_table, *slot, INSERT);
 290   if (*new_slot == NULL)
 291     *new_slot = *slot;
 292
 293   return 1;
 294 }
 295
 296 /* See typeprint.h.  */
 297
 298 typedef_hash_table::typedef_hash_table (const typedef_hash_table &table)
 299 {
 300   m_table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
 301                                NULL, xcalloc, xfree);
 302   htab_traverse_noresize (table.m_table, copy_typedef_hash_element,
 303                           m_table);
 304 }
 305
 306 /* Look up the type T in the global typedef hash.  If it is found,
 307    return the typedef name.  If it is not found, apply the
 308    type-printers, if any, given by start_script_type_printers and return the
 309    result.  A NULL return means that the name was not found.  */
 310
 311 const char *
 312 typedef_hash_table::find_global_typedef (const struct type_print_options *flags,
 313                                          struct type *t)
 314 {
 315   char *applied;
 316   void **slot;
 317   struct decl_field tf, *new_tf;
 318
 319   if (flags->global_typedefs == NULL)
 320     return NULL;
 321
 322   tf.name = NULL;
 323   tf.type = t;
 324
 325   slot = htab_find_slot (flags->global_typedefs->m_table, &tf, INSERT);
 326   if (*slot != NULL)
 327     {
 328       new_tf = (struct decl_field *) *slot;
 329       return new_tf->name;
 330     }
 331
 332   /* Put an entry into the hash table now, in case
 333      apply_ext_lang_type_printers recurses.  */
 334   new_tf = XOBNEW (&flags->global_typedefs->m_storage, struct decl_field);
 335   new_tf->name = NULL;
 336   new_tf->type = t;
 337
 338   *slot = new_tf;
 339
 340   applied = apply_ext_lang_type_printers (flags->global_printers, t);
 341
 342   if (applied != NULL)
 343     {
 344       new_tf->name
 345         = (const char *) obstack_copy0 (&flags->global_typedefs->m_storage,
 346                                         applied, strlen (applied));
 347       xfree (applied);
 348     }
 349
 350   return new_tf->name;
 351 }
 352
 353 /* See typeprint.h.  */
 354
 355 const char *
 356 typedef_hash_table::find_typedef (const struct type_print_options *flags,
 357                                   struct type *t)
 358 {
 359   if (flags->local_typedefs != NULL)
 360     {
 361       struct decl_field tf, *found;
 362
 363       tf.name = NULL;
 364       tf.type = t;
 365       found = (struct decl_field *) htab_find (flags->local_typedefs->m_table,
 366                                                &tf);
 367
 368       if (found != NULL)
 369         return found->name;
 370     }
 371
 372   return find_global_typedef (flags, t);
 373 }
 374
 375 \f
 376
 377 /* Print a description of a type in the format of a
 378    typedef for the current language.
 379    NEW is the new name for a type TYPE.  */
 380
 381 void
 382 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
 383 {
 384   LA_PRINT_TYPEDEF (type, newobj, stream);
 385 }
 386
 387 /* The default way to print a typedef.  */
 388
 389 void
 390 default_print_typedef (struct type *type, struct symbol *new_symbol,
 391                        struct ui_file *stream)
 392 {
 393   error (_("Language not supported."));
 394 }
 395
 396 /* Print a description of a type TYPE in the form of a declaration of a
 397    variable named VARSTRING.  (VARSTRING is demangled if necessary.)
 398    Output goes to STREAM (via stdio).
 399    If SHOW is positive, we show the contents of the outermost level
 400    of structure even if there is a type name that could be used instead.
 401    If SHOW is negative, we never show the details of elements' types.  */
 402
 403 void
 404 type_print (struct type *type, const char *varstring, struct ui_file *stream,
 405             int show)
 406 {
 407   LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
 408 }
 409
 410 /* Print TYPE to a string, returning it.  The caller is responsible for
 411    freeing the string.  */
 412
 413 std::string
 414 type_to_string (struct type *type)
 415 {
 416   try
 417     {
 418       string_file stb;
 419
 420       type_print (type, "", &stb, -1);
 421       return std::move (stb.string ());
 422     }
 423   catch (const gdb_exception &except)
 424     {
 425     }
 426
 427   return {};
 428 }
 429
 430 /* See typeprint.h.  */
 431
 432 void
 433 type_print_unknown_return_type (struct ui_file *stream)
 434 {
 435   fprintf_filtered (stream, _("<unknown return type>"));
 436 }
 437
 438 /* See typeprint.h.  */
 439
 440 void
 441 error_unknown_type (const char *sym_print_name)
 442 {
 443   error (_("'%s' has unknown type; cast it to its declared type"),
 444          sym_print_name);
 445 }
 446
 447 /* Print type of EXP, or last thing in value history if EXP == NULL.
 448    show is passed to type_print.  */
 449
 450 static void
 451 whatis_exp (const char *exp, int show)
 452 {
 453   struct value *val;
 454   struct type *real_type = NULL;
 455   struct type *type;
 456   int full = 0;
 457   LONGEST top = -1;
 458   int using_enc = 0;
 459   struct value_print_options opts;
 460   struct type_print_options flags = default_ptype_flags;
 461
 462   if (exp)
 463     {
 464       if (*exp == '/')
 465         {
 466           int seen_one = 0;
 467
 468           for (++exp; *exp && !isspace (*exp); ++exp)
 469             {
 470               switch (*exp)
 471                 {
 472                 case 'r':
 473                   flags.raw = 1;
 474                   break;
 475                 case 'm':
 476                   flags.print_methods = 0;
 477                   break;
 478                 case 'M':
 479                   flags.print_methods = 1;
 480                   break;
 481                 case 't':
 482                   flags.print_typedefs = 0;
 483                   break;
 484                 case 'T':
 485                   flags.print_typedefs = 1;
 486                   break;
 487                 case 'o':
 488                   {
 489                     /* Filter out languages which don't implement the
 490                        feature.  */
 491                     if (show > 0
 492                         && (current_language->la_language == language_c
 493                             || current_language->la_language == language_cplus
 494                             || current_language->la_language == language_rust))
 495                       {
 496                         flags.print_offsets = 1;
 497                         flags.print_typedefs = 0;
 498                         flags.print_methods = 0;
 499                       }
 500                     break;
 501                   }
 502                 default:
 503                   error (_("unrecognized flag '%c'"), *exp);
 504                 }
 505               seen_one = 1;
 506             }
 507
 508           if (!*exp && !seen_one)
 509             error (_("flag expected"));
 510           if (!isspace (*exp))
 511             error (_("expected space after format"));
 512           exp = skip_spaces (exp);
 513         }
 514
 515       expression_up expr = parse_expression (exp);
 516
 517       /* The behavior of "whatis" depends on whether the user
 518          expression names a type directly, or a language expression
 519          (including variable names).  If the former, then "whatis"
 520          strips one level of typedefs, only.  If an expression,
 521          "whatis" prints the type of the expression without stripping
 522          any typedef level.  "ptype" always strips all levels of
 523          typedefs.  */
 524       if (show == -1 && expr->elts[0].opcode == OP_TYPE)
 525         {
 526           /* The user expression names a type directly.  */
 527           type = expr->elts[1].type;
 528
 529           /* If this is a typedef, then find its immediate target.
 530              Use check_typedef to resolve stubs, but ignore its result
 531              because we do not want to dig past all typedefs.  */
 532           check_typedef (type);
 533           if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 534             type = TYPE_TARGET_TYPE (type);
 535
 536           /* If the expression is actually a type, then there's no
 537              value to fetch the dynamic type from.  */
 538           val = NULL;
 539         }
 540       else
 541         {
 542           /* The user expression names a type indirectly by naming an
 543              object or expression of that type.  Find that
 544              indirectly-named type.  */
 545           val = evaluate_type (expr.get ());
 546           type = value_type (val);
 547         }
 548     }
 549   else
 550     {
 551       val = access_value_history (0);
 552       type = value_type (val);
 553     }
 554
 555   get_user_print_options (&opts);
 556   if (val != NULL && opts.objectprint)
 557     {
 558       if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
 559           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 560         real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
 561       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 562         real_type = value_rtti_type (val, &full, &top, &using_enc);
 563     }
 564
 565   if (flags.print_offsets
 566       && (TYPE_CODE (type) == TYPE_CODE_STRUCT
 567           || TYPE_CODE (type) == TYPE_CODE_UNION))
 568     fprintf_filtered (gdb_stdout, "/* offset    |  size */  ");
 569
 570   printf_filtered ("type = ");
 571
 572   std::unique_ptr<typedef_hash_table> table_holder;
 573   std::unique_ptr<ext_lang_type_printers> printer_holder;
 574   if (!flags.raw)
 575     {
 576       table_holder.reset (new typedef_hash_table);
 577       flags.global_typedefs = table_holder.get ();
 578
 579       printer_holder.reset (new ext_lang_type_printers);
 580       flags.global_printers = printer_holder.get ();
 581     }
 582
 583   if (real_type)
 584     {
 585       printf_filtered ("/* real type = ");
 586       type_print (real_type, "", gdb_stdout, -1);
 587       if (! full)
 588         printf_filtered (" (incomplete object)");
 589       printf_filtered (" */\n");
 590     }
 591
 592   LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
 593   printf_filtered ("\n");
 594 }
 595
 596 static void
 597 whatis_command (const char *exp, int from_tty)
 598 {
 599   /* Most of the time users do not want to see all the fields
 600      in a structure.  If they do they can use the "ptype" command.
 601      Hence the "-1" below.  */
 602   whatis_exp (exp, -1);
 603 }
 604
 605 /* TYPENAME is either the name of a type, or an expression.  */
 606
 607 static void
 608 ptype_command (const char *type_name, int from_tty)
 609 {
 610   whatis_exp (type_name, 1);
 611 }
 612
 613 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
 614    Used to print data from type structures in a specified type.  For example,
 615    array bounds may be characters or booleans in some languages, and this
 616    allows the ranges to be printed in their "natural" form rather than as
 617    decimal integer values.
 618
 619    FIXME:  This is here simply because only the type printing routines
 620    currently use it, and it wasn't clear if it really belonged somewhere
 621    else (like printcmd.c).  There are a lot of other gdb routines that do
 622    something similar, but they are generally concerned with printing values
 623    that come from the inferior in target byte order and target size.  */
 624
 625 void
 626 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 627 {
 628   unsigned int i;
 629   unsigned len;
 630
 631   type = check_typedef (type);
 632
 633   switch (TYPE_CODE (type))
 634     {
 635
 636     case TYPE_CODE_ENUM:
 637       len = TYPE_NFIELDS (type);
 638       for (i = 0; i < len; i++)
 639         {
 640           if (TYPE_FIELD_ENUMVAL (type, i) == val)
 641             {
 642               break;
 643             }
 644         }
 645       if (i < len)
 646         {
 647           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 648         }
 649       else
 650         {
 651           print_longest (stream, 'd', 0, val);
 652         }
 653       break;
 654
 655     case TYPE_CODE_INT:
 656       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 657       break;
 658
 659     case TYPE_CODE_CHAR:
 660       LA_PRINT_CHAR ((unsigned char) val, type, stream);
 661       break;
 662
 663     case TYPE_CODE_BOOL:
 664       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 665       break;
 666
 667     case TYPE_CODE_RANGE:
 668       print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
 669       return;
 670
 671     case TYPE_CODE_UNDEF:
 672     case TYPE_CODE_PTR:
 673     case TYPE_CODE_ARRAY:
 674     case TYPE_CODE_STRUCT:
 675     case TYPE_CODE_UNION:
 676     case TYPE_CODE_FUNC:
 677     case TYPE_CODE_FLT:
 678     case TYPE_CODE_VOID:
 679     case TYPE_CODE_SET:
 680     case TYPE_CODE_STRING:
 681     case TYPE_CODE_ERROR:
 682     case TYPE_CODE_MEMBERPTR:
 683     case TYPE_CODE_METHODPTR:
 684     case TYPE_CODE_METHOD:
 685     case TYPE_CODE_REF:
 686     case TYPE_CODE_RVALUE_REF:
 687     case TYPE_CODE_NAMESPACE:
 688       error (_("internal error: unhandled type in print_type_scalar"));
 689       break;
 690
 691     default:
 692       error (_("Invalid type code in symbol table."));
 693     }
 694 }
 695
 696 /* Dump details of a type specified either directly or indirectly.
 697    Uses the same sort of type lookup mechanism as ptype_command()
 698    and whatis_command().  */
 699
 700 void
 701 maintenance_print_type (const char *type_name, int from_tty)
 702 {
 703   struct value *val;
 704   struct type *type;
 705
 706   if (type_name != NULL)
 707     {
 708       expression_up expr = parse_expression (type_name);
 709       if (expr->elts[0].opcode == OP_TYPE)
 710         {
 711           /* The user expression names a type directly, just use that type.  */
 712           type = expr->elts[1].type;
 713         }
 714       else
 715         {
 716           /* The user expression may name a type indirectly by naming an
 717              object of that type.  Find that indirectly named type.  */
 718           val = evaluate_type (expr.get ());
 719           type = value_type (val);
 720         }
 721       if (type != NULL)
 722         {
 723           recursive_dump_type (type, 0);
 724         }
 725     }
 726 }
 727 \f
 728
 729 struct cmd_list_element *setprinttypelist;
 730
 731 struct cmd_list_element *showprinttypelist;
 732
 733 static void
 734 set_print_type (const char *arg, int from_tty)
 735 {
 736   printf_unfiltered (
 737      "\"set print type\" must be followed by the name of a subcommand.\n");
 738   help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
 739 }
 740
 741 static void
 742 show_print_type (const char *args, int from_tty)
 743 {
 744   cmd_show_list (showprinttypelist, from_tty, "");
 745 }
 746
 747 static int print_methods = 1;
 748
 749 static void
 750 set_print_type_methods (const char *args,
 751                         int from_tty, struct cmd_list_element *c)
 752 {
 753   default_ptype_flags.print_methods = print_methods;
 754 }
 755
 756 static void
 757 show_print_type_methods (struct ui_file *file, int from_tty,
 758                          struct cmd_list_element *c, const char *value)
 759 {
 760   fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
 761                     value);
 762 }
 763
 764 static int print_typedefs = 1;
 765
 766 static void
 767 set_print_type_typedefs (const char *args,
 768                          int from_tty, struct cmd_list_element *c)
 769 {
 770   default_ptype_flags.print_typedefs = print_typedefs;
 771 }
 772
 773 static void
 774 show_print_type_typedefs (struct ui_file *file, int from_tty,
 775                          struct cmd_list_element *c, const char *value)
 776 {
 777   fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
 778                     value);
 779 }
 780
 781 /* Limit on the number of nested type definitions to print or -1 to print
 782    all nested type definitions in a class.  By default, we do not print
 783    nested definitions.  */
 784
 785 static int print_nested_type_limit = 0;
 786
 787 /* Set how many nested type definitions should be printed by the type
 788    printer.  */
 789
 790 static void
 791 set_print_type_nested_types (const char *args, int from_tty,
 792                              struct cmd_list_element *c)
 793 {
 794   default_ptype_flags.print_nested_type_limit = print_nested_type_limit;
 795 }
 796
 797 /* Show how many nested type definitions the type printer will print.  */
 798
 799 static void
 800 show_print_type_nested_types  (struct ui_file *file, int from_tty,
 801                                struct cmd_list_element *c, const char *value)
 802 {
 803   if (*value == '0')
 804     {
 805       fprintf_filtered (file,
 806                         _("Will not print nested types defined in a class\n"));
 807     }
 808   else
 809     {
 810       fprintf_filtered (file,
 811                         _("Will print %s nested types defined in a class\n"),
 812                         value);
 813     }
 814 }
 815
 816 void
 817 _initialize_typeprint (void)
 818 {
 819   struct cmd_list_element *c;
 820
 821   c = add_com ("ptype", class_vars, ptype_command, _("\
 822 Print definition of type TYPE.\n\
 823 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
 824 Argument may be any type (for example a type name defined by typedef,\n\
 825 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
 826 or \"enum ENUM-TAG\") or an expression.\n\
 827 The selected stack frame's lexical context is used to look up the name.\n\
 828 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
 829 \n\
 830 Available FLAGS are:\n\
 831   /r    print in \"raw\" form; do not substitute typedefs\n\
 832   /m    do not print methods defined in a class\n\
 833   /M    print methods defined in a class\n\
 834   /t    do not print typedefs defined in a class\n\
 835   /T    print typedefs defined in a class\n\
 836   /o    print offsets and sizes of fields in a struct (like pahole)\n"));
 837   set_cmd_completer (c, expression_completer);
 838
 839   c = add_com ("whatis", class_vars, whatis_command,
 840                _("Print data type of expression EXP.\n\
 841 Only one level of typedefs is unrolled.  See also \"ptype\"."));
 842   set_cmd_completer (c, expression_completer);
 843
 844   add_prefix_cmd ("type", no_class, show_print_type,
 845                   _("Generic command for showing type-printing settings."),
 846                   &showprinttypelist, "show print type ", 0, &showprintlist);
 847   add_prefix_cmd ("type", no_class, set_print_type,
 848                   _("Generic command for setting how types print."),
 849                   &setprinttypelist, "set print type ", 0, &setprintlist);
 850
 851   add_setshow_boolean_cmd ("methods", no_class, &print_methods,
 852                            _("\
 853 Set printing of methods defined in classes."), _("\
 854 Show printing of methods defined in classes."), NULL,
 855                            set_print_type_methods,
 856                            show_print_type_methods,
 857                            &setprinttypelist, &showprinttypelist);
 858   add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
 859                            _("\
 860 Set printing of typedefs defined in classes."), _("\
 861 Show printing of typedefs defined in classes."), NULL,
 862                            set_print_type_typedefs,
 863                            show_print_type_typedefs,
 864                            &setprinttypelist, &showprinttypelist);
 865
 866   add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
 867                                        &print_nested_type_limit,
 868                                        _("\
 869 Set the number of recursive nested type definitions to print \
 870 (\"unlimited\" or -1 to show all)."), _("\
 871 Show the number of recursive nested type definitions to print."), NULL,
 872                                        set_print_type_nested_types,
 873                                        show_print_type_nested_types,
 874                                        &setprinttypelist, &showprinttypelist);
 875 }
 876
 877 /* Print <not allocated> status to stream STREAM.  */
 878
 879 void
 880 val_print_not_allocated (struct ui_file *stream)
 881 {
 882   fprintf_filtered (stream, _("<not allocated>"));
 883 }
 884
 885 /* Print <not associated> status to stream STREAM.  */
 886
 887 void
 888 val_print_not_associated (struct ui_file *stream)
 889 {
 890   fprintf_filtered (stream, _("<not associated>"));
 891 }