1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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 "gdbsupport/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"
39 #include "cli/cli-style.h"
41 const struct type_print_options type_print_raw_options
=
44 1, /* print_methods */
45 1, /* print_typedefs */
46 0, /* print_offsets */
48 0, /* print_nested_type_limit */
49 NULL
, /* local_typedefs */
50 NULL
, /* global_table */
51 NULL
/* global_printers */
54 /* The default flags for 'ptype' and 'whatis'. */
56 static struct type_print_options default_ptype_flags
=
59 1, /* print_methods */
60 1, /* print_typedefs */
61 0, /* print_offsets */
63 0, /* print_nested_type_limit */
64 NULL
, /* local_typedefs */
65 NULL
, /* global_table */
66 NULL
/* global_printers */
71 /* See typeprint.h. */
73 const int print_offset_data::indentation
= 27;
75 /* See typeprint.h. */
77 print_offset_data::print_offset_data (const struct type_print_options
*flags
)
80 print_in_hex
= flags
->print_in_hex
;
83 /* See typeprint.h. */
86 print_offset_data::maybe_print_hole (struct ui_file
*stream
,
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
)
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
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
;
108 fprintf_styled (stream
, highlight_style
.style (),
109 "/* XXX %2u-bit %-7s */", hole_bit
, for_what
);
110 gdb_puts ("\n", stream
);
115 fprintf_styled (stream
, highlight_style
.style (),
116 "/* XXX %2u-byte %-7s */", hole_byte
, for_what
);
117 gdb_puts ("\n", stream
);
122 /* See typeprint.h. */
125 print_offset_data::update (struct type
*type
, unsigned int field_idx
,
126 struct ui_file
*stream
)
128 if (field_is_static (&type
->field (field_idx
)))
130 print_spaces (indentation
, stream
);
134 struct type
*ftype
= check_typedef (type
->field (field_idx
).type ());
135 if (type
->code () == TYPE_CODE_UNION
)
137 /* Since union fields don't have the concept of offsets, we just
138 print their sizes. */
139 gdb_printf (stream
, "/* %6s */",
141 hex_string_custom (ftype
->length (), 4) :
142 pulongest (ftype
->length ())));
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
;
150 maybe_print_hole (stream
, bitpos
, "hole");
152 if (TYPE_FIELD_PACKED (type
, field_idx
)
153 || offset_bitpos
% TARGET_CHAR_BIT
!= 0)
155 /* We're dealing with a bitfield. Print the bit offset. */
156 fieldsize_bit
= TYPE_FIELD_BITSIZE (type
, field_idx
);
158 unsigned real_bitpos
= bitpos
+ offset_bitpos
;
161 (print_in_hex
? "/* 0x%04x: 0x%x" : "/* %6u:%2u "),
162 real_bitpos
/ TARGET_CHAR_BIT
,
163 real_bitpos
% TARGET_CHAR_BIT
);
167 /* The position of the field, relative to the beginning of the
169 gdb_printf (stream
, (print_in_hex
? "/* 0x%04x" : "/* %6u"),
170 (bitpos
+ offset_bitpos
) / TARGET_CHAR_BIT
);
172 gdb_printf (stream
, " ");
175 gdb_printf (stream
, (print_in_hex
? " | 0x%04x */" : " | %6u */"),
178 end_bitpos
= bitpos
+ fieldsize_bit
;
181 /* See typeprint.h. */
184 print_offset_data::finish (struct type
*type
, int level
,
185 struct ui_file
*stream
)
187 unsigned int bitpos
= type
->length () * TARGET_CHAR_BIT
;
188 maybe_print_hole (stream
, bitpos
, "padding");
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 ()));
198 /* A hash function for a typedef_field. */
201 hash_typedef_field (const void *p
)
203 const struct decl_field
*tf
= (const struct decl_field
*) p
;
205 return htab_hash_string (TYPE_SAFE_NAME (tf
->type
));
208 /* An equality function for a typedef field. */
211 eq_typedef_field (const void *a
, const void *b
)
213 const struct decl_field
*tfa
= (const struct decl_field
*) a
;
214 const struct decl_field
*tfb
= (const struct decl_field
*) b
;
216 return types_equal (tfa
->type
, tfb
->type
);
219 /* See typeprint.h. */
222 typedef_hash_table::recursively_update (struct type
*t
)
226 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
228 struct decl_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
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. */
239 /* Recurse into superclasses. */
240 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
241 recursively_update (TYPE_BASECLASS (t
, i
));
244 /* See typeprint.h. */
247 typedef_hash_table::add_template_parameters (struct type
*t
)
251 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
253 struct decl_field
*tf
;
256 /* We only want type-valued template parameters in the hash. */
257 if (TYPE_TEMPLATE_ARGUMENT (t
, i
)->aclass () != LOC_TYPEDEF
)
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 ();
264 slot
= htab_find_slot (m_table
.get (), tf
, INSERT
);
270 /* See typeprint.h. */
272 typedef_hash_table::typedef_hash_table ()
273 : m_table (htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
274 NULL
, xcalloc
, xfree
))
278 /* Helper function for typedef_hash_table::copy. */
281 copy_typedef_hash_element (void **slot
, void *nt
)
283 htab_t new_table
= (htab_t
) nt
;
286 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
287 if (*new_slot
== NULL
)
293 /* See typeprint.h. */
295 typedef_hash_table::typedef_hash_table (const typedef_hash_table
&table
)
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
,
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. */
309 typedef_hash_table::find_global_typedef (const struct type_print_options
*flags
,
314 struct decl_field tf
, *new_tf
;
316 if (flags
->global_typedefs
== NULL
)
322 slot
= htab_find_slot (flags
->global_typedefs
->m_table
.get (), &tf
, INSERT
);
325 new_tf
= (struct decl_field
*) *slot
;
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
);
337 applied
= apply_ext_lang_type_printers (flags
->global_printers
, t
);
341 new_tf
->name
= obstack_strdup (&flags
->global_typedefs
->m_storage
,
349 /* See typeprint.h. */
352 typedef_hash_table::find_typedef (const struct type_print_options
*flags
,
355 if (flags
->local_typedefs
!= NULL
)
357 struct decl_field tf
, *found
;
361 htab_t table
= flags
->local_typedefs
->m_table
.get ();
362 found
= (struct decl_field
*) htab_find (table
, &tf
);
368 return find_global_typedef (flags
, t
);
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. */
378 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
380 current_language
->print_typedef (type
, newobj
, stream
);
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. */
391 type_print (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
394 current_language
->print_type (type
, varstring
, stream
, show
, 0,
395 &default_ptype_flags
);
398 /* Print TYPE to a string, returning it. The caller is responsible for
399 freeing the string. */
402 type_to_string (struct type
*type
)
408 type_print (type
, "", &stb
, -1);
409 return stb
.release ();
411 catch (const gdb_exception
&except
)
418 /* See typeprint.h. */
421 type_print_unknown_return_type (struct ui_file
*stream
)
423 fprintf_styled (stream
, metadata_style
.style (),
424 _("<unknown return type>"));
427 /* See typeprint.h. */
430 error_unknown_type (const char *sym_print_name
)
432 error (_("'%s' has unknown type; cast it to its declared type"),
436 /* Print type of EXP, or last thing in value history if EXP == NULL.
437 show is passed to type_print. */
440 whatis_exp (const char *exp
, int show
)
443 struct type
*real_type
= NULL
;
448 struct value_print_options opts
;
449 struct type_print_options flags
= default_ptype_flags
;
457 for (++exp
; *exp
&& !isspace (*exp
); ++exp
)
465 flags
.print_methods
= 0;
468 flags
.print_methods
= 1;
471 flags
.print_typedefs
= 0;
474 flags
.print_typedefs
= 1;
478 /* Filter out languages which don't implement the
481 && current_language
->can_print_type_offsets ())
483 flags
.print_offsets
= 1;
484 flags
.print_typedefs
= 0;
485 flags
.print_methods
= 0;
490 flags
.print_in_hex
= 1;
493 flags
.print_in_hex
= 0;
496 error (_("unrecognized flag '%c'"), *exp
);
501 if (!*exp
&& !seen_one
)
502 error (_("flag expected"));
504 error (_("expected space after format"));
505 exp
= skip_spaces (exp
);
508 expression_up expr
= parse_expression (exp
);
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
517 val
= evaluate_type (expr
.get ());
518 type
= value_type (val
);
520 if (show
== -1 && expr
->first_opcode () == OP_TYPE
)
522 /* The user expression names a type directly. */
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 ();
531 /* If the expression is actually a type, then there's no
532 value to fetch the dynamic type from. */
538 val
= access_value_history (0);
539 type
= value_type (val
);
542 get_user_print_options (&opts
);
543 if (val
!= NULL
&& opts
.objectprint
)
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
);
552 if (flags
.print_offsets
553 && (type
->code () == TYPE_CODE_STRUCT
554 || type
->code () == TYPE_CODE_UNION
))
555 gdb_printf ("/* offset | size */ ");
557 gdb_printf ("type = ");
559 std::unique_ptr
<typedef_hash_table
> table_holder
;
560 std::unique_ptr
<ext_lang_type_printers
> printer_holder
;
563 table_holder
.reset (new typedef_hash_table
);
564 flags
.global_typedefs
= table_holder
.get ();
566 printer_holder
.reset (new ext_lang_type_printers
);
567 flags
.global_printers
= printer_holder
.get ();
572 gdb_printf ("/* real type = ");
573 type_print (real_type
, "", gdb_stdout
, -1);
575 gdb_printf (" (incomplete object)");
576 gdb_printf (" */\n");
579 current_language
->print_type (type
, "", gdb_stdout
, show
, 0, &flags
);
584 whatis_command (const char *exp
, int from_tty
)
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);
592 /* TYPENAME is either the name of a type, or an expression. */
595 ptype_command (const char *type_name
, int from_tty
)
597 whatis_exp (type_name
, 1);
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.
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. */
613 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
618 type
= check_typedef (type
);
620 switch (type
->code ())
624 len
= type
->num_fields ();
625 for (i
= 0; i
< len
; i
++)
627 if (type
->field (i
).loc_enumval () == val
)
634 gdb_puts (type
->field (i
).name (), stream
);
638 print_longest (stream
, 'd', 0, val
);
643 print_longest (stream
, type
->is_unsigned () ? 'u' : 'd', 0, val
);
647 current_language
->printchar ((unsigned char) val
, type
, stream
);
651 gdb_printf (stream
, val
? "TRUE" : "FALSE");
654 case TYPE_CODE_RANGE
:
655 print_type_scalar (type
->target_type (), val
, stream
);
658 case TYPE_CODE_FIXED_POINT
:
659 print_type_fixed_point (type
, stream
);
662 case TYPE_CODE_UNDEF
:
664 case TYPE_CODE_ARRAY
:
665 case TYPE_CODE_STRUCT
:
666 case TYPE_CODE_UNION
:
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
:
677 case TYPE_CODE_RVALUE_REF
:
678 case TYPE_CODE_NAMESPACE
:
679 error (_("internal error: unhandled type in print_type_scalar"));
683 error (_("Invalid type code in symbol table."));
687 /* See typeprint.h. */
690 print_type_fixed_point (struct type
*type
, struct ui_file
*stream
)
692 std::string small_img
= type
->fixed_point_scaling_factor ().str ();
694 gdb_printf (stream
, "%s-byte fixed point (small = %s)",
695 pulongest (type
->length ()), small_img
.c_str ());
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(). */
703 maintenance_print_type (const char *type_name
, int from_tty
)
705 if (type_name
!= NULL
)
707 expression_up expr
= parse_expression (type_name
);
708 struct value
*val
= evaluate_type (expr
.get ());
709 struct type
*type
= value_type (val
);
712 recursive_dump_type (type
, 0);
717 struct cmd_list_element
*setprinttypelist
;
719 struct cmd_list_element
*showprinttypelist
;
721 static bool print_methods
= true;
724 set_print_type_methods (const char *args
,
725 int from_tty
, struct cmd_list_element
*c
)
727 default_ptype_flags
.print_methods
= print_methods
;
731 show_print_type_methods (struct ui_file
*file
, int from_tty
,
732 struct cmd_list_element
*c
, const char *value
)
734 gdb_printf (file
, _("Printing of methods defined in a class in %s\n"),
738 static bool print_typedefs
= true;
741 set_print_type_typedefs (const char *args
,
742 int from_tty
, struct cmd_list_element
*c
)
744 default_ptype_flags
.print_typedefs
= print_typedefs
;
748 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
749 struct cmd_list_element
*c
, const char *value
)
751 gdb_printf (file
, _("Printing of typedefs defined in a class in %s\n"),
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. */
759 static int print_nested_type_limit
= 0;
761 /* Set how many nested type definitions should be printed by the type
765 set_print_type_nested_types (const char *args
, int from_tty
,
766 struct cmd_list_element
*c
)
768 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
771 /* Show how many nested type definitions the type printer will print. */
774 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
775 struct cmd_list_element
*c
, const char *value
)
780 _("Will not print nested types defined in a class\n"));
785 _("Will print %s nested types defined in a class\n"),
790 /* When printing structs, offsets and sizes of members can be displayed using
791 decimal notation or hexadecimal notation. By default, Decimal notation is
794 static bool print_offsets_and_sizes_in_hex
= false;
796 /* Set the flags that instructs if sizes and offsets of struct members are
797 displayed in hexadecimal or decimal notation. */
800 set_print_offsets_and_sizes_in_hex (const char *args
,
801 int from_tty
, struct cmd_list_element
*c
)
803 default_ptype_flags
.print_in_hex
= print_offsets_and_sizes_in_hex
;
806 /* Display whether struct members sizes and offsets are printed
807 using decimal or hexadecimal notation. */
810 show_print_offsets_and_sizes_in_hex (struct ui_file
*file
, int from_tty
,
811 struct cmd_list_element
*c
,
814 gdb_printf (file
, _("\
815 Display of struct members offsets and sizes in hexadecimal is %s\n"),
819 void _initialize_typeprint ();
821 _initialize_typeprint ()
823 struct cmd_list_element
*c
;
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\
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\
843 /d use decimal notation when displaying sizes and offsets\n\
844 of struct members "));
845 set_cmd_completer (c
, expression_completer
);
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
);
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
);
858 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
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
,
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
);
873 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
874 &print_nested_type_limit
,
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
);
883 add_setshow_boolean_cmd ("hex", no_class
, &print_offsets_and_sizes_in_hex
,
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
);
892 /* Print <not allocated> status to stream STREAM. */
895 val_print_not_allocated (struct ui_file
*stream
)
897 fprintf_styled (stream
, metadata_style
.style (), _("<not allocated>"));
900 /* Print <not associated> status to stream STREAM. */
903 val_print_not_associated (struct ui_file
*stream
)
905 fprintf_styled (stream
, metadata_style
.style (), _("<not associated>"));