1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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
);
495 /* The user expression names a type indirectly by naming an
496 object or expression of that type. Find that
497 indirectly-named type. */
498 val
= evaluate_type (expr
.get ());
499 type
= value_type (val
);
504 val
= access_value_history (0);
505 type
= value_type (val
);
508 get_user_print_options (&opts
);
509 if (opts
.objectprint
)
511 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
512 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
513 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
514 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
515 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
518 if (flags
.print_offsets
519 && (TYPE_CODE (type
) == TYPE_CODE_STRUCT
520 || TYPE_CODE (type
) == TYPE_CODE_UNION
))
521 fprintf_filtered (gdb_stdout
, "/* offset | size */ ");
523 printf_filtered ("type = ");
526 create_global_typedef_table (&flags
);
530 printf_filtered ("/* real type = ");
531 type_print (real_type
, "", gdb_stdout
, -1);
533 printf_filtered (" (incomplete object)");
534 printf_filtered (" */\n");
537 LA_PRINT_TYPE (type
, "", gdb_stdout
, show
, 0, &flags
);
538 printf_filtered ("\n");
540 do_cleanups (old_chain
);
544 whatis_command (const char *exp
, int from_tty
)
546 /* Most of the time users do not want to see all the fields
547 in a structure. If they do they can use the "ptype" command.
548 Hence the "-1" below. */
549 whatis_exp (exp
, -1);
552 /* TYPENAME is either the name of a type, or an expression. */
555 ptype_command (const char *type_name
, int from_tty
)
557 whatis_exp (type_name
, 1);
560 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
561 Used to print data from type structures in a specified type. For example,
562 array bounds may be characters or booleans in some languages, and this
563 allows the ranges to be printed in their "natural" form rather than as
564 decimal integer values.
566 FIXME: This is here simply because only the type printing routines
567 currently use it, and it wasn't clear if it really belonged somewhere
568 else (like printcmd.c). There are a lot of other gdb routines that do
569 something similar, but they are generally concerned with printing values
570 that come from the inferior in target byte order and target size. */
573 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
578 type
= check_typedef (type
);
580 switch (TYPE_CODE (type
))
584 len
= TYPE_NFIELDS (type
);
585 for (i
= 0; i
< len
; i
++)
587 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
594 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
598 print_longest (stream
, 'd', 0, val
);
603 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
607 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
611 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
614 case TYPE_CODE_RANGE
:
615 print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
618 case TYPE_CODE_UNDEF
:
620 case TYPE_CODE_ARRAY
:
621 case TYPE_CODE_STRUCT
:
622 case TYPE_CODE_UNION
:
627 case TYPE_CODE_STRING
:
628 case TYPE_CODE_ERROR
:
629 case TYPE_CODE_MEMBERPTR
:
630 case TYPE_CODE_METHODPTR
:
631 case TYPE_CODE_METHOD
:
633 case TYPE_CODE_RVALUE_REF
:
634 case TYPE_CODE_NAMESPACE
:
635 error (_("internal error: unhandled type in print_type_scalar"));
639 error (_("Invalid type code in symbol table."));
644 /* Dump details of a type specified either directly or indirectly.
645 Uses the same sort of type lookup mechanism as ptype_command()
646 and whatis_command(). */
649 maintenance_print_type (const char *type_name
, int from_tty
)
654 if (type_name
!= NULL
)
656 expression_up expr
= parse_expression (type_name
);
657 if (expr
->elts
[0].opcode
== OP_TYPE
)
659 /* The user expression names a type directly, just use that type. */
660 type
= expr
->elts
[1].type
;
664 /* The user expression may name a type indirectly by naming an
665 object of that type. Find that indirectly named type. */
666 val
= evaluate_type (expr
.get ());
667 type
= value_type (val
);
671 recursive_dump_type (type
, 0);
677 struct cmd_list_element
*setprinttypelist
;
679 struct cmd_list_element
*showprinttypelist
;
682 set_print_type (const char *arg
, int from_tty
)
685 "\"set print type\" must be followed by the name of a subcommand.\n");
686 help_list (setprintlist
, "set print type ", all_commands
, gdb_stdout
);
690 show_print_type (const char *args
, int from_tty
)
692 cmd_show_list (showprinttypelist
, from_tty
, "");
695 static int print_methods
= 1;
698 set_print_type_methods (const char *args
,
699 int from_tty
, struct cmd_list_element
*c
)
701 default_ptype_flags
.print_methods
= print_methods
;
705 show_print_type_methods (struct ui_file
*file
, int from_tty
,
706 struct cmd_list_element
*c
, const char *value
)
708 fprintf_filtered (file
, _("Printing of methods defined in a class in %s\n"),
712 static int print_typedefs
= 1;
715 set_print_type_typedefs (const char *args
,
716 int from_tty
, struct cmd_list_element
*c
)
718 default_ptype_flags
.print_typedefs
= print_typedefs
;
722 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
723 struct cmd_list_element
*c
, const char *value
)
725 fprintf_filtered (file
, _("Printing of typedefs defined in a class in %s\n"),
729 /* Limit on the number of nested type definitions to print or -1 to print
730 all nested type definitions in a class. By default, we do not print
731 nested definitions. */
733 static int print_nested_type_limit
= 0;
735 /* Set how many nested type definitions should be printed by the type
739 set_print_type_nested_types (const char *args
, int from_tty
,
740 struct cmd_list_element
*c
)
742 default_ptype_flags
.print_nested_type_limit
= print_nested_type_limit
;
745 /* Show how many nested type definitions the type printer will print. */
748 show_print_type_nested_types (struct ui_file
*file
, int from_tty
,
749 struct cmd_list_element
*c
, const char *value
)
753 fprintf_filtered (file
,
754 _("Will not print nested types defined in a class\n"));
758 fprintf_filtered (file
,
759 _("Will print %s nested types defined in a class\n"),
765 _initialize_typeprint (void)
767 struct cmd_list_element
*c
;
769 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
770 Print definition of type TYPE.\n\
771 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
772 Argument may be any type (for example a type name defined by typedef,\n\
773 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
774 or \"enum ENUM-TAG\") or an expression.\n\
775 The selected stack frame's lexical context is used to look up the name.\n\
776 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
778 Available FLAGS are:\n\
779 /r print in \"raw\" form; do not substitute typedefs\n\
780 /m do not print methods defined in a class\n\
781 /M print methods defined in a class\n\
782 /t do not print typedefs defined in a class\n\
783 /T print typedefs defined in a class\n\
784 /o print offsets and sizes of fields in a struct (like pahole)\n"));
785 set_cmd_completer (c
, expression_completer
);
787 c
= add_com ("whatis", class_vars
, whatis_command
,
788 _("Print data type of expression EXP.\n\
789 Only one level of typedefs is unrolled. See also \"ptype\"."));
790 set_cmd_completer (c
, expression_completer
);
792 add_prefix_cmd ("type", no_class
, show_print_type
,
793 _("Generic command for showing type-printing settings."),
794 &showprinttypelist
, "show print type ", 0, &showprintlist
);
795 add_prefix_cmd ("type", no_class
, set_print_type
,
796 _("Generic command for setting how types print."),
797 &setprinttypelist
, "show print type ", 0, &setprintlist
);
799 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
801 Set printing of methods defined in classes."), _("\
802 Show printing of methods defined in classes."), NULL
,
803 set_print_type_methods
,
804 show_print_type_methods
,
805 &setprinttypelist
, &showprinttypelist
);
806 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
808 Set printing of typedefs defined in classes."), _("\
809 Show printing of typedefs defined in classes."), NULL
,
810 set_print_type_typedefs
,
811 show_print_type_typedefs
,
812 &setprinttypelist
, &showprinttypelist
);
814 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class
,
815 &print_nested_type_limit
,
817 Set the number of recursive nested type definitions to print \
818 (\"unlimited\" or -1 to show all)."), _("\
819 Show the number of recursive nested type definitions to print."), NULL
,
820 set_print_type_nested_types
,
821 show_print_type_nested_types
,
822 &setprinttypelist
, &showprinttypelist
);
825 /* Print <not allocated> status to stream STREAM. */
828 val_print_not_allocated (struct ui_file
*stream
)
830 fprintf_filtered (stream
, _("<not allocated>"));
833 /* Print <not associated> status to stream STREAM. */
836 val_print_not_associated (struct ui_file
*stream
)
838 fprintf_filtered (stream
, _("<not associated>"));