1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2024 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/>. */
20 #include "gdbsupport/gdb_obstack.h"
24 #include "expression.h"
32 #include "typeprint.h"
35 #include "cli/cli-utils.h"
36 #include "extension.h"
37 #include "completer.h"
38 #include "cli/cli-style.h"
40 const struct type_print_options type_print_raw_options
=
43 1, /* print_methods */
44 1, /* print_typedefs */
45 0, /* print_offsets */
47 0, /* print_nested_type_limit */
48 NULL
, /* local_typedefs */
49 NULL
, /* global_table */
50 NULL
/* global_printers */
53 /* The default flags for 'ptype' and 'whatis'. */
55 static struct type_print_options default_ptype_flags
=
58 1, /* print_methods */
59 1, /* print_typedefs */
60 0, /* print_offsets */
62 0, /* print_nested_type_limit */
63 NULL
, /* local_typedefs */
64 NULL
, /* global_table */
65 NULL
/* global_printers */
70 /* See typeprint.h. */
72 const int print_offset_data::indentation
= 27;
74 /* See typeprint.h. */
76 print_offset_data::print_offset_data (const struct type_print_options
*flags
)
79 print_in_hex
= flags
->print_in_hex
;
82 /* See typeprint.h. */
85 print_offset_data::maybe_print_hole (struct ui_file
*stream
,
89 /* We check for END_BITPOS > 0 because there is a specific
90 scenario when END_BITPOS can be zero and BITPOS can be >
91 0: when we are dealing with a struct/class with a virtual method.
92 Because of the vtable, the first field of the struct/class will
93 have an offset of sizeof (void *) (the size of the vtable). If
94 we do not check for END_BITPOS > 0 here, GDB will report
95 a hole before the first field, which is not accurate. */
96 if (end_bitpos
> 0 && end_bitpos
< bitpos
)
98 /* If END_BITPOS is smaller than the current type's
99 bitpos, it means there's a hole in the struct, so we report
101 unsigned int hole
= bitpos
- end_bitpos
;
102 unsigned int hole_byte
= hole
/ TARGET_CHAR_BIT
;
103 unsigned int hole_bit
= hole
% TARGET_CHAR_BIT
;
107 fprintf_styled (stream
, highlight_style
.style (),
108 "/* XXX %2u-bit %-7s */", hole_bit
, for_what
);
109 gdb_puts ("\n", stream
);
114 fprintf_styled (stream
, highlight_style
.style (),
115 "/* XXX %2u-byte %-7s */", hole_byte
, for_what
);
116 gdb_puts ("\n", stream
);
121 /* See typeprint.h. */
124 print_offset_data::update (struct type
*type
, unsigned int field_idx
,
125 struct ui_file
*stream
)
127 if (type
->field (field_idx
).is_static ())
129 print_spaces (indentation
, stream
);
133 struct type
*ftype
= check_typedef (type
->field (field_idx
).type ());
134 if (type
->code () == TYPE_CODE_UNION
)
136 /* Since union fields don't have the concept of offsets, we just
137 print their sizes. */
138 gdb_printf (stream
, "/* %6s */",
140 hex_string_custom (ftype
->length (), 4) :
141 pulongest (ftype
->length ())));
145 unsigned int bitpos
= type
->field (field_idx
).loc_bitpos ();
146 unsigned int fieldsize_byte
= ftype
->length ();
147 unsigned int fieldsize_bit
= fieldsize_byte
* TARGET_CHAR_BIT
;
149 maybe_print_hole (stream
, bitpos
, "hole");
151 if (type
->field (field_idx
).is_packed ()
152 || offset_bitpos
% TARGET_CHAR_BIT
!= 0)
154 /* We're dealing with a bitfield. Print the bit offset. */
155 fieldsize_bit
= type
->field (field_idx
).bitsize ();
157 unsigned real_bitpos
= bitpos
+ offset_bitpos
;
160 (print_in_hex
? "/* 0x%04x: 0x%x" : "/* %6u:%2u "),
161 real_bitpos
/ TARGET_CHAR_BIT
,
162 real_bitpos
% TARGET_CHAR_BIT
);
166 /* The position of the field, relative to the beginning of the
168 gdb_printf (stream
, (print_in_hex
? "/* 0x%04x" : "/* %6u"),
169 (bitpos
+ offset_bitpos
) / TARGET_CHAR_BIT
);
171 gdb_printf (stream
, " ");
174 gdb_printf (stream
, (print_in_hex
? " | 0x%04x */" : " | %6u */"),
177 end_bitpos
= bitpos
+ fieldsize_bit
;
180 /* See typeprint.h. */
183 print_offset_data::finish (struct type
*type
, int level
,
184 struct ui_file
*stream
)
186 unsigned int bitpos
= type
->length () * TARGET_CHAR_BIT
;
187 maybe_print_hole (stream
, bitpos
, "padding");
189 gdb_puts ("\n", stream
);
190 print_spaces (level
+ 4 + print_offset_data::indentation
, stream
);
191 gdb_printf (stream
, "/* total size (bytes): %4s */\n",
192 pulongest (type
->length ()));
197 /* A hash function for a typedef_field. */
200 hash_typedef_field (const void *p
)
202 const struct decl_field
*tf
= (const struct decl_field
*) p
;
204 return htab_hash_string (TYPE_SAFE_NAME (tf
->type
));
207 /* An equality function for a typedef field. */
210 eq_typedef_field (const void *a
, const void *b
)
212 const struct decl_field
*tfa
= (const struct decl_field
*) a
;
213 const struct decl_field
*tfb
= (const struct decl_field
*) b
;
215 return types_equal (tfa
->type
, tfb
->type
);
218 /* See typeprint.h. */
221 typedef_hash_table::recursively_update (struct type
*t
)
225 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
227 struct decl_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
230 slot
= htab_find_slot (m_table
.get (), tdef
, INSERT
);
231 /* Only add a given typedef name once. Really this shouldn't
232 happen; but it is safe enough to do the updates breadth-first
233 and thus use the most specific typedef. */
238 /* Recurse into superclasses. */
239 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
240 recursively_update (TYPE_BASECLASS (t
, i
));
243 /* See typeprint.h. */
246 typedef_hash_table::add_template_parameters (struct type
*t
)
250 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
252 struct decl_field
*tf
;
255 /* We only want type-valued template parameters in the hash. */
256 if (TYPE_TEMPLATE_ARGUMENT (t
, i
)->aclass () != LOC_TYPEDEF
)
259 tf
= XOBNEW (&m_storage
, struct decl_field
);
260 tf
->name
= TYPE_TEMPLATE_ARGUMENT (t
, i
)->linkage_name ();
261 tf
->type
= TYPE_TEMPLATE_ARGUMENT (t
, i
)->type ();
263 slot
= htab_find_slot (m_table
.get (), tf
, INSERT
);
269 /* See typeprint.h. */
271 typedef_hash_table::typedef_hash_table ()
272 : m_table (htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
273 NULL
, xcalloc
, xfree
))
277 /* Helper function for typedef_hash_table::copy. */
280 copy_typedef_hash_element (void **slot
, void *nt
)
282 htab_t new_table
= (htab_t
) nt
;
285 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
286 if (*new_slot
== NULL
)
292 /* See typeprint.h. */
294 typedef_hash_table::typedef_hash_table (const typedef_hash_table
&table
)
296 m_table
.reset (htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
297 NULL
, xcalloc
, xfree
));
298 htab_traverse_noresize (table
.m_table
.get (), copy_typedef_hash_element
,
302 /* Look up the type T in the global typedef hash. If it is found,
303 return the typedef name. If it is not found, apply the
304 type-printers, if any, given by start_script_type_printers and return the
305 result. A NULL return means that the name was not found. */
308 typedef_hash_table::find_global_typedef (const struct type_print_options
*flags
,
312 struct decl_field tf
, *new_tf
;
314 if (flags
->global_typedefs
== NULL
)
320 slot
= htab_find_slot (flags
->global_typedefs
->m_table
.get (), &tf
, INSERT
);
323 new_tf
= (struct decl_field
*) *slot
;
327 /* Put an entry into the hash table now, in case
328 apply_ext_lang_type_printers recurses. */
329 new_tf
= XOBNEW (&flags
->global_typedefs
->m_storage
, struct decl_field
);
335 gdb::unique_xmalloc_ptr
<char> applied
336 = apply_ext_lang_type_printers (flags
->global_printers
, t
);
338 if (applied
!= nullptr)
339 new_tf
->name
= obstack_strdup (&flags
->global_typedefs
->m_storage
,
345 /* See typeprint.h. */
348 typedef_hash_table::find_typedef (const struct type_print_options
*flags
,
351 if (flags
->local_typedefs
!= NULL
)
353 struct decl_field tf
, *found
;
357 htab_t table
= flags
->local_typedefs
->m_table
.get ();
358 found
= (struct decl_field
*) htab_find (table
, &tf
);
364 return find_global_typedef (flags
, t
);
369 /* Print a description of a type in the format of a
370 typedef for the current language.
371 NEW is the new name for a type TYPE. */
374 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
376 current_language
->print_typedef (type
, newobj
, stream
);
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 current_language
->print_type (type
, varstring
, stream
, show
, 0,
391 &default_ptype_flags
);
394 /* Print TYPE to a string, returning it. The caller is responsible for
395 freeing the string. */
398 type_to_string (struct type
*type
)
404 type_print (type
, "", &stb
, -1);
405 return stb
.release ();
407 catch (const gdb_exception
&except
)
414 /* See typeprint.h. */
417 type_print_unknown_return_type (struct ui_file
*stream
)
419 fprintf_styled (stream
, metadata_style
.style (),
420 _("<unknown return type>"));
423 /* See typeprint.h. */
426 error_unknown_type (const char *sym_print_name
)
428 error (_("'%s' has unknown type; cast it to its declared type"),
432 /* Print type of EXP, or last thing in value history if EXP == NULL.
433 show is passed to type_print. */
436 whatis_exp (const char *exp
, int show
)
439 struct type
*real_type
= NULL
;
444 struct value_print_options opts
;
445 struct type_print_options flags
= default_ptype_flags
;
453 for (++exp
; *exp
&& !isspace (*exp
); ++exp
)
461 flags
.print_methods
= 0;
464 flags
.print_methods
= 1;
467 flags
.print_typedefs
= 0;
470 flags
.print_typedefs
= 1;
474 /* Filter out languages which don't implement the
477 && current_language
->can_print_type_offsets ())
479 flags
.print_offsets
= 1;
480 flags
.print_typedefs
= 0;
481 flags
.print_methods
= 0;
486 flags
.print_in_hex
= 1;
489 flags
.print_in_hex
= 0;
492 error (_("unrecognized flag '%c'"), *exp
);
497 if (!*exp
&& !seen_one
)
498 error (_("flag expected"));
500 error (_("expected space after format"));
501 exp
= skip_spaces (exp
);
504 expression_up expr
= parse_expression (exp
);
506 /* The behavior of "whatis" depends on whether the user
507 expression names a type directly, or a language expression
508 (including variable names). If the former, then "whatis"
509 strips one level of typedefs, only. If an expression,
510 "whatis" prints the type of the expression without stripping
511 any typedef level. "ptype" always strips all levels of
513 val
= expr
->evaluate_type ();
516 if (show
== -1 && expr
->first_opcode () == OP_TYPE
)
518 /* The user expression names a type directly. */
520 /* If this is a typedef, then find its immediate target.
521 Use check_typedef to resolve stubs, but ignore its result
522 because we do not want to dig past all typedefs. */
523 check_typedef (type
);
524 if (type
->code () == TYPE_CODE_TYPEDEF
)
525 type
= type
->target_type ();
527 /* If the expression is actually a type, then there's no
528 value to fetch the dynamic type from. */
534 val
= access_value_history (0);
538 if (flags
.print_offsets
&& is_dynamic_type (type
))
540 warning (_("ptype/o does not work with dynamic types; disabling '/o'"));
541 flags
.print_offsets
= 0;
544 get_user_print_options (&opts
);
545 if (val
!= NULL
&& opts
.objectprint
)
547 if (type
->is_pointer_or_reference ()
548 && (type
->target_type ()->code () == TYPE_CODE_STRUCT
))
549 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
550 else if (type
->code () == TYPE_CODE_STRUCT
)
551 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
554 if (flags
.print_offsets
555 && (type
->code () == TYPE_CODE_STRUCT
556 || type
->code () == TYPE_CODE_UNION
))
557 gdb_printf ("/* offset | size */ ");
559 gdb_printf ("type = ");
561 std::unique_ptr
<typedef_hash_table
> table_holder
;
562 std::unique_ptr
<ext_lang_type_printers
> printer_holder
;
565 table_holder
.reset (new typedef_hash_table
);
566 flags
.global_typedefs
= table_holder
.get ();
568 printer_holder
.reset (new ext_lang_type_printers
);
569 flags
.global_printers
= printer_holder
.get ();
574 gdb_printf ("/* real type = ");
575 type_print (real_type
, "", gdb_stdout
, -1);
577 gdb_printf (" (incomplete object)");
578 gdb_printf (" */\n");
581 current_language
->print_type (type
, "", gdb_stdout
, show
, 0, &flags
);
586 whatis_command (const char *exp
, int from_tty
)
588 /* Most of the time users do not want to see all the fields
589 in a structure. If they do they can use the "ptype" command.
590 Hence the "-1" below. */
591 whatis_exp (exp
, -1);
594 /* TYPENAME is either the name of a type, or an expression. */
597 ptype_command (const char *type_name
, int from_tty
)
599 whatis_exp (type_name
, 1);
602 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
603 Used to print data from type structures in a specified type. For example,
604 array bounds may be characters or booleans in some languages, and this
605 allows the ranges to be printed in their "natural" form rather than as
606 decimal integer values.
608 FIXME: This is here simply because only the type printing routines
609 currently use it, and it wasn't clear if it really belonged somewhere
610 else (like printcmd.c). There are a lot of other gdb routines that do
611 something similar, but they are generally concerned with printing values
612 that come from the inferior in target byte order and target size. */
615 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
620 type
= check_typedef (type
);
622 switch (type
->code ())
626 len
= type
->num_fields ();
627 for (i
= 0; i
< len
; i
++)
629 if (type
->field (i
).loc_enumval () == val
)
636 gdb_puts (type
->field (i
).name (), stream
);
640 print_longest (stream
, 'd', 0, val
);
645 print_longest (stream
, type
->is_unsigned () ? 'u' : 'd', 0, val
);
649 current_language
->printchar ((unsigned char) val
, type
, stream
);
653 gdb_printf (stream
, val
? "TRUE" : "FALSE");
656 case TYPE_CODE_RANGE
:
657 print_type_scalar (type
->target_type (), val
, stream
);
660 case TYPE_CODE_FIXED_POINT
:
661 print_type_fixed_point (type
, stream
);
664 case TYPE_CODE_UNDEF
:
666 case TYPE_CODE_ARRAY
:
667 case TYPE_CODE_STRUCT
:
668 case TYPE_CODE_UNION
:
673 case TYPE_CODE_STRING
:
674 case TYPE_CODE_ERROR
:
675 case TYPE_CODE_MEMBERPTR
:
676 case TYPE_CODE_METHODPTR
:
677 case TYPE_CODE_METHOD
:
679 case TYPE_CODE_RVALUE_REF
:
680 case TYPE_CODE_NAMESPACE
:
681 error (_("internal error: unhandled type in print_type_scalar"));
685 error (_("Invalid type code in symbol table."));
689 /* See typeprint.h. */
692 print_type_fixed_point (struct type
*type
, struct ui_file
*stream
)
694 std::string small_img
= type
->fixed_point_scaling_factor ().str ();
696 gdb_printf (stream
, "%s-byte fixed point (small = %s)",
697 pulongest (type
->length ()), small_img
.c_str ());
700 /* Dump details of a type specified either directly or indirectly.
701 Uses the same sort of type lookup mechanism as ptype_command()
702 and whatis_command(). */
705 maintenance_print_type (const char *type_name
, int from_tty
)
707 if (type_name
!= NULL
)
709 expression_up expr
= parse_expression (type_name
);
710 struct value
*val
= expr
->evaluate_type ();
711 struct type
*type
= val
->type ();
714 recursive_dump_type (type
, 0);
719 struct cmd_list_element
*setprinttypelist
;
721 struct cmd_list_element
*showprinttypelist
;
723 static bool print_methods
= true;
726 set_print_type_methods (const char *args
,
727 int from_tty
, struct cmd_list_element
*c
)
729 default_ptype_flags
.print_methods
= print_methods
;
733 show_print_type_methods (struct ui_file
*file
, int from_tty
,
734 struct cmd_list_element
*c
, const char *value
)
736 gdb_printf (file
, _("Printing of methods defined in a class in %s\n"),
740 static bool print_typedefs
= true;
743 set_print_type_typedefs (const char *args
,
744 int from_tty
, struct cmd_list_element
*c
)
746 default_ptype_flags
.print_typedefs
= print_typedefs
;
750 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
751 struct cmd_list_element
*c
, const char *value
)
753 gdb_printf (file
, _("Printing of typedefs defined in a class in %s\n"),
757 /* Limit on the number of nested type definitions to print or -1 to print
758 all nested type definitions in a class. By default, we do not print
759 nested definitions. */
761 static int print_nested_type_limit
= 0;
763 /* Set how many nested type definitions should be printed by the type
767 set_print_type_nested_types (const char *args
, int from_tty
,
768 struct cmd_list_element
*c
)
770 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
773 /* Show how many nested type definitions the type printer will print. */
776 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
777 struct cmd_list_element
*c
, const char *value
)
782 _("Will not print nested types defined in a class\n"));
787 _("Will print %s nested types defined in a class\n"),
792 /* When printing structs, offsets and sizes of members can be displayed using
793 decimal notation or hexadecimal notation. By default, Decimal notation is
796 static bool print_offsets_and_sizes_in_hex
= false;
798 /* Set the flags that instructs if sizes and offsets of struct members are
799 displayed in hexadecimal or decimal notation. */
802 set_print_offsets_and_sizes_in_hex (const char *args
,
803 int from_tty
, struct cmd_list_element
*c
)
805 default_ptype_flags
.print_in_hex
= print_offsets_and_sizes_in_hex
;
808 /* Display whether struct members sizes and offsets are printed
809 using decimal or hexadecimal notation. */
812 show_print_offsets_and_sizes_in_hex (struct ui_file
*file
, int from_tty
,
813 struct cmd_list_element
*c
,
816 gdb_printf (file
, _("\
817 Display of struct members offsets and sizes in hexadecimal is %s\n"),
821 void _initialize_typeprint ();
823 _initialize_typeprint ()
825 struct cmd_list_element
*c
;
827 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
828 Print definition of type TYPE.\n\
829 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
830 Argument may be any type (for example a type name defined by typedef,\n\
831 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
832 or \"enum ENUM-TAG\") or an expression.\n\
833 The selected stack frame's lexical context is used to look up the name.\n\
834 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
836 Available FLAGS are:\n\
837 /r print in \"raw\" form; do not substitute typedefs\n\
838 /m do not print methods defined in a class\n\
839 /M print methods defined in a class\n\
840 /t do not print typedefs defined in a class\n\
841 /T print typedefs defined in a class\n\
842 /o print offsets and sizes of fields in a struct (like pahole)\n\
843 /x use hexadecimal notation when displaying sizes and offsets\n\
845 /d use decimal notation when displaying sizes and offsets\n\
846 of struct members "));
847 set_cmd_completer (c
, expression_completer
);
849 c
= add_com ("whatis", class_vars
, whatis_command
,
850 _("Print data type of expression EXP.\n\
851 Only one level of typedefs is unrolled. See also \"ptype\"."));
852 set_cmd_completer (c
, expression_completer
);
854 add_setshow_prefix_cmd ("type", no_class
,
855 _("Generic command for showing type-printing settings."),
856 _("Generic command for setting how types print."),
857 &setprinttypelist
, &showprinttypelist
,
858 &setprintlist
, &showprintlist
);
860 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
862 Set printing of methods defined in classes."), _("\
863 Show printing of methods defined in classes."), NULL
,
864 set_print_type_methods
,
865 show_print_type_methods
,
866 &setprinttypelist
, &showprinttypelist
);
867 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
869 Set printing of typedefs defined in classes."), _("\
870 Show printing of typedefs defined in classes."), NULL
,
871 set_print_type_typedefs
,
872 show_print_type_typedefs
,
873 &setprinttypelist
, &showprinttypelist
);
875 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
876 &print_nested_type_limit
,
878 Set the number of recursive nested type definitions to print \
879 (\"unlimited\" or -1 to show all)."), _("\
880 Show the number of recursive nested type definitions to print."), NULL
,
881 set_print_type_nested_types
,
882 show_print_type_nested_types
,
883 &setprinttypelist
, &showprinttypelist
);
885 add_setshow_boolean_cmd ("hex", no_class
, &print_offsets_and_sizes_in_hex
,
887 Set printing of struct members sizes and offsets using hex notation."), _("\
888 Show whether sizes and offsets of struct members are printed using hex \
889 notation."), nullptr, set_print_offsets_and_sizes_in_hex
,
890 show_print_offsets_and_sizes_in_hex
,
891 &setprinttypelist
, &showprinttypelist
);
894 /* Print <not allocated> status to stream STREAM. */
897 val_print_not_allocated (struct ui_file
*stream
)
899 fprintf_styled (stream
, metadata_style
.style (), _("<not allocated>"));
902 /* Print <not associated> status to stream STREAM. */
905 val_print_not_associated (struct ui_file
*stream
)
907 fprintf_styled (stream
, metadata_style
.style (), _("<not associated>"));