1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
25 #include "expression.h"
33 #include "typeprint.h"
36 #include "cli/cli-utils.h"
37 #include "extension.h"
38 #include "completer.h"
40 const struct type_print_options type_print_raw_options =
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 */
52 /* The default flags for 'ptype' and 'whatis'. */
54 static struct type_print_options default_ptype_flags =
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 */
68 /* See typeprint.h. */
70 const int print_offset_data::indentation = 23;
73 /* See typeprint.h. */
76 print_offset_data::maybe_print_hole (struct ui_file *stream,
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)
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
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;
97 fprintf_filtered (stream, "/* XXX %2u-bit %s */\n", hole_bit,
101 fprintf_filtered (stream, "/* XXX %2u-byte %s */\n", hole_byte,
106 /* See typeprint.h. */
109 print_offset_data::update (struct type *type, unsigned int field_idx,
110 struct ui_file *stream)
112 if (field_is_static (&TYPE_FIELD (type, field_idx)))
114 print_spaces_filtered (indentation, stream);
118 struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx));
119 if (TYPE_CODE (type) == TYPE_CODE_UNION)
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)));
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;
132 maybe_print_hole (stream, bitpos, "hole");
134 if (TYPE_FIELD_PACKED (type, field_idx)
135 || offset_bitpos % TARGET_CHAR_BIT != 0)
137 /* We're dealing with a bitfield. Print the bit offset. */
138 fieldsize_bit = TYPE_FIELD_BITSIZE (type, field_idx);
140 unsigned real_bitpos = bitpos + offset_bitpos;
142 fprintf_filtered (stream, "/* %4u:%2u", real_bitpos / TARGET_CHAR_BIT,
143 real_bitpos % TARGET_CHAR_BIT);
147 /* The position of the field, relative to the beginning of the
149 fprintf_filtered (stream, "/* %4u",
150 (bitpos + offset_bitpos) / TARGET_CHAR_BIT);
152 fprintf_filtered (stream, " ");
155 fprintf_filtered (stream, " | %4u */", fieldsize_byte);
157 end_bitpos = bitpos + fieldsize_bit;
160 /* See typeprint.h. */
163 print_offset_data::finish (struct type *type, int level,
164 struct ui_file *stream)
166 unsigned int bitpos = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
167 maybe_print_hole (stream, bitpos, "padding");
169 fputs_filtered ("\n", stream);
170 print_spaces_filtered (level + 4 + print_offset_data::indentation, stream);
171 fprintf_filtered (stream, "/* total size (bytes): %4s */\n",
172 pulongest (TYPE_LENGTH (type)));
177 /* A hash function for a typedef_field. */
180 hash_typedef_field (const void *p)
182 const struct decl_field *tf = (const struct decl_field *) p;
183 struct type *t = check_typedef (tf->type);
185 return htab_hash_string (TYPE_SAFE_NAME (t));
188 /* An equality function for a typedef field. */
191 eq_typedef_field (const void *a, const void *b)
193 const struct decl_field *tfa = (const struct decl_field *) a;
194 const struct decl_field *tfb = (const struct decl_field *) b;
196 return types_equal (tfa->type, tfb->type);
199 /* See typeprint.h. */
202 typedef_hash_table::recursively_update (struct type *t)
206 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
208 struct decl_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
211 slot = htab_find_slot (m_table, tdef, INSERT);
212 /* Only add a given typedef name once. Really this shouldn't
213 happen; but it is safe enough to do the updates breadth-first
214 and thus use the most specific typedef. */
219 /* Recurse into superclasses. */
220 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
221 recursively_update (TYPE_BASECLASS (t, i));
224 /* See typeprint.h. */
227 typedef_hash_table::add_template_parameters (struct type *t)
231 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
233 struct decl_field *tf;
236 /* We only want type-valued template parameters in the hash. */
237 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
240 tf = XOBNEW (&m_storage, struct decl_field);
241 tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
242 tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
244 slot = htab_find_slot (m_table, tf, INSERT);
250 /* See typeprint.h. */
252 typedef_hash_table::typedef_hash_table ()
254 m_table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
255 NULL, xcalloc, xfree);
258 /* Free a typedef field table. */
260 typedef_hash_table::~typedef_hash_table ()
262 htab_delete (m_table);
265 /* Helper function for typedef_hash_table::copy. */
268 copy_typedef_hash_element (void **slot, void *nt)
270 htab_t new_table = (htab_t) nt;
273 new_slot = htab_find_slot (new_table, *slot, INSERT);
274 if (*new_slot == NULL)
280 /* See typeprint.h. */
282 typedef_hash_table::typedef_hash_table (const typedef_hash_table &table)
284 m_table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
285 NULL, xcalloc, xfree);
286 htab_traverse_noresize (table.m_table, copy_typedef_hash_element,
290 /* Look up the type T in the global typedef hash. If it is found,
291 return the typedef name. If it is not found, apply the
292 type-printers, if any, given by start_script_type_printers and return the
293 result. A NULL return means that the name was not found. */
296 typedef_hash_table::find_global_typedef (const struct type_print_options *flags,
301 struct decl_field tf, *new_tf;
303 if (flags->global_typedefs == NULL)
309 slot = htab_find_slot (flags->global_typedefs->m_table, &tf, INSERT);
312 new_tf = (struct decl_field *) *slot;
316 /* Put an entry into the hash table now, in case
317 apply_ext_lang_type_printers recurses. */
318 new_tf = XOBNEW (&flags->global_typedefs->m_storage, struct decl_field);
324 applied = apply_ext_lang_type_printers (flags->global_printers, t);
328 new_tf->name = obstack_strdup (&flags->global_typedefs->m_storage,
336 /* See typeprint.h. */
339 typedef_hash_table::find_typedef (const struct type_print_options *flags,
342 if (flags->local_typedefs != NULL)
344 struct decl_field tf, *found;
348 found = (struct decl_field *) htab_find (flags->local_typedefs->m_table,
355 return find_global_typedef (flags, t);
360 /* Print a description of a type in the format of a
361 typedef for the current language.
362 NEW is the new name for a type TYPE. */
365 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
367 LA_PRINT_TYPEDEF (type, newobj, stream);
370 /* The default way to print a typedef. */
373 default_print_typedef (struct type *type, struct symbol *new_symbol,
374 struct ui_file *stream)
376 error (_("Language not supported."));
379 /* Print a description of a type TYPE in the form of a declaration of a
380 variable named VARSTRING. (VARSTRING is demangled if necessary.)
381 Output goes to STREAM (via stdio).
382 If SHOW is positive, we show the contents of the outermost level
383 of structure even if there is a type name that could be used instead.
384 If SHOW is negative, we never show the details of elements' types. */
387 type_print (struct type *type, const char *varstring, struct ui_file *stream,
390 LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
393 /* Print TYPE to a string, returning it. The caller is responsible for
394 freeing the string. */
397 type_to_string (struct type *type)
403 type_print (type, "", &stb, -1);
404 return std::move (stb.string ());
406 catch (const gdb_exception &except)
413 /* See typeprint.h. */
416 type_print_unknown_return_type (struct ui_file *stream)
418 fprintf_filtered (stream, _("<unknown return type>"));
421 /* See typeprint.h. */
424 error_unknown_type (const char *sym_print_name)
426 error (_("'%s' has unknown type; cast it to its declared type"),
430 /* Print type of EXP, or last thing in value history if EXP == NULL.
431 show is passed to type_print. */
434 whatis_exp (const char *exp, int show)
437 struct type *real_type = NULL;
442 struct value_print_options opts;
443 struct type_print_options flags = default_ptype_flags;
451 for (++exp; *exp && !isspace (*exp); ++exp)
459 flags.print_methods = 0;
462 flags.print_methods = 1;
465 flags.print_typedefs = 0;
468 flags.print_typedefs = 1;
472 /* Filter out languages which don't implement the
475 && (current_language->la_language == language_c
476 || current_language->la_language == language_cplus
477 || current_language->la_language == language_rust))
479 flags.print_offsets = 1;
480 flags.print_typedefs = 0;
481 flags.print_methods = 0;
486 error (_("unrecognized flag '%c'"), *exp);
491 if (!*exp && !seen_one)
492 error (_("flag expected"));
494 error (_("expected space after format"));
495 exp = skip_spaces (exp);
498 expression_up expr = parse_expression (exp);
500 /* The behavior of "whatis" depends on whether the user
501 expression names a type directly, or a language expression
502 (including variable names). If the former, then "whatis"
503 strips one level of typedefs, only. If an expression,
504 "whatis" prints the type of the expression without stripping
505 any typedef level. "ptype" always strips all levels of
507 if (show == -1 && expr->elts[0].opcode == OP_TYPE)
509 /* The user expression names a type directly. */
510 type = expr->elts[1].type;
512 /* If this is a typedef, then find its immediate target.
513 Use check_typedef to resolve stubs, but ignore its result
514 because we do not want to dig past all typedefs. */
515 check_typedef (type);
516 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
517 type = TYPE_TARGET_TYPE (type);
519 /* If the expression is actually a type, then there's no
520 value to fetch the dynamic type from. */
525 /* The user expression names a type indirectly by naming an
526 object or expression of that type. Find that
527 indirectly-named type. */
528 val = evaluate_type (expr.get ());
529 type = value_type (val);
534 val = access_value_history (0);
535 type = value_type (val);
538 get_user_print_options (&opts);
539 if (val != NULL && opts.objectprint)
541 if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
542 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
543 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
544 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
545 real_type = value_rtti_type (val, &full, &top, &using_enc);
548 if (flags.print_offsets
549 && (TYPE_CODE (type) == TYPE_CODE_STRUCT
550 || TYPE_CODE (type) == TYPE_CODE_UNION))
551 fprintf_filtered (gdb_stdout, "/* offset | size */ ");
553 printf_filtered ("type = ");
555 std::unique_ptr<typedef_hash_table> table_holder;
556 std::unique_ptr<ext_lang_type_printers> printer_holder;
559 table_holder.reset (new typedef_hash_table);
560 flags.global_typedefs = table_holder.get ();
562 printer_holder.reset (new ext_lang_type_printers);
563 flags.global_printers = printer_holder.get ();
568 printf_filtered ("/* real type = ");
569 type_print (real_type, "", gdb_stdout, -1);
571 printf_filtered (" (incomplete object)");
572 printf_filtered (" */\n");
575 LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
576 printf_filtered ("\n");
580 whatis_command (const char *exp, int from_tty)
582 /* Most of the time users do not want to see all the fields
583 in a structure. If they do they can use the "ptype" command.
584 Hence the "-1" below. */
585 whatis_exp (exp, -1);
588 /* TYPENAME is either the name of a type, or an expression. */
591 ptype_command (const char *type_name, int from_tty)
593 whatis_exp (type_name, 1);
596 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
597 Used to print data from type structures in a specified type. For example,
598 array bounds may be characters or booleans in some languages, and this
599 allows the ranges to be printed in their "natural" form rather than as
600 decimal integer values.
602 FIXME: This is here simply because only the type printing routines
603 currently use it, and it wasn't clear if it really belonged somewhere
604 else (like printcmd.c). There are a lot of other gdb routines that do
605 something similar, but they are generally concerned with printing values
606 that come from the inferior in target byte order and target size. */
609 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
614 type = check_typedef (type);
616 switch (TYPE_CODE (type))
620 len = TYPE_NFIELDS (type);
621 for (i = 0; i < len; i++)
623 if (TYPE_FIELD_ENUMVAL (type, i) == val)
630 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
634 print_longest (stream, 'd', 0, val);
639 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
643 LA_PRINT_CHAR ((unsigned char) val, type, stream);
647 fprintf_filtered (stream, val ? "TRUE" : "FALSE");
650 case TYPE_CODE_RANGE:
651 print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
654 case TYPE_CODE_UNDEF:
656 case TYPE_CODE_ARRAY:
657 case TYPE_CODE_STRUCT:
658 case TYPE_CODE_UNION:
663 case TYPE_CODE_STRING:
664 case TYPE_CODE_ERROR:
665 case TYPE_CODE_MEMBERPTR:
666 case TYPE_CODE_METHODPTR:
667 case TYPE_CODE_METHOD:
669 case TYPE_CODE_RVALUE_REF:
670 case TYPE_CODE_NAMESPACE:
671 error (_("internal error: unhandled type in print_type_scalar"));
675 error (_("Invalid type code in symbol table."));
679 /* Dump details of a type specified either directly or indirectly.
680 Uses the same sort of type lookup mechanism as ptype_command()
681 and whatis_command(). */
684 maintenance_print_type (const char *type_name, int from_tty)
689 if (type_name != NULL)
691 expression_up expr = parse_expression (type_name);
692 if (expr->elts[0].opcode == OP_TYPE)
694 /* The user expression names a type directly, just use that type. */
695 type = expr->elts[1].type;
699 /* The user expression may name a type indirectly by naming an
700 object of that type. Find that indirectly named type. */
701 val = evaluate_type (expr.get ());
702 type = value_type (val);
706 recursive_dump_type (type, 0);
712 struct cmd_list_element *setprinttypelist;
714 struct cmd_list_element *showprinttypelist;
717 set_print_type (const char *arg, int from_tty)
720 "\"set print type\" must be followed by the name of a subcommand.\n");
721 help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
725 show_print_type (const char *args, int from_tty)
727 cmd_show_list (showprinttypelist, from_tty, "");
730 static int print_methods = 1;
733 set_print_type_methods (const char *args,
734 int from_tty, struct cmd_list_element *c)
736 default_ptype_flags.print_methods = print_methods;
740 show_print_type_methods (struct ui_file *file, int from_tty,
741 struct cmd_list_element *c, const char *value)
743 fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
747 static int print_typedefs = 1;
750 set_print_type_typedefs (const char *args,
751 int from_tty, struct cmd_list_element *c)
753 default_ptype_flags.print_typedefs = print_typedefs;
757 show_print_type_typedefs (struct ui_file *file, int from_tty,
758 struct cmd_list_element *c, const char *value)
760 fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
764 /* Limit on the number of nested type definitions to print or -1 to print
765 all nested type definitions in a class. By default, we do not print
766 nested definitions. */
768 static int print_nested_type_limit = 0;
770 /* Set how many nested type definitions should be printed by the type
774 set_print_type_nested_types (const char *args, int from_tty,
775 struct cmd_list_element *c)
777 default_ptype_flags.print_nested_type_limit = print_nested_type_limit;
780 /* Show how many nested type definitions the type printer will print. */
783 show_print_type_nested_types (struct ui_file *file, int from_tty,
784 struct cmd_list_element *c, const char *value)
788 fprintf_filtered (file,
789 _("Will not print nested types defined in a class\n"));
793 fprintf_filtered (file,
794 _("Will print %s nested types defined in a class\n"),
800 _initialize_typeprint (void)
802 struct cmd_list_element *c;
804 c = add_com ("ptype", class_vars, ptype_command, _("\
805 Print definition of type TYPE.\n\
806 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
807 Argument may be any type (for example a type name defined by typedef,\n\
808 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
809 or \"enum ENUM-TAG\") or an expression.\n\
810 The selected stack frame's lexical context is used to look up the name.\n\
811 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
813 Available FLAGS are:\n\
814 /r print in \"raw\" form; do not substitute typedefs\n\
815 /m do not print methods defined in a class\n\
816 /M print methods defined in a class\n\
817 /t do not print typedefs defined in a class\n\
818 /T print typedefs defined in a class\n\
819 /o print offsets and sizes of fields in a struct (like pahole)"));
820 set_cmd_completer (c, expression_completer);
822 c = add_com ("whatis", class_vars, whatis_command,
823 _("Print data type of expression EXP.\n\
824 Only one level of typedefs is unrolled. See also \"ptype\"."));
825 set_cmd_completer (c, expression_completer);
827 add_prefix_cmd ("type", no_class, show_print_type,
828 _("Generic command for showing type-printing settings."),
829 &showprinttypelist, "show print type ", 0, &showprintlist);
830 add_prefix_cmd ("type", no_class, set_print_type,
831 _("Generic command for setting how types print."),
832 &setprinttypelist, "set print type ", 0, &setprintlist);
834 add_setshow_boolean_cmd ("methods", no_class, &print_methods,
836 Set printing of methods defined in classes."), _("\
837 Show printing of methods defined in classes."), NULL,
838 set_print_type_methods,
839 show_print_type_methods,
840 &setprinttypelist, &showprinttypelist);
841 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
843 Set printing of typedefs defined in classes."), _("\
844 Show printing of typedefs defined in classes."), NULL,
845 set_print_type_typedefs,
846 show_print_type_typedefs,
847 &setprinttypelist, &showprinttypelist);
849 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
850 &print_nested_type_limit,
852 Set the number of recursive nested type definitions to print \
853 (\"unlimited\" or -1 to show all)."), _("\
854 Show the number of recursive nested type definitions to print."), NULL,
855 set_print_type_nested_types,
856 show_print_type_nested_types,
857 &setprinttypelist, &showprinttypelist);
860 /* Print <not allocated> status to stream STREAM. */
863 val_print_not_allocated (struct ui_file *stream)
865 fprintf_filtered (stream, _("<not allocated>"));
868 /* Print <not associated> status to stream STREAM. */
871 val_print_not_associated (struct ui_file *stream)
873 fprintf_filtered (stream, _("<not associated>"));