1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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"
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 */
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 */
61 0, /* print_nested_type_limit */
62 NULL
, /* local_typedefs */
63 NULL
, /* global_table */
64 NULL
/* global_printers */
69 /* See typeprint.h. */
71 const int print_offset_data::indentation
= 23;
74 /* See typeprint.h. */
77 print_offset_data::maybe_print_hole (struct ui_file
*stream
,
81 /* We check for END_BITPOS > 0 because there is a specific
82 scenario when END_BITPOS can be zero and BITPOS can be >
83 0: when we are dealing with a struct/class with a virtual method.
84 Because of the vtable, the first field of the struct/class will
85 have an offset of sizeof (void *) (the size of the vtable). If
86 we do not check for END_BITPOS > 0 here, GDB will report
87 a hole before the first field, which is not accurate. */
88 if (end_bitpos
> 0 && end_bitpos
< bitpos
)
90 /* If END_BITPOS is smaller than the current type's
91 bitpos, it means there's a hole in the struct, so we report
93 unsigned int hole
= bitpos
- end_bitpos
;
94 unsigned int hole_byte
= hole
/ TARGET_CHAR_BIT
;
95 unsigned int hole_bit
= hole
% TARGET_CHAR_BIT
;
98 fprintf_filtered (stream
, "/* XXX %2u-bit %s */\n", hole_bit
,
102 fprintf_filtered (stream
, "/* XXX %2u-byte %s */\n", hole_byte
,
107 /* See typeprint.h. */
110 print_offset_data::update (struct type
*type
, unsigned int field_idx
,
111 struct ui_file
*stream
)
113 if (field_is_static (&type
->field (field_idx
)))
115 print_spaces_filtered (indentation
, stream
);
119 struct type
*ftype
= check_typedef (TYPE_FIELD_TYPE (type
, field_idx
));
120 if (type
->code () == TYPE_CODE_UNION
)
122 /* Since union fields don't have the concept of offsets, we just
123 print their sizes. */
124 fprintf_filtered (stream
, "/* %4s */",
125 pulongest (TYPE_LENGTH (ftype
)));
129 unsigned int bitpos
= TYPE_FIELD_BITPOS (type
, field_idx
);
130 unsigned int fieldsize_byte
= TYPE_LENGTH (ftype
);
131 unsigned int fieldsize_bit
= fieldsize_byte
* TARGET_CHAR_BIT
;
133 maybe_print_hole (stream
, bitpos
, "hole");
135 if (TYPE_FIELD_PACKED (type
, field_idx
)
136 || offset_bitpos
% TARGET_CHAR_BIT
!= 0)
138 /* We're dealing with a bitfield. Print the bit offset. */
139 fieldsize_bit
= TYPE_FIELD_BITSIZE (type
, field_idx
);
141 unsigned real_bitpos
= bitpos
+ offset_bitpos
;
143 fprintf_filtered (stream
, "/* %4u:%2u", real_bitpos
/ TARGET_CHAR_BIT
,
144 real_bitpos
% TARGET_CHAR_BIT
);
148 /* The position of the field, relative to the beginning of the
150 fprintf_filtered (stream
, "/* %4u",
151 (bitpos
+ offset_bitpos
) / TARGET_CHAR_BIT
);
153 fprintf_filtered (stream
, " ");
156 fprintf_filtered (stream
, " | %4u */", fieldsize_byte
);
158 end_bitpos
= bitpos
+ fieldsize_bit
;
161 /* See typeprint.h. */
164 print_offset_data::finish (struct type
*type
, int level
,
165 struct ui_file
*stream
)
167 unsigned int bitpos
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
;
168 maybe_print_hole (stream
, bitpos
, "padding");
170 fputs_filtered ("\n", stream
);
171 print_spaces_filtered (level
+ 4 + print_offset_data::indentation
, stream
);
172 fprintf_filtered (stream
, "/* total size (bytes): %4s */\n",
173 pulongest (TYPE_LENGTH (type
)));
178 /* A hash function for a typedef_field. */
181 hash_typedef_field (const void *p
)
183 const struct decl_field
*tf
= (const struct decl_field
*) p
;
184 struct type
*t
= check_typedef (tf
->type
);
186 return htab_hash_string (TYPE_SAFE_NAME (t
));
189 /* An equality function for a typedef field. */
192 eq_typedef_field (const void *a
, const void *b
)
194 const struct decl_field
*tfa
= (const struct decl_field
*) a
;
195 const struct decl_field
*tfb
= (const struct decl_field
*) b
;
197 return types_equal (tfa
->type
, tfb
->type
);
200 /* See typeprint.h. */
203 typedef_hash_table::recursively_update (struct type
*t
)
207 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
209 struct decl_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
212 slot
= htab_find_slot (m_table
, tdef
, INSERT
);
213 /* Only add a given typedef name once. Really this shouldn't
214 happen; but it is safe enough to do the updates breadth-first
215 and thus use the most specific typedef. */
220 /* Recurse into superclasses. */
221 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
222 recursively_update (TYPE_BASECLASS (t
, i
));
225 /* See typeprint.h. */
228 typedef_hash_table::add_template_parameters (struct type
*t
)
232 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
234 struct decl_field
*tf
;
237 /* We only want type-valued template parameters in the hash. */
238 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t
, i
)) != LOC_TYPEDEF
)
241 tf
= XOBNEW (&m_storage
, struct decl_field
);
242 tf
->name
= TYPE_TEMPLATE_ARGUMENT (t
, i
)->linkage_name ();
243 tf
->type
= SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t
, i
));
245 slot
= htab_find_slot (m_table
, tf
, INSERT
);
251 /* See typeprint.h. */
253 typedef_hash_table::typedef_hash_table ()
255 m_table
= htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
256 NULL
, xcalloc
, xfree
);
259 /* Free a typedef field table. */
261 typedef_hash_table::~typedef_hash_table ()
263 htab_delete (m_table
);
266 /* Helper function for typedef_hash_table::copy. */
269 copy_typedef_hash_element (void **slot
, void *nt
)
271 htab_t new_table
= (htab_t
) nt
;
274 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
275 if (*new_slot
== NULL
)
281 /* See typeprint.h. */
283 typedef_hash_table::typedef_hash_table (const typedef_hash_table
&table
)
285 m_table
= htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
286 NULL
, xcalloc
, xfree
);
287 htab_traverse_noresize (table
.m_table
, copy_typedef_hash_element
,
291 /* Look up the type T in the global typedef hash. If it is found,
292 return the typedef name. If it is not found, apply the
293 type-printers, if any, given by start_script_type_printers and return the
294 result. A NULL return means that the name was not found. */
297 typedef_hash_table::find_global_typedef (const struct type_print_options
*flags
,
302 struct decl_field tf
, *new_tf
;
304 if (flags
->global_typedefs
== NULL
)
310 slot
= htab_find_slot (flags
->global_typedefs
->m_table
, &tf
, INSERT
);
313 new_tf
= (struct decl_field
*) *slot
;
317 /* Put an entry into the hash table now, in case
318 apply_ext_lang_type_printers recurses. */
319 new_tf
= XOBNEW (&flags
->global_typedefs
->m_storage
, struct decl_field
);
325 applied
= apply_ext_lang_type_printers (flags
->global_printers
, t
);
329 new_tf
->name
= obstack_strdup (&flags
->global_typedefs
->m_storage
,
337 /* See typeprint.h. */
340 typedef_hash_table::find_typedef (const struct type_print_options
*flags
,
343 if (flags
->local_typedefs
!= NULL
)
345 struct decl_field tf
, *found
;
349 found
= (struct decl_field
*) htab_find (flags
->local_typedefs
->m_table
,
356 return find_global_typedef (flags
, t
);
361 /* Print a description of a type in the format of a
362 typedef for the current language.
363 NEW is the new name for a type TYPE. */
366 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
368 LA_PRINT_TYPEDEF (type
, newobj
, stream
);
371 /* The default way to print a typedef. */
374 default_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
375 struct ui_file
*stream
)
377 error (_("Language not supported."));
380 /* Print a description of a type TYPE in the form of a declaration of a
381 variable named VARSTRING. (VARSTRING is demangled if necessary.)
382 Output goes to STREAM (via stdio).
383 If SHOW is positive, we show the contents of the outermost level
384 of structure even if there is a type name that could be used instead.
385 If SHOW is negative, we never show the details of elements' types. */
388 type_print (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
391 LA_PRINT_TYPE (type
, varstring
, stream
, show
, 0, &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 std::move (stb
.string ());
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
->la_language
== language_c
478 || current_language
->la_language
== language_cplus
479 || current_language
->la_language
== language_rust
))
481 flags
.print_offsets
= 1;
482 flags
.print_typedefs
= 0;
483 flags
.print_methods
= 0;
488 error (_("unrecognized flag '%c'"), *exp
);
493 if (!*exp
&& !seen_one
)
494 error (_("flag expected"));
496 error (_("expected space after format"));
497 exp
= skip_spaces (exp
);
500 expression_up expr
= parse_expression (exp
);
502 /* The behavior of "whatis" depends on whether the user
503 expression names a type directly, or a language expression
504 (including variable names). If the former, then "whatis"
505 strips one level of typedefs, only. If an expression,
506 "whatis" prints the type of the expression without stripping
507 any typedef level. "ptype" always strips all levels of
509 if (show
== -1 && expr
->elts
[0].opcode
== OP_TYPE
)
511 /* The user expression names a type directly. */
512 type
= expr
->elts
[1].type
;
514 /* If this is a typedef, then find its immediate target.
515 Use check_typedef to resolve stubs, but ignore its result
516 because we do not want to dig past all typedefs. */
517 check_typedef (type
);
518 if (type
->code () == TYPE_CODE_TYPEDEF
)
519 type
= TYPE_TARGET_TYPE (type
);
521 /* If the expression is actually a type, then there's no
522 value to fetch the dynamic type from. */
527 /* The user expression names a type indirectly by naming an
528 object or expression of that type. Find that
529 indirectly-named type. */
530 val
= evaluate_type (expr
.get ());
531 type
= value_type (val
);
536 val
= access_value_history (0);
537 type
= value_type (val
);
540 get_user_print_options (&opts
);
541 if (val
!= NULL
&& opts
.objectprint
)
543 if (((type
->code () == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
544 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_STRUCT
))
545 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
546 else if (type
->code () == TYPE_CODE_STRUCT
)
547 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
550 if (flags
.print_offsets
551 && (type
->code () == TYPE_CODE_STRUCT
552 || type
->code () == TYPE_CODE_UNION
))
553 fprintf_filtered (gdb_stdout
, "/* offset | size */ ");
555 printf_filtered ("type = ");
557 std::unique_ptr
<typedef_hash_table
> table_holder
;
558 std::unique_ptr
<ext_lang_type_printers
> printer_holder
;
561 table_holder
.reset (new typedef_hash_table
);
562 flags
.global_typedefs
= table_holder
.get ();
564 printer_holder
.reset (new ext_lang_type_printers
);
565 flags
.global_printers
= printer_holder
.get ();
570 printf_filtered ("/* real type = ");
571 type_print (real_type
, "", gdb_stdout
, -1);
573 printf_filtered (" (incomplete object)");
574 printf_filtered (" */\n");
577 LA_PRINT_TYPE (type
, "", gdb_stdout
, show
, 0, &flags
);
578 printf_filtered ("\n");
582 whatis_command (const char *exp
, int from_tty
)
584 /* Most of the time users do not want to see all the fields
585 in a structure. If they do they can use the "ptype" command.
586 Hence the "-1" below. */
587 whatis_exp (exp
, -1);
590 /* TYPENAME is either the name of a type, or an expression. */
593 ptype_command (const char *type_name
, int from_tty
)
595 whatis_exp (type_name
, 1);
598 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
599 Used to print data from type structures in a specified type. For example,
600 array bounds may be characters or booleans in some languages, and this
601 allows the ranges to be printed in their "natural" form rather than as
602 decimal integer values.
604 FIXME: This is here simply because only the type printing routines
605 currently use it, and it wasn't clear if it really belonged somewhere
606 else (like printcmd.c). There are a lot of other gdb routines that do
607 something similar, but they are generally concerned with printing values
608 that come from the inferior in target byte order and target size. */
611 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
616 type
= check_typedef (type
);
618 switch (type
->code ())
622 len
= type
->num_fields ();
623 for (i
= 0; i
< len
; i
++)
625 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
632 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
636 print_longest (stream
, 'd', 0, val
);
641 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
645 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
649 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
652 case TYPE_CODE_RANGE
:
653 print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
656 case TYPE_CODE_UNDEF
:
658 case TYPE_CODE_ARRAY
:
659 case TYPE_CODE_STRUCT
:
660 case TYPE_CODE_UNION
:
665 case TYPE_CODE_STRING
:
666 case TYPE_CODE_ERROR
:
667 case TYPE_CODE_MEMBERPTR
:
668 case TYPE_CODE_METHODPTR
:
669 case TYPE_CODE_METHOD
:
671 case TYPE_CODE_RVALUE_REF
:
672 case TYPE_CODE_NAMESPACE
:
673 error (_("internal error: unhandled type in print_type_scalar"));
677 error (_("Invalid type code in symbol table."));
681 /* Dump details of a type specified either directly or indirectly.
682 Uses the same sort of type lookup mechanism as ptype_command()
683 and whatis_command(). */
686 maintenance_print_type (const char *type_name
, int from_tty
)
691 if (type_name
!= NULL
)
693 expression_up expr
= parse_expression (type_name
);
694 if (expr
->elts
[0].opcode
== OP_TYPE
)
696 /* The user expression names a type directly, just use that type. */
697 type
= expr
->elts
[1].type
;
701 /* The user expression may name a type indirectly by naming an
702 object of that type. Find that indirectly named type. */
703 val
= evaluate_type (expr
.get ());
704 type
= value_type (val
);
708 recursive_dump_type (type
, 0);
714 struct cmd_list_element
*setprinttypelist
;
716 struct cmd_list_element
*showprinttypelist
;
718 static bool print_methods
= true;
721 set_print_type_methods (const char *args
,
722 int from_tty
, struct cmd_list_element
*c
)
724 default_ptype_flags
.print_methods
= print_methods
;
728 show_print_type_methods (struct ui_file
*file
, int from_tty
,
729 struct cmd_list_element
*c
, const char *value
)
731 fprintf_filtered (file
, _("Printing of methods defined in a class in %s\n"),
735 static bool print_typedefs
= true;
738 set_print_type_typedefs (const char *args
,
739 int from_tty
, struct cmd_list_element
*c
)
741 default_ptype_flags
.print_typedefs
= print_typedefs
;
745 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
746 struct cmd_list_element
*c
, const char *value
)
748 fprintf_filtered (file
, _("Printing of typedefs defined in a class in %s\n"),
752 /* Limit on the number of nested type definitions to print or -1 to print
753 all nested type definitions in a class. By default, we do not print
754 nested definitions. */
756 static int print_nested_type_limit
= 0;
758 /* Set how many nested type definitions should be printed by the type
762 set_print_type_nested_types (const char *args
, int from_tty
,
763 struct cmd_list_element
*c
)
765 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
768 /* Show how many nested type definitions the type printer will print. */
771 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
772 struct cmd_list_element
*c
, const char *value
)
776 fprintf_filtered (file
,
777 _("Will not print nested types defined in a class\n"));
781 fprintf_filtered (file
,
782 _("Will print %s nested types defined in a class\n"),
787 void _initialize_typeprint ();
789 _initialize_typeprint ()
791 struct cmd_list_element
*c
;
793 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
794 Print definition of type TYPE.\n\
795 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
796 Argument may be any type (for example a type name defined by typedef,\n\
797 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
798 or \"enum ENUM-TAG\") or an expression.\n\
799 The selected stack frame's lexical context is used to look up the name.\n\
800 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
802 Available FLAGS are:\n\
803 /r print in \"raw\" form; do not substitute typedefs\n\
804 /m do not print methods defined in a class\n\
805 /M print methods defined in a class\n\
806 /t do not print typedefs defined in a class\n\
807 /T print typedefs defined in a class\n\
808 /o print offsets and sizes of fields in a struct (like pahole)"));
809 set_cmd_completer (c
, expression_completer
);
811 c
= add_com ("whatis", class_vars
, whatis_command
,
812 _("Print data type of expression EXP.\n\
813 Only one level of typedefs is unrolled. See also \"ptype\"."));
814 set_cmd_completer (c
, expression_completer
);
816 add_show_prefix_cmd ("type", no_class
,
817 _("Generic command for showing type-printing settings."),
818 &showprinttypelist
, "show print type ", 0,
820 add_basic_prefix_cmd ("type", no_class
,
821 _("Generic command for setting how types print."),
822 &setprinttypelist
, "set print type ", 0,
825 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
827 Set printing of methods defined in classes."), _("\
828 Show printing of methods defined in classes."), NULL
,
829 set_print_type_methods
,
830 show_print_type_methods
,
831 &setprinttypelist
, &showprinttypelist
);
832 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
834 Set printing of typedefs defined in classes."), _("\
835 Show printing of typedefs defined in classes."), NULL
,
836 set_print_type_typedefs
,
837 show_print_type_typedefs
,
838 &setprinttypelist
, &showprinttypelist
);
840 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
841 &print_nested_type_limit
,
843 Set the number of recursive nested type definitions to print \
844 (\"unlimited\" or -1 to show all)."), _("\
845 Show the number of recursive nested type definitions to print."), NULL
,
846 set_print_type_nested_types
,
847 show_print_type_nested_types
,
848 &setprinttypelist
, &showprinttypelist
);
851 /* Print <not allocated> status to stream STREAM. */
854 val_print_not_allocated (struct ui_file
*stream
)
856 fprintf_styled (stream
, metadata_style
.style (), _("<not allocated>"));
859 /* Print <not associated> status to stream STREAM. */
862 val_print_not_associated (struct ui_file
*stream
)
864 fprintf_styled (stream
, metadata_style
.style (), _("<not associated>"));