gdb/typeprint.c

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