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 extern void _initialize_typeprint (void);
42 static void ptype_command (char *, int);
44 static void whatis_command (char *, int);
46 static void whatis_exp (char *, int);
48 const struct type_print_options type_print_raw_options
=
51 1, /* print_methods */
52 1, /* print_typedefs */
53 NULL
, /* local_typedefs */
54 NULL
, /* global_table */
55 NULL
/* global_printers */
58 /* The default flags for 'ptype' and 'whatis'. */
60 static struct type_print_options default_ptype_flags
=
63 1, /* print_methods */
64 1, /* print_typedefs */
65 NULL
, /* local_typedefs */
66 NULL
, /* global_table */
67 NULL
/* global_printers */
72 /* A hash table holding typedef_field objects. This is more
73 complicated than an ordinary hash because it must also track the
74 lifetime of some -- but not all -- of the contained objects. */
76 struct typedef_hash_table
78 /* The actual hash table. */
81 /* Storage for typedef_field objects that must be synthesized. */
82 struct obstack storage
;
85 /* A hash function for a typedef_field. */
88 hash_typedef_field (const void *p
)
90 const struct typedef_field
*tf
= (const struct typedef_field
*) p
;
91 struct type
*t
= check_typedef (tf
->type
);
93 return htab_hash_string (TYPE_SAFE_NAME (t
));
96 /* An equality function for a typedef field. */
99 eq_typedef_field (const void *a
, const void *b
)
101 const struct typedef_field
*tfa
= (const struct typedef_field
*) a
;
102 const struct typedef_field
*tfb
= (const struct typedef_field
*) b
;
104 return types_equal (tfa
->type
, tfb
->type
);
107 /* Add typedefs from T to the hash table TABLE. */
110 recursively_update_typedef_hash (struct typedef_hash_table
*table
,
118 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (t
); ++i
)
120 struct typedef_field
*tdef
= &TYPE_TYPEDEF_FIELD (t
, i
);
123 slot
= htab_find_slot (table
->table
, tdef
, INSERT
);
124 /* Only add a given typedef name once. Really this shouldn't
125 happen; but it is safe enough to do the updates breadth-first
126 and thus use the most specific typedef. */
131 /* Recurse into superclasses. */
132 for (i
= 0; i
< TYPE_N_BASECLASSES (t
); ++i
)
133 recursively_update_typedef_hash (table
, TYPE_BASECLASS (t
, i
));
136 /* Add template parameters from T to the typedef hash TABLE. */
139 add_template_parameters (struct typedef_hash_table
*table
, struct type
*t
)
146 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (t
); ++i
)
148 struct typedef_field
*tf
;
151 /* We only want type-valued template parameters in the hash. */
152 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t
, i
)) != LOC_TYPEDEF
)
155 tf
= XOBNEW (&table
->storage
, struct typedef_field
);
156 tf
->name
= SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t
, i
));
157 tf
->type
= SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t
, i
));
159 slot
= htab_find_slot (table
->table
, tf
, INSERT
);
165 /* Create a new typedef-lookup hash table. */
167 struct typedef_hash_table
*
168 create_typedef_hash (void)
170 struct typedef_hash_table
*result
;
172 result
= XNEW (struct typedef_hash_table
);
173 result
->table
= htab_create_alloc (10, hash_typedef_field
, eq_typedef_field
,
174 NULL
, xcalloc
, xfree
);
175 obstack_init (&result
->storage
);
180 /* Free a typedef field table. */
183 free_typedef_hash (struct typedef_hash_table
*table
)
187 htab_delete (table
->table
);
188 obstack_free (&table
->storage
, NULL
);
193 /* A cleanup for freeing a typedef_hash_table. */
196 do_free_typedef_hash (void *arg
)
198 free_typedef_hash ((struct typedef_hash_table
*) arg
);
201 /* Return a new cleanup that frees TABLE. */
204 make_cleanup_free_typedef_hash (struct typedef_hash_table
*table
)
206 return make_cleanup (do_free_typedef_hash
, table
);
209 /* Helper function for copy_typedef_hash. */
212 copy_typedef_hash_element (void **slot
, void *nt
)
214 htab_t new_table
= (htab_t
) nt
;
217 new_slot
= htab_find_slot (new_table
, *slot
, INSERT
);
218 if (*new_slot
== NULL
)
224 /* Copy a typedef hash. */
226 struct typedef_hash_table
*
227 copy_typedef_hash (struct typedef_hash_table
*table
)
229 struct typedef_hash_table
*result
;
234 result
= create_typedef_hash ();
235 htab_traverse_noresize (table
->table
, copy_typedef_hash_element
,
240 /* A cleanup to free the global typedef hash. */
243 do_free_global_table (void *arg
)
245 struct type_print_options
*flags
= (struct type_print_options
*) arg
;
247 free_typedef_hash (flags
->global_typedefs
);
248 free_ext_lang_type_printers (flags
->global_printers
);
251 /* Create the global typedef hash. */
253 static struct cleanup
*
254 create_global_typedef_table (struct type_print_options
*flags
)
256 gdb_assert (flags
->global_typedefs
== NULL
&& flags
->global_printers
== NULL
);
257 flags
->global_typedefs
= create_typedef_hash ();
258 flags
->global_printers
= start_ext_lang_type_printers ();
259 return make_cleanup (do_free_global_table
, flags
);
262 /* Look up the type T in the global typedef hash. If it is found,
263 return the typedef name. If it is not found, apply the
264 type-printers, if any, given by start_script_type_printers and return the
265 result. A NULL return means that the name was not found. */
268 find_global_typedef (const struct type_print_options
*flags
,
273 struct typedef_field tf
, *new_tf
;
275 if (flags
->global_typedefs
== NULL
)
281 slot
= htab_find_slot (flags
->global_typedefs
->table
, &tf
, INSERT
);
284 new_tf
= (struct typedef_field
*) *slot
;
288 /* Put an entry into the hash table now, in case
289 apply_ext_lang_type_printers recurses. */
290 new_tf
= XOBNEW (&flags
->global_typedefs
->storage
, struct typedef_field
);
296 applied
= apply_ext_lang_type_printers (flags
->global_printers
, t
);
301 = (const char *) obstack_copy0 (&flags
->global_typedefs
->storage
,
302 applied
, strlen (applied
));
309 /* Look up the type T in the typedef hash table in with FLAGS. If T
310 is in the table, return its short (class-relative) typedef name.
311 Otherwise return NULL. If the table is NULL, this always returns
315 find_typedef_in_hash (const struct type_print_options
*flags
, struct type
*t
)
317 if (flags
->local_typedefs
!= NULL
)
319 struct typedef_field tf
, *found
;
323 found
= (struct typedef_field
*) htab_find (flags
->local_typedefs
->table
,
330 return find_global_typedef (flags
, t
);
335 /* Print a description of a type in the format of a
336 typedef for the current language.
337 NEW is the new name for a type TYPE. */
340 typedef_print (struct type
*type
, struct symbol
*newobj
, struct ui_file
*stream
)
342 LA_PRINT_TYPEDEF (type
, newobj
, stream
);
345 /* The default way to print a typedef. */
348 default_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
349 struct ui_file
*stream
)
351 error (_("Language not supported."));
354 /* Print a description of a type TYPE in the form of a declaration of a
355 variable named VARSTRING. (VARSTRING is demangled if necessary.)
356 Output goes to STREAM (via stdio).
357 If SHOW is positive, we show the contents of the outermost level
358 of structure even if there is a type name that could be used instead.
359 If SHOW is negative, we never show the details of elements' types. */
362 type_print (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
365 LA_PRINT_TYPE (type
, varstring
, stream
, show
, 0, &default_ptype_flags
);
368 /* Print TYPE to a string, returning it. The caller is responsible for
369 freeing the string. */
372 type_to_string (struct type
*type
)
378 type_print (type
, "", &stb
, -1);
379 return std::move (stb
.string ());
381 CATCH (except
, RETURN_MASK_ALL
)
389 /* See typeprint.h. */
392 type_print_unknown_return_type (struct ui_file
*stream
)
394 fprintf_filtered (stream
, _("<unknown return type>"));
397 /* See typeprint.h. */
400 error_unknown_type (const char *sym_print_name
)
402 error (_("'%s' has unknown type; cast it to its declared type"),
406 /* Print type of EXP, or last thing in value history if EXP == NULL.
407 show is passed to type_print. */
410 whatis_exp (char *exp
, int show
)
413 struct cleanup
*old_chain
;
414 struct type
*real_type
= NULL
;
419 struct value_print_options opts
;
420 struct type_print_options flags
= default_ptype_flags
;
422 old_chain
= make_cleanup (null_cleanup
, NULL
);
430 for (++exp
; *exp
&& !isspace (*exp
); ++exp
)
438 flags
.print_methods
= 0;
441 flags
.print_methods
= 1;
444 flags
.print_typedefs
= 0;
447 flags
.print_typedefs
= 1;
450 error (_("unrecognized flag '%c'"), *exp
);
455 if (!*exp
&& !seen_one
)
456 error (_("flag expected"));
458 error (_("expected space after format"));
459 exp
= skip_spaces (exp
);
462 expression_up expr
= parse_expression (exp
);
464 /* The behavior of "whatis" depends on whether the user
465 expression names a type directly, or a language expression
466 (including variable names). If the former, then "whatis"
467 strips one level of typedefs, only. If an expression,
468 "whatis" prints the type of the expression without stripping
469 any typedef level. "ptype" always strips all levels of
471 if (show
== -1 && expr
->elts
[0].opcode
== OP_TYPE
)
473 /* The user expression names a type directly. */
474 type
= expr
->elts
[1].type
;
476 /* If this is a typedef, then find its immediate target.
477 Use check_typedef to resolve stubs, but ignore its result
478 because we do not want to dig past all typedefs. */
479 check_typedef (type
);
480 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
481 type
= TYPE_TARGET_TYPE (type
);
485 /* The user expression names a type indirectly by naming an
486 object or expression of that type. Find that
487 indirectly-named type. */
488 val
= evaluate_type (expr
.get ());
489 type
= value_type (val
);
494 val
= access_value_history (0);
495 type
= value_type (val
);
498 get_user_print_options (&opts
);
499 if (opts
.objectprint
)
501 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
502 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
503 real_type
= value_rtti_indirect_type (val
, &full
, &top
, &using_enc
);
504 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
505 real_type
= value_rtti_type (val
, &full
, &top
, &using_enc
);
508 printf_filtered ("type = ");
511 create_global_typedef_table (&flags
);
515 printf_filtered ("/* real type = ");
516 type_print (real_type
, "", gdb_stdout
, -1);
518 printf_filtered (" (incomplete object)");
519 printf_filtered (" */\n");
522 LA_PRINT_TYPE (type
, "", gdb_stdout
, show
, 0, &flags
);
523 printf_filtered ("\n");
525 do_cleanups (old_chain
);
529 whatis_command (char *exp
, int from_tty
)
531 /* Most of the time users do not want to see all the fields
532 in a structure. If they do they can use the "ptype" command.
533 Hence the "-1" below. */
534 whatis_exp (exp
, -1);
537 /* TYPENAME is either the name of a type, or an expression. */
540 ptype_command (char *type_name
, int from_tty
)
542 whatis_exp (type_name
, 1);
545 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
546 Used to print data from type structures in a specified type. For example,
547 array bounds may be characters or booleans in some languages, and this
548 allows the ranges to be printed in their "natural" form rather than as
549 decimal integer values.
551 FIXME: This is here simply because only the type printing routines
552 currently use it, and it wasn't clear if it really belonged somewhere
553 else (like printcmd.c). There are a lot of other gdb routines that do
554 something similar, but they are generally concerned with printing values
555 that come from the inferior in target byte order and target size. */
558 print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
563 type
= check_typedef (type
);
565 switch (TYPE_CODE (type
))
569 len
= TYPE_NFIELDS (type
);
570 for (i
= 0; i
< len
; i
++)
572 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
579 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
583 print_longest (stream
, 'd', 0, val
);
588 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
592 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
596 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
599 case TYPE_CODE_RANGE
:
600 print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
603 case TYPE_CODE_UNDEF
:
605 case TYPE_CODE_ARRAY
:
606 case TYPE_CODE_STRUCT
:
607 case TYPE_CODE_UNION
:
612 case TYPE_CODE_STRING
:
613 case TYPE_CODE_ERROR
:
614 case TYPE_CODE_MEMBERPTR
:
615 case TYPE_CODE_METHODPTR
:
616 case TYPE_CODE_METHOD
:
618 case TYPE_CODE_RVALUE_REF
:
619 case TYPE_CODE_NAMESPACE
:
620 error (_("internal error: unhandled type in print_type_scalar"));
624 error (_("Invalid type code in symbol table."));
629 /* Dump details of a type specified either directly or indirectly.
630 Uses the same sort of type lookup mechanism as ptype_command()
631 and whatis_command(). */
634 maintenance_print_type (char *type_name
, int from_tty
)
639 if (type_name
!= NULL
)
641 expression_up expr
= parse_expression (type_name
);
642 if (expr
->elts
[0].opcode
== OP_TYPE
)
644 /* The user expression names a type directly, just use that type. */
645 type
= expr
->elts
[1].type
;
649 /* The user expression may name a type indirectly by naming an
650 object of that type. Find that indirectly named type. */
651 val
= evaluate_type (expr
.get ());
652 type
= value_type (val
);
656 recursive_dump_type (type
, 0);
662 struct cmd_list_element
*setprinttypelist
;
664 struct cmd_list_element
*showprinttypelist
;
667 set_print_type (char *arg
, int from_tty
)
670 "\"set print type\" must be followed by the name of a subcommand.\n");
671 help_list (setprintlist
, "set print type ", all_commands
, gdb_stdout
);
675 show_print_type (char *args
, int from_tty
)
677 cmd_show_list (showprinttypelist
, from_tty
, "");
680 static int print_methods
= 1;
683 set_print_type_methods (char *args
, int from_tty
, struct cmd_list_element
*c
)
685 default_ptype_flags
.print_methods
= print_methods
;
689 show_print_type_methods (struct ui_file
*file
, int from_tty
,
690 struct cmd_list_element
*c
, const char *value
)
692 fprintf_filtered (file
, _("Printing of methods defined in a class in %s\n"),
696 static int print_typedefs
= 1;
699 set_print_type_typedefs (char *args
, int from_tty
, struct cmd_list_element
*c
)
701 default_ptype_flags
.print_typedefs
= print_typedefs
;
705 show_print_type_typedefs (struct ui_file
*file
, int from_tty
,
706 struct cmd_list_element
*c
, const char *value
)
708 fprintf_filtered (file
, _("Printing of typedefs defined in a class in %s\n"),
713 _initialize_typeprint (void)
715 struct cmd_list_element
*c
;
717 c
= add_com ("ptype", class_vars
, ptype_command
, _("\
718 Print definition of type TYPE.\n\
719 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
720 Argument may be any type (for example a type name defined by typedef,\n\
721 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
722 or \"enum ENUM-TAG\") or an expression.\n\
723 The selected stack frame's lexical context is used to look up the name.\n\
724 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
726 Available FLAGS are:\n\
727 /r print in \"raw\" form; do not substitute typedefs\n\
728 /m do not print methods defined in a class\n\
729 /M print methods defined in a class\n\
730 /t do not print typedefs defined in a class\n\
731 /T print typedefs defined in a class"));
732 set_cmd_completer (c
, expression_completer
);
734 c
= add_com ("whatis", class_vars
, whatis_command
,
735 _("Print data type of expression EXP.\n\
736 Only one level of typedefs is unrolled. See also \"ptype\"."));
737 set_cmd_completer (c
, expression_completer
);
739 add_prefix_cmd ("type", no_class
, show_print_type
,
740 _("Generic command for showing type-printing settings."),
741 &showprinttypelist
, "show print type ", 0, &showprintlist
);
742 add_prefix_cmd ("type", no_class
, set_print_type
,
743 _("Generic command for setting how types print."),
744 &setprinttypelist
, "show print type ", 0, &setprintlist
);
746 add_setshow_boolean_cmd ("methods", no_class
, &print_methods
,
748 Set printing of methods defined in classes."), _("\
749 Show printing of methods defined in classes."), NULL
,
750 set_print_type_methods
,
751 show_print_type_methods
,
752 &setprinttypelist
, &showprinttypelist
);
753 add_setshow_boolean_cmd ("typedefs", no_class
, &print_typedefs
,
755 Set printing of typedefs defined in classes."), _("\
756 Show printing of typedefs defined in classes."), NULL
,
757 set_print_type_typedefs
,
758 show_print_type_typedefs
,
759 &setprinttypelist
, &showprinttypelist
);
762 /* Print <not allocated> status to stream STREAM. */
765 val_print_not_allocated (struct ui_file
*stream
)
767 fprintf_filtered (stream
, _("<not allocated>"));
770 /* Print <not associated> status to stream STREAM. */
773 val_print_not_associated (struct ui_file
*stream
)
775 fprintf_filtered (stream
, _("<not associated>"));