1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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 /* A hash table holding typedef_field objects. This is more
69 complicated than an ordinary hash because it must also track the
70 lifetime of some -- but not all -- of the contained objects. */
72 struct typedef_hash_table
74 /* The actual hash table. */
77 /* Storage for typedef_field objects that must be synthesized. */
78 struct obstack storage
;
81 /* A hash function for a typedef_field. */
84 hash_typedef_field (const void *p
)
86 const struct decl_field
*tf
= (const struct decl_field
*) p
;
87 struct type
*t
= check_typedef (tf
->type
);
89 return htab_hash_string (TYPE_SAFE_NAME (t
));
92 /* An equality function for a typedef field. */
95 eq_typedef_field (const void *a
, const void *b
)
97 const struct decl_field
*tfa
= (const struct decl_field
*) a
;
98 const struct decl_field
*tfb
= (const struct decl_field
*) b
;
100 return types_equal (tfa
->type
, tfb
->type
);
103 /* Add typedefs from T to the hash table TABLE. */
106 recursively_update_typedef_hash (struct typedef_hash_table
*table
,
114 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
116 struct decl_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
119 slot
= htab_find_slot (table
->table
, tdef
, INSERT
);
120 /* Only add a given typedef name once. Really this shouldn't
121 happen; but it is safe enough to do the updates breadth-first
122 and thus use the most specific typedef. */
127 /* Recurse into superclasses. */
128 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
129 recursively_update_typedef_hash (table
, TYPE_BASECLASS (t
, i
));
132 /* Add template parameters from T to the typedef hash TABLE. */
135 add_template_parameters (struct typedef_hash_table
*table
, struct type
*t
)
142 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
144 struct decl_field
*tf
;
147 /* We only want type-valued template parameters in the hash. */
148 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t
, i
)) != LOC_TYPEDEF
)
151 tf
= XOBNEW (&table
->storage
, struct decl_field
);
152 tf
->name
= SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t
, i
));
153 tf
->type
= SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t
, i
));
155 slot
= htab_find_slot (table
->table
, tf
, INSERT
);
161 /* Create a new typedef-lookup hash table. */
163 struct typedef_hash_table
*
164 create_typedef_hash (void)
166 struct typedef_hash_table
*result
;
168 result
= XNEW (struct typedef_hash_table
);
169 result
->table
= htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
170 NULL
, xcalloc
, xfree
);
171 obstack_init (&result
->storage
);
176 /* Free a typedef field table. */
179 free_typedef_hash (struct typedef_hash_table
*table
)
183 htab_delete (table
->table
);
184 obstack_free (&table
->storage
, NULL
);
189 /* A cleanup for freeing a typedef_hash_table. */
192 do_free_typedef_hash (void *arg
)
194 free_typedef_hash ((struct typedef_hash_table
*) arg
);
197 /* Return a new cleanup that frees TABLE. */
200 make_cleanup_free_typedef_hash (struct typedef_hash_table
*table
)
202 return make_cleanup (do_free_typedef_hash
, table
);
205 /* Helper function for copy_typedef_hash. */
208 copy_typedef_hash_element (void **slot
, void *nt
)
210 htab_t new_table
= (htab_t
) nt
;
213 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
214 if (*new_slot
== NULL
)
220 /* Copy a typedef hash. */
222 struct typedef_hash_table
*
223 copy_typedef_hash (struct typedef_hash_table
*table
)
225 struct typedef_hash_table
*result
;
230 result
= create_typedef_hash ();
231 htab_traverse_noresize (table
->table
, copy_typedef_hash_element
,
236 /* A cleanup to free the global typedef hash. */
239 do_free_global_table (void *arg
)
241 struct type_print_options
*flags
= (struct type_print_options
*) arg
;
243 free_typedef_hash (flags
->global_typedefs
);
244 free_ext_lang_type_printers (flags
->global_printers
);
247 /* Create the global typedef hash. */
249 static struct cleanup
*
250 create_global_typedef_table (struct type_print_options
*flags
)
252 gdb_assert (flags
->global_typedefs
== NULL
&& flags
->global_printers
== NULL
);
253 flags
->global_typedefs
= create_typedef_hash ();
254 flags
->global_printers
= start_ext_lang_type_printers ();
255 return make_cleanup (do_free_global_table
, flags
);
258 /* Look up the type T in the global typedef hash. If it is found,
259 return the typedef name. If it is not found, apply the
260 type-printers, if any, given by start_script_type_printers and return the
261 result. A NULL return means that the name was not found. */
264 find_global_typedef (const struct type_print_options
*flags
,
269 struct decl_field tf
, *new_tf
;
271 if (flags
->global_typedefs
== NULL
)
277 slot
= htab_find_slot (flags
->global_typedefs
->table
, &tf
, INSERT
);
280 new_tf
= (struct decl_field
*) *slot
;
284 /* Put an entry into the hash table now, in case
285 apply_ext_lang_type_printers recurses. */
286 new_tf
= XOBNEW (&flags
->global_typedefs
->storage
, struct decl_field
);
292 applied
= apply_ext_lang_type_printers (flags
->global_printers
, t
);
297 = (const char *) obstack_copy0 (&flags
->global_typedefs
->storage
,
298 applied
, strlen (applied
));
305 /* Look up the type T in the typedef hash table in with FLAGS. If T
306 is in the table, return its short (class-relative) typedef name.
307 Otherwise return NULL. If the table is NULL, this always returns
311 find_typedef_in_hash (const struct type_print_options
*flags
, struct type
*t
)
313 if (flags
->local_typedefs
!= NULL
)
315 struct decl_field tf
, *found
;
319 found
= (struct decl_field
*) htab_find (flags
->local_typedefs
->table
,
326 return find_global_typedef (flags
, t
);
331 /* Print a description of a type in the format of a
332 typedef for the current language.
333 NEW is the new name for a type TYPE. */
336 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
338 LA_PRINT_TYPEDEF (type
, newobj
, stream
);
341 /* The default way to print a typedef. */
344 default_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
345 struct ui_file
*stream
)
347 error (_("Language not supported."));
350 /* Print a description of a type TYPE in the form of a declaration of a
351 variable named VARSTRING. (VARSTRING is demangled if necessary.)
352 Output goes to STREAM (via stdio).
353 If SHOW is positive, we show the contents of the outermost level
354 of structure even if there is a type name that could be used instead.
355 If SHOW is negative, we never show the details of elements' types. */
358 type_print (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
361 LA_PRINT_TYPE (type
, varstring
, stream
, show
, 0, &default_ptype_flags
);
364 /* Print TYPE to a string, returning it. The caller is responsible for
365 freeing the string. */
368 type_to_string (struct type
*type
)
374 type_print (type
, "", &stb
, -1);
375 return std::move (stb
.string ());
377 CATCH (except
, RETURN_MASK_ALL
)
385 /* See typeprint.h. */
388 type_print_unknown_return_type (struct ui_file
*stream
)
390 fprintf_filtered (stream
, _("<unknown return type>"));
393 /* See typeprint.h. */
396 error_unknown_type (const char *sym_print_name
)
398 error (_("'%s' has unknown type; cast it to its declared type"),
402 /* Print type of EXP, or last thing in value history if EXP == NULL.
403 show is passed to type_print. */
406 whatis_exp (const char *exp
, int show
)
409 struct cleanup
*old_chain
;
410 struct type
*real_type
= NULL
;
415 struct value_print_options opts
;
416 struct type_print_options flags
= default_ptype_flags
;
418 old_chain
= make_cleanup (null_cleanup
, NULL
);
426 for (++exp
; *exp
&& !isspace (*exp
); ++exp
)
434 flags
.print_methods
= 0;
437 flags
.print_methods
= 1;
440 flags
.print_typedefs
= 0;
443 flags
.print_typedefs
= 1;
447 /* Filter out languages which don't implement the
450 && (current_language
->la_language
== language_c
451 || current_language
->la_language
== language_cplus
))
453 flags
.print_offsets
= 1;
454 flags
.print_typedefs
= 0;
455 flags
.print_methods
= 0;
460 error (_("unrecognized flag '%c'"), *exp
);
465 if (!*exp
&& !seen_one
)
466 error (_("flag expected"));
468 error (_("expected space after format"));
469 exp
= skip_spaces (exp
);
472 expression_up expr
= parse_expression (exp
);
474 /* The behavior of "whatis" depends on whether the user
475 expression names a type directly, or a language expression
476 (including variable names). If the former, then "whatis"
477 strips one level of typedefs, only. If an expression,
478 "whatis" prints the type of the expression without stripping
479 any typedef level. "ptype" always strips all levels of
481 if (show
== -1 && expr
->elts
[0].opcode
== OP_TYPE
)
483 /* The user expression names a type directly. */
484 type
= expr
->elts
[1].type
;
486 /* If this is a typedef, then find its immediate target.
487 Use check_typedef to resolve stubs, but ignore its result
488 because we do not want to dig past all typedefs. */
489 check_typedef (type
);
490 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
491 type
= TYPE_TARGET_TYPE (type
);
493 /* If the expression is actually a type, then there's no
494 value to fetch the dynamic type from. */
499 /* The user expression names a type indirectly by naming an
500 object or expression of that type. Find that
501 indirectly-named type. */
502 val
= evaluate_type (expr
.get ());
503 type
= value_type (val
);
508 val
= access_value_history (0);
509 type
= value_type (val
);
512 get_user_print_options (&opts
);
513 if (val
!= NULL
&& opts
.objectprint
)
515 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
516 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
517 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
518 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
519 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
522 if (flags
.print_offsets
523 && (TYPE_CODE (type
) == TYPE_CODE_STRUCT
524 || TYPE_CODE (type
) == TYPE_CODE_UNION
))
525 fprintf_filtered (gdb_stdout
, "/* offset | size */ ");
527 printf_filtered ("type = ");
530 create_global_typedef_table (&flags
);
534 printf_filtered ("/* real type = ");
535 type_print (real_type
, "", gdb_stdout
, -1);
537 printf_filtered (" (incomplete object)");
538 printf_filtered (" */\n");
541 LA_PRINT_TYPE (type
, "", gdb_stdout
, show
, 0, &flags
);
542 printf_filtered ("\n");
544 do_cleanups (old_chain
);
548 whatis_command (const char *exp
, int from_tty
)
550 /* Most of the time users do not want to see all the fields
551 in a structure. If they do they can use the "ptype" command.
552 Hence the "-1" below. */
553 whatis_exp (exp
, -1);
556 /* TYPENAME is either the name of a type, or an expression. */
559 ptype_command (const char *type_name
, int from_tty
)
561 whatis_exp (type_name
, 1);
564 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
565 Used to print data from type structures in a specified type. For example,
566 array bounds may be characters or booleans in some languages, and this
567 allows the ranges to be printed in their "natural" form rather than as
568 decimal integer values.
570 FIXME: This is here simply because only the type printing routines
571 currently use it, and it wasn't clear if it really belonged somewhere
572 else (like printcmd.c). There are a lot of other gdb routines that do
573 something similar, but they are generally concerned with printing values
574 that come from the inferior in target byte order and target size. */
577 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
582 type
= check_typedef (type
);
584 switch (TYPE_CODE (type
))
588 len
= TYPE_NFIELDS (type
);
589 for (i
= 0; i
< len
; i
++)
591 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
598 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
602 print_longest (stream
, 'd', 0, val
);
607 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
611 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
615 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
618 case TYPE_CODE_RANGE
:
619 print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
622 case TYPE_CODE_UNDEF
:
624 case TYPE_CODE_ARRAY
:
625 case TYPE_CODE_STRUCT
:
626 case TYPE_CODE_UNION
:
631 case TYPE_CODE_STRING
:
632 case TYPE_CODE_ERROR
:
633 case TYPE_CODE_MEMBERPTR
:
634 case TYPE_CODE_METHODPTR
:
635 case TYPE_CODE_METHOD
:
637 case TYPE_CODE_RVALUE_REF
:
638 case TYPE_CODE_NAMESPACE
:
639 error (_("internal error: unhandled type in print_type_scalar"));
643 error (_("Invalid type code in symbol table."));
648 /* Dump details of a type specified either directly or indirectly.
649 Uses the same sort of type lookup mechanism as ptype_command()
650 and whatis_command(). */
653 maintenance_print_type (const char *type_name
, int from_tty
)
658 if (type_name
!= NULL
)
660 expression_up expr
= parse_expression (type_name
);
661 if (expr
->elts
[0].opcode
== OP_TYPE
)
663 /* The user expression names a type directly, just use that type. */
664 type
= expr
->elts
[1].type
;
668 /* The user expression may name a type indirectly by naming an
669 object of that type. Find that indirectly named type. */
670 val
= evaluate_type (expr
.get ());
671 type
= value_type (val
);
675 recursive_dump_type (type
, 0);
681 struct cmd_list_element
*setprinttypelist
;
683 struct cmd_list_element
*showprinttypelist
;
686 set_print_type (const char *arg
, int from_tty
)
689 "\"set print type\" must be followed by the name of a subcommand.\n");
690 help_list (setprintlist
, "set print type ", all_commands
, gdb_stdout
);
694 show_print_type (const char *args
, int from_tty
)
696 cmd_show_list (showprinttypelist
, from_tty
, "");
699 static int print_methods
= 1;
702 set_print_type_methods (const char *args
,
703 int from_tty
, struct cmd_list_element
*c
)
705 default_ptype_flags
.print_methods
= print_methods
;
709 show_print_type_methods (struct ui_file
*file
, int from_tty
,
710 struct cmd_list_element
*c
, const char *value
)
712 fprintf_filtered (file
, _("Printing of methods defined in a class in %s\n"),
716 static int print_typedefs
= 1;
719 set_print_type_typedefs (const char *args
,
720 int from_tty
, struct cmd_list_element
*c
)
722 default_ptype_flags
.print_typedefs
= print_typedefs
;
726 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
727 struct cmd_list_element
*c
, const char *value
)
729 fprintf_filtered (file
, _("Printing of typedefs defined in a class in %s\n"),
733 /* Limit on the number of nested type definitions to print or -1 to print
734 all nested type definitions in a class. By default, we do not print
735 nested definitions. */
737 static int print_nested_type_limit
= 0;
739 /* Set how many nested type definitions should be printed by the type
743 set_print_type_nested_types (const char *args
, int from_tty
,
744 struct cmd_list_element
*c
)
746 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
749 /* Show how many nested type definitions the type printer will print. */
752 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
753 struct cmd_list_element
*c
, const char *value
)
757 fprintf_filtered (file
,
758 _("Will not print nested types defined in a class\n"));
762 fprintf_filtered (file
,
763 _("Will print %s nested types defined in a class\n"),
769 _initialize_typeprint (void)
771 struct cmd_list_element
*c
;
773 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
774 Print definition of type TYPE.\n\
775 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
776 Argument may be any type (for example a type name defined by typedef,\n\
777 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
778 or \"enum ENUM-TAG\") or an expression.\n\
779 The selected stack frame's lexical context is used to look up the name.\n\
780 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
782 Available FLAGS are:\n\
783 /r print in \"raw\" form; do not substitute typedefs\n\
784 /m do not print methods defined in a class\n\
785 /M print methods defined in a class\n\
786 /t do not print typedefs defined in a class\n\
787 /T print typedefs defined in a class\n\
788 /o print offsets and sizes of fields in a struct (like pahole)\n"));
789 set_cmd_completer (c
, expression_completer
);
791 c
= add_com ("whatis", class_vars
, whatis_command
,
792 _("Print data type of expression EXP.\n\
793 Only one level of typedefs is unrolled. See also \"ptype\"."));
794 set_cmd_completer (c
, expression_completer
);
796 add_prefix_cmd ("type", no_class
, show_print_type
,
797 _("Generic command for showing type-printing settings."),
798 &showprinttypelist
, "show print type ", 0, &showprintlist
);
799 add_prefix_cmd ("type", no_class
, set_print_type
,
800 _("Generic command for setting how types print."),
801 &setprinttypelist
, "show print type ", 0, &setprintlist
);
803 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
805 Set printing of methods defined in classes."), _("\
806 Show printing of methods defined in classes."), NULL
,
807 set_print_type_methods
,
808 show_print_type_methods
,
809 &setprinttypelist
, &showprinttypelist
);
810 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
812 Set printing of typedefs defined in classes."), _("\
813 Show printing of typedefs defined in classes."), NULL
,
814 set_print_type_typedefs
,
815 show_print_type_typedefs
,
816 &setprinttypelist
, &showprinttypelist
);
818 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
819 &print_nested_type_limit
,
821 Set the number of recursive nested type definitions to print \
822 (\"unlimited\" or -1 to show all)."), _("\
823 Show the number of recursive nested type definitions to print."), NULL
,
824 set_print_type_nested_types
,
825 show_print_type_nested_types
,
826 &setprinttypelist
, &showprinttypelist
);
829 /* Print <not allocated> status to stream STREAM. */
832 val_print_not_allocated (struct ui_file
*stream
)
834 fprintf_filtered (stream
, _("<not allocated>"));
837 /* Print <not associated> status to stream STREAM. */
840 val_print_not_associated (struct ui_file
*stream
)
842 fprintf_filtered (stream
, _("<not associated>"));