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
))
136 /* We're dealing with a bitfield. Print how many bits are left
138 unsigned int bitsize
= TYPE_FIELD_BITSIZE (type
, field_idx
);
139 /* The bitpos relative to the beginning of our container
141 unsigned int relative_bitpos
;
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
;
148 relative_bitpos
= bitpos
% TARGET_CHAR_BIT
;
150 /* This is the exact offset (in bits) of this bitfield. */
151 unsigned int bit_offset
152 = (bitpos
- relative_bitpos
) + offset_bitpos
;
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
157 fprintf_filtered (stream
, "/* %4u:%2u", bit_offset
/ TARGET_CHAR_BIT
,
158 fieldsize_bit
- (relative_bitpos
+ bitsize
));
159 fieldsize_bit
= bitsize
;
163 /* The position of the field, relative to the beginning of the
165 fprintf_filtered (stream
, "/* %4u",
166 (bitpos
+ offset_bitpos
) / TARGET_CHAR_BIT
);
168 fprintf_filtered (stream
, " ");
171 fprintf_filtered (stream
, " | %4u */", fieldsize_byte
);
173 end_bitpos
= bitpos
+ fieldsize_bit
;
176 /* See typeprint.h. */
179 print_offset_data::finish (struct type
*type
, int level
,
180 struct ui_file
*stream
)
182 unsigned int bitpos
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
183 maybe_print_hole (stream
, bitpos
, "padding");
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
)));
193 /* A hash function for a typedef_field. */
196 hash_typedef_field (const void *p
)
198 const struct decl_field
*tf
= (const struct decl_field
*) p
;
199 struct type
*t
= check_typedef (tf
->type
);
201 return htab_hash_string (TYPE_SAFE_NAME (t
));
204 /* An equality function for a typedef field. */
207 eq_typedef_field (const void *a
, const void *b
)
209 const struct decl_field
*tfa
= (const struct decl_field
*) a
;
210 const struct decl_field
*tfb
= (const struct decl_field
*) b
;
212 return types_equal (tfa
->type
, tfb
->type
);
215 /* See typeprint.h. */
218 typedef_hash_table::recursively_update (struct type
*t
)
222 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
224 struct decl_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
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. */
235 /* Recurse into superclasses. */
236 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
237 recursively_update (TYPE_BASECLASS (t
, i
));
240 /* See typeprint.h. */
243 typedef_hash_table::add_template_parameters (struct type
*t
)
247 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
249 struct decl_field
*tf
;
252 /* We only want type-valued template parameters in the hash. */
253 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t
, i
)) != LOC_TYPEDEF
)
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
));
260 slot
= htab_find_slot (m_table
, tf
, INSERT
);
266 /* See typeprint.h. */
268 typedef_hash_table::typedef_hash_table ()
270 m_table
= htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
271 NULL
, xcalloc
, xfree
);
274 /* Free a typedef field table. */
276 typedef_hash_table::~typedef_hash_table ()
278 htab_delete (m_table
);
281 /* Helper function for typedef_hash_table::copy. */
284 copy_typedef_hash_element (void **slot
, void *nt
)
286 htab_t new_table
= (htab_t
) nt
;
289 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
290 if (*new_slot
== NULL
)
296 /* See typeprint.h. */
298 typedef_hash_table::typedef_hash_table (const typedef_hash_table
&table
)
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
,
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. */
312 typedef_hash_table::find_global_typedef (const struct type_print_options
*flags
,
317 struct decl_field tf
, *new_tf
;
319 if (flags
->global_typedefs
== NULL
)
325 slot
= htab_find_slot (flags
->global_typedefs
->m_table
, &tf
, INSERT
);
328 new_tf
= (struct decl_field
*) *slot
;
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
);
340 applied
= apply_ext_lang_type_printers (flags
->global_printers
, t
);
345 = (const char *) obstack_copy0 (&flags
->global_typedefs
->m_storage
,
346 applied
, strlen (applied
));
353 /* See typeprint.h. */
356 typedef_hash_table::find_typedef (const struct type_print_options
*flags
,
359 if (flags
->local_typedefs
!= NULL
)
361 struct decl_field tf
, *found
;
365 found
= (struct decl_field
*) htab_find (flags
->local_typedefs
->m_table
,
372 return find_global_typedef (flags
, t
);
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. */
382 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
384 LA_PRINT_TYPEDEF (type
, newobj
, stream
);
387 /* The default way to print a typedef. */
390 default_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
391 struct ui_file
*stream
)
393 error (_("Language not supported."));
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. */
404 type_print (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
407 LA_PRINT_TYPE (type
, varstring
, stream
, show
, 0, &default_ptype_flags
);
410 /* Print TYPE to a string, returning it. The caller is responsible for
411 freeing the string. */
414 type_to_string (struct type
*type
)
420 type_print (type
, "", &stb
, -1);
421 return std::move (stb
.string ());
423 CATCH (except
, RETURN_MASK_ALL
)
431 /* See typeprint.h. */
434 type_print_unknown_return_type (struct ui_file
*stream
)
436 fprintf_filtered (stream
, _("<unknown return type>"));
439 /* See typeprint.h. */
442 error_unknown_type (const char *sym_print_name
)
444 error (_("'%s' has unknown type; cast it to its declared type"),
448 /* Print type of EXP, or last thing in value history if EXP == NULL.
449 show is passed to type_print. */
452 whatis_exp (const char *exp
, int show
)
455 struct type
*real_type
= NULL
;
460 struct value_print_options opts
;
461 struct type_print_options flags
= default_ptype_flags
;
469 for (++exp
; *exp
&& !isspace (*exp
); ++exp
)
477 flags
.print_methods
= 0;
480 flags
.print_methods
= 1;
483 flags
.print_typedefs
= 0;
486 flags
.print_typedefs
= 1;
490 /* Filter out languages which don't implement the
493 && (current_language
->la_language
== language_c
494 || current_language
->la_language
== language_cplus
495 || current_language
->la_language
== language_rust
))
497 flags
.print_offsets
= 1;
498 flags
.print_typedefs
= 0;
499 flags
.print_methods
= 0;
504 error (_("unrecognized flag '%c'"), *exp
);
509 if (!*exp
&& !seen_one
)
510 error (_("flag expected"));
512 error (_("expected space after format"));
513 exp
= skip_spaces (exp
);
516 expression_up expr
= parse_expression (exp
);
518 /* The behavior of "whatis" depends on whether the user
519 expression names a type directly, or a language expression
520 (including variable names). If the former, then "whatis"
521 strips one level of typedefs, only. If an expression,
522 "whatis" prints the type of the expression without stripping
523 any typedef level. "ptype" always strips all levels of
525 if (show
== -1 && expr
->elts
[0].opcode
== OP_TYPE
)
527 /* The user expression names a type directly. */
528 type
= expr
->elts
[1].type
;
530 /* If this is a typedef, then find its immediate target.
531 Use check_typedef to resolve stubs, but ignore its result
532 because we do not want to dig past all typedefs. */
533 check_typedef (type
);
534 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
535 type
= TYPE_TARGET_TYPE (type
);
537 /* If the expression is actually a type, then there's no
538 value to fetch the dynamic type from. */
543 /* The user expression names a type indirectly by naming an
544 object or expression of that type. Find that
545 indirectly-named type. */
546 val
= evaluate_type (expr
.get ());
547 type
= value_type (val
);
552 val
= access_value_history (0);
553 type
= value_type (val
);
556 get_user_print_options (&opts
);
557 if (val
!= NULL
&& opts
.objectprint
)
559 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
560 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
561 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
562 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
563 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
566 if (flags
.print_offsets
567 && (TYPE_CODE (type
) == TYPE_CODE_STRUCT
568 || TYPE_CODE (type
) == TYPE_CODE_UNION
))
569 fprintf_filtered (gdb_stdout
, "/* offset | size */ ");
571 printf_filtered ("type = ");
573 std::unique_ptr
<typedef_hash_table
> table_holder
;
574 std::unique_ptr
<ext_lang_type_printers
> printer_holder
;
577 table_holder
.reset (new typedef_hash_table
);
578 flags
.global_typedefs
= table_holder
.get ();
580 printer_holder
.reset (new ext_lang_type_printers
);
581 flags
.global_printers
= printer_holder
.get ();
586 printf_filtered ("/* real type = ");
587 type_print (real_type
, "", gdb_stdout
, -1);
589 printf_filtered (" (incomplete object)");
590 printf_filtered (" */\n");
593 LA_PRINT_TYPE (type
, "", gdb_stdout
, show
, 0, &flags
);
594 printf_filtered ("\n");
598 whatis_command (const char *exp
, int from_tty
)
600 /* Most of the time users do not want to see all the fields
601 in a structure. If they do they can use the "ptype" command.
602 Hence the "-1" below. */
603 whatis_exp (exp
, -1);
606 /* TYPENAME is either the name of a type, or an expression. */
609 ptype_command (const char *type_name
, int from_tty
)
611 whatis_exp (type_name
, 1);
614 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
615 Used to print data from type structures in a specified type. For example,
616 array bounds may be characters or booleans in some languages, and this
617 allows the ranges to be printed in their "natural" form rather than as
618 decimal integer values.
620 FIXME: This is here simply because only the type printing routines
621 currently use it, and it wasn't clear if it really belonged somewhere
622 else (like printcmd.c). There are a lot of other gdb routines that do
623 something similar, but they are generally concerned with printing values
624 that come from the inferior in target byte order and target size. */
627 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
632 type
= check_typedef (type
);
634 switch (TYPE_CODE (type
))
638 len
= TYPE_NFIELDS (type
);
639 for (i
= 0; i
< len
; i
++)
641 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
648 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
652 print_longest (stream
, 'd', 0, val
);
657 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
661 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
665 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
668 case TYPE_CODE_RANGE
:
669 print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
672 case TYPE_CODE_UNDEF
:
674 case TYPE_CODE_ARRAY
:
675 case TYPE_CODE_STRUCT
:
676 case TYPE_CODE_UNION
:
681 case TYPE_CODE_STRING
:
682 case TYPE_CODE_ERROR
:
683 case TYPE_CODE_MEMBERPTR
:
684 case TYPE_CODE_METHODPTR
:
685 case TYPE_CODE_METHOD
:
687 case TYPE_CODE_RVALUE_REF
:
688 case TYPE_CODE_NAMESPACE
:
689 error (_("internal error: unhandled type in print_type_scalar"));
693 error (_("Invalid type code in symbol table."));
697 /* Dump details of a type specified either directly or indirectly.
698 Uses the same sort of type lookup mechanism as ptype_command()
699 and whatis_command(). */
702 maintenance_print_type (const char *type_name
, int from_tty
)
707 if (type_name
!= NULL
)
709 expression_up expr
= parse_expression (type_name
);
710 if (expr
->elts
[0].opcode
== OP_TYPE
)
712 /* The user expression names a type directly, just use that type. */
713 type
= expr
->elts
[1].type
;
717 /* The user expression may name a type indirectly by naming an
718 object of that type. Find that indirectly named type. */
719 val
= evaluate_type (expr
.get ());
720 type
= value_type (val
);
724 recursive_dump_type (type
, 0);
730 struct cmd_list_element
*setprinttypelist
;
732 struct cmd_list_element
*showprinttypelist
;
735 set_print_type (const char *arg
, int from_tty
)
738 "\"set print type\" must be followed by the name of a subcommand.\n");
739 help_list (setprintlist
, "set print type ", all_commands
, gdb_stdout
);
743 show_print_type (const char *args
, int from_tty
)
745 cmd_show_list (showprinttypelist
, from_tty
, "");
748 static int print_methods
= 1;
751 set_print_type_methods (const char *args
,
752 int from_tty
, struct cmd_list_element
*c
)
754 default_ptype_flags
.print_methods
= print_methods
;
758 show_print_type_methods (struct ui_file
*file
, int from_tty
,
759 struct cmd_list_element
*c
, const char *value
)
761 fprintf_filtered (file
, _("Printing of methods defined in a class in %s\n"),
765 static int print_typedefs
= 1;
768 set_print_type_typedefs (const char *args
,
769 int from_tty
, struct cmd_list_element
*c
)
771 default_ptype_flags
.print_typedefs
= print_typedefs
;
775 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
776 struct cmd_list_element
*c
, const char *value
)
778 fprintf_filtered (file
, _("Printing of typedefs defined in a class in %s\n"),
782 /* Limit on the number of nested type definitions to print or -1 to print
783 all nested type definitions in a class. By default, we do not print
784 nested definitions. */
786 static int print_nested_type_limit
= 0;
788 /* Set how many nested type definitions should be printed by the type
792 set_print_type_nested_types (const char *args
, int from_tty
,
793 struct cmd_list_element
*c
)
795 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
798 /* Show how many nested type definitions the type printer will print. */
801 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
802 struct cmd_list_element
*c
, const char *value
)
806 fprintf_filtered (file
,
807 _("Will not print nested types defined in a class\n"));
811 fprintf_filtered (file
,
812 _("Will print %s nested types defined in a class\n"),
818 _initialize_typeprint (void)
820 struct cmd_list_element
*c
;
822 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
823 Print definition of type TYPE.\n\
824 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
825 Argument may be any type (for example a type name defined by typedef,\n\
826 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
827 or \"enum ENUM-TAG\") or an expression.\n\
828 The selected stack frame's lexical context is used to look up the name.\n\
829 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
831 Available FLAGS are:\n\
832 /r print in \"raw\" form; do not substitute typedefs\n\
833 /m do not print methods defined in a class\n\
834 /M print methods defined in a class\n\
835 /t do not print typedefs defined in a class\n\
836 /T print typedefs defined in a class\n\
837 /o print offsets and sizes of fields in a struct (like pahole)\n"));
838 set_cmd_completer (c
, expression_completer
);
840 c
= add_com ("whatis", class_vars
, whatis_command
,
841 _("Print data type of expression EXP.\n\
842 Only one level of typedefs is unrolled. See also \"ptype\"."));
843 set_cmd_completer (c
, expression_completer
);
845 add_prefix_cmd ("type", no_class
, show_print_type
,
846 _("Generic command for showing type-printing settings."),
847 &showprinttypelist
, "show print type ", 0, &showprintlist
);
848 add_prefix_cmd ("type", no_class
, set_print_type
,
849 _("Generic command for setting how types print."),
850 &setprinttypelist
, "set print type ", 0, &setprintlist
);
852 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
854 Set printing of methods defined in classes."), _("\
855 Show printing of methods defined in classes."), NULL
,
856 set_print_type_methods
,
857 show_print_type_methods
,
858 &setprinttypelist
, &showprinttypelist
);
859 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
861 Set printing of typedefs defined in classes."), _("\
862 Show printing of typedefs defined in classes."), NULL
,
863 set_print_type_typedefs
,
864 show_print_type_typedefs
,
865 &setprinttypelist
, &showprinttypelist
);
867 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
868 &print_nested_type_limit
,
870 Set the number of recursive nested type definitions to print \
871 (\"unlimited\" or -1 to show all)."), _("\
872 Show the number of recursive nested type definitions to print."), NULL
,
873 set_print_type_nested_types
,
874 show_print_type_nested_types
,
875 &setprinttypelist
, &showprinttypelist
);
878 /* Print <not allocated> status to stream STREAM. */
881 val_print_not_allocated (struct ui_file
*stream
)
883 fprintf_filtered (stream
, _("<not allocated>"));
886 /* Print <not associated> status to stream STREAM. */
889 val_print_not_associated (struct ui_file
*stream
)
891 fprintf_filtered (stream
, _("<not associated>"));