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 NULL, /* local_typedefs */
46 NULL, /* global_table */
47 NULL /* global_printers */
50 /* The default flags for 'ptype' and 'whatis'. */
52 static struct type_print_options default_ptype_flags =
55 1, /* print_methods */
56 1, /* print_typedefs */
57 NULL, /* local_typedefs */
58 NULL, /* global_table */
59 NULL /* global_printers */
64 /* A hash table holding typedef_field objects. This is more
65 complicated than an ordinary hash because it must also track the
66 lifetime of some -- but not all -- of the contained objects. */
68 struct typedef_hash_table
70 /* The actual hash table. */
73 /* Storage for typedef_field objects that must be synthesized. */
74 struct obstack storage;
77 /* A hash function for a typedef_field. */
80 hash_typedef_field (const void *p)
82 const struct typedef_field *tf = (const struct typedef_field *) p;
83 struct type *t = check_typedef (tf->type);
85 return htab_hash_string (TYPE_SAFE_NAME (t));
88 /* An equality function for a typedef field. */
91 eq_typedef_field (const void *a, const void *b)
93 const struct typedef_field *tfa = (const struct typedef_field *) a;
94 const struct typedef_field *tfb = (const struct typedef_field *) b;
96 return types_equal (tfa->type, tfb->type);
99 /* Add typedefs from T to the hash table TABLE. */
102 recursively_update_typedef_hash (struct typedef_hash_table *table,
110 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
112 struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
115 slot = htab_find_slot (table->table, tdef, INSERT);
116 /* Only add a given typedef name once. Really this shouldn't
117 happen; but it is safe enough to do the updates breadth-first
118 and thus use the most specific typedef. */
123 /* Recurse into superclasses. */
124 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
125 recursively_update_typedef_hash (table, TYPE_BASECLASS (t, i));
128 /* Add template parameters from T to the typedef hash TABLE. */
131 add_template_parameters (struct typedef_hash_table *table, struct type *t)
138 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
140 struct typedef_field *tf;
143 /* We only want type-valued template parameters in the hash. */
144 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
147 tf = XOBNEW (&table->storage, struct typedef_field);
148 tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
149 tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
151 slot = htab_find_slot (table->table, tf, INSERT);
157 /* Create a new typedef-lookup hash table. */
159 struct typedef_hash_table *
160 create_typedef_hash (void)
162 struct typedef_hash_table *result;
164 result = XNEW (struct typedef_hash_table);
165 result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
166 NULL, xcalloc, xfree);
167 obstack_init (&result->storage);
172 /* Free a typedef field table. */
175 free_typedef_hash (struct typedef_hash_table *table)
179 htab_delete (table->table);
180 obstack_free (&table->storage, NULL);
185 /* A cleanup for freeing a typedef_hash_table. */
188 do_free_typedef_hash (void *arg)
190 free_typedef_hash ((struct typedef_hash_table *) arg);
193 /* Return a new cleanup that frees TABLE. */
196 make_cleanup_free_typedef_hash (struct typedef_hash_table *table)
198 return make_cleanup (do_free_typedef_hash, table);
201 /* Helper function for copy_typedef_hash. */
204 copy_typedef_hash_element (void **slot, void *nt)
206 htab_t new_table = (htab_t) nt;
209 new_slot = htab_find_slot (new_table, *slot, INSERT);
210 if (*new_slot == NULL)
216 /* Copy a typedef hash. */
218 struct typedef_hash_table *
219 copy_typedef_hash (struct typedef_hash_table *table)
221 struct typedef_hash_table *result;
226 result = create_typedef_hash ();
227 htab_traverse_noresize (table->table, copy_typedef_hash_element,
232 /* A cleanup to free the global typedef hash. */
235 do_free_global_table (void *arg)
237 struct type_print_options *flags = (struct type_print_options *) arg;
239 free_typedef_hash (flags->global_typedefs);
240 free_ext_lang_type_printers (flags->global_printers);
243 /* Create the global typedef hash. */
245 static struct cleanup *
246 create_global_typedef_table (struct type_print_options *flags)
248 gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL);
249 flags->global_typedefs = create_typedef_hash ();
250 flags->global_printers = start_ext_lang_type_printers ();
251 return make_cleanup (do_free_global_table, flags);
254 /* Look up the type T in the global typedef hash. If it is found,
255 return the typedef name. If it is not found, apply the
256 type-printers, if any, given by start_script_type_printers and return the
257 result. A NULL return means that the name was not found. */
260 find_global_typedef (const struct type_print_options *flags,
265 struct typedef_field tf, *new_tf;
267 if (flags->global_typedefs == NULL)
273 slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT);
276 new_tf = (struct typedef_field *) *slot;
280 /* Put an entry into the hash table now, in case
281 apply_ext_lang_type_printers recurses. */
282 new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field);
288 applied = apply_ext_lang_type_printers (flags->global_printers, t);
293 = (const char *) obstack_copy0 (&flags->global_typedefs->storage,
294 applied, strlen (applied));
301 /* Look up the type T in the typedef hash table in with FLAGS. If T
302 is in the table, return its short (class-relative) typedef name.
303 Otherwise return NULL. If the table is NULL, this always returns
307 find_typedef_in_hash (const struct type_print_options *flags, struct type *t)
309 if (flags->local_typedefs != NULL)
311 struct typedef_field tf, *found;
315 found = (struct typedef_field *) htab_find (flags->local_typedefs->table,
322 return find_global_typedef (flags, t);
327 /* Print a description of a type in the format of a
328 typedef for the current language.
329 NEW is the new name for a type TYPE. */
332 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
334 LA_PRINT_TYPEDEF (type, newobj, stream);
337 /* The default way to print a typedef. */
340 default_print_typedef (struct type *type, struct symbol *new_symbol,
341 struct ui_file *stream)
343 error (_("Language not supported."));
346 /* Print a description of a type TYPE in the form of a declaration of a
347 variable named VARSTRING. (VARSTRING is demangled if necessary.)
348 Output goes to STREAM (via stdio).
349 If SHOW is positive, we show the contents of the outermost level
350 of structure even if there is a type name that could be used instead.
351 If SHOW is negative, we never show the details of elements' types. */
354 type_print (struct type *type, const char *varstring, struct ui_file *stream,
357 LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
360 /* Print TYPE to a string, returning it. The caller is responsible for
361 freeing the string. */
364 type_to_string (struct type *type)
370 type_print (type, "", &stb, -1);
371 return std::move (stb.string ());
373 CATCH (except, RETURN_MASK_ALL)
381 /* See typeprint.h. */
384 type_print_unknown_return_type (struct ui_file *stream)
386 fprintf_filtered (stream, _("<unknown return type>"));
389 /* See typeprint.h. */
392 error_unknown_type (const char *sym_print_name)
394 error (_("'%s' has unknown type; cast it to its declared type"),
398 /* Print type of EXP, or last thing in value history if EXP == NULL.
399 show is passed to type_print. */
402 whatis_exp (const char *exp, int show)
405 struct cleanup *old_chain;
406 struct type *real_type = NULL;
411 struct value_print_options opts;
412 struct type_print_options flags = default_ptype_flags;
414 old_chain = make_cleanup (null_cleanup, NULL);
422 for (++exp; *exp && !isspace (*exp); ++exp)
430 flags.print_methods = 0;
433 flags.print_methods = 1;
436 flags.print_typedefs = 0;
439 flags.print_typedefs = 1;
442 error (_("unrecognized flag '%c'"), *exp);
447 if (!*exp && !seen_one)
448 error (_("flag expected"));
450 error (_("expected space after format"));
451 exp = skip_spaces (exp);
454 expression_up expr = parse_expression (exp);
456 /* The behavior of "whatis" depends on whether the user
457 expression names a type directly, or a language expression
458 (including variable names). If the former, then "whatis"
459 strips one level of typedefs, only. If an expression,
460 "whatis" prints the type of the expression without stripping
461 any typedef level. "ptype" always strips all levels of
463 if (show == -1 && expr->elts[0].opcode == OP_TYPE)
465 /* The user expression names a type directly. */
466 type = expr->elts[1].type;
468 /* If this is a typedef, then find its immediate target.
469 Use check_typedef to resolve stubs, but ignore its result
470 because we do not want to dig past all typedefs. */
471 check_typedef (type);
472 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
473 type = TYPE_TARGET_TYPE (type);
477 /* The user expression names a type indirectly by naming an
478 object or expression of that type. Find that
479 indirectly-named type. */
480 val = evaluate_type (expr.get ());
481 type = value_type (val);
486 val = access_value_history (0);
487 type = value_type (val);
490 get_user_print_options (&opts);
491 if (opts.objectprint)
493 if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
494 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
495 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
496 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
497 real_type = value_rtti_type (val, &full, &top, &using_enc);
500 printf_filtered ("type = ");
503 create_global_typedef_table (&flags);
507 printf_filtered ("/* real type = ");
508 type_print (real_type, "", gdb_stdout, -1);
510 printf_filtered (" (incomplete object)");
511 printf_filtered (" */\n");
514 LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
515 printf_filtered ("\n");
517 do_cleanups (old_chain);
521 whatis_command (const char *exp, int from_tty)
523 /* Most of the time users do not want to see all the fields
524 in a structure. If they do they can use the "ptype" command.
525 Hence the "-1" below. */
526 whatis_exp (exp, -1);
529 /* TYPENAME is either the name of a type, or an expression. */
532 ptype_command (const char *type_name, int from_tty)
534 whatis_exp (type_name, 1);
537 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
538 Used to print data from type structures in a specified type. For example,
539 array bounds may be characters or booleans in some languages, and this
540 allows the ranges to be printed in their "natural" form rather than as
541 decimal integer values.
543 FIXME: This is here simply because only the type printing routines
544 currently use it, and it wasn't clear if it really belonged somewhere
545 else (like printcmd.c). There are a lot of other gdb routines that do
546 something similar, but they are generally concerned with printing values
547 that come from the inferior in target byte order and target size. */
550 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
555 type = check_typedef (type);
557 switch (TYPE_CODE (type))
561 len = TYPE_NFIELDS (type);
562 for (i = 0; i < len; i++)
564 if (TYPE_FIELD_ENUMVAL (type, i) == val)
571 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
575 print_longest (stream, 'd', 0, val);
580 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
584 LA_PRINT_CHAR ((unsigned char) val, type, stream);
588 fprintf_filtered (stream, val ? "TRUE" : "FALSE");
591 case TYPE_CODE_RANGE:
592 print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
595 case TYPE_CODE_UNDEF:
597 case TYPE_CODE_ARRAY:
598 case TYPE_CODE_STRUCT:
599 case TYPE_CODE_UNION:
604 case TYPE_CODE_STRING:
605 case TYPE_CODE_ERROR:
606 case TYPE_CODE_MEMBERPTR:
607 case TYPE_CODE_METHODPTR:
608 case TYPE_CODE_METHOD:
610 case TYPE_CODE_RVALUE_REF:
611 case TYPE_CODE_NAMESPACE:
612 error (_("internal error: unhandled type in print_type_scalar"));
616 error (_("Invalid type code in symbol table."));
621 /* Dump details of a type specified either directly or indirectly.
622 Uses the same sort of type lookup mechanism as ptype_command()
623 and whatis_command(). */
626 maintenance_print_type (const char *type_name, int from_tty)
631 if (type_name != NULL)
633 expression_up expr = parse_expression (type_name);
634 if (expr->elts[0].opcode == OP_TYPE)
636 /* The user expression names a type directly, just use that type. */
637 type = expr->elts[1].type;
641 /* The user expression may name a type indirectly by naming an
642 object of that type. Find that indirectly named type. */
643 val = evaluate_type (expr.get ());
644 type = value_type (val);
648 recursive_dump_type (type, 0);
654 struct cmd_list_element *setprinttypelist;
656 struct cmd_list_element *showprinttypelist;
659 set_print_type (const char *arg, int from_tty)
662 "\"set print type\" must be followed by the name of a subcommand.\n");
663 help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
667 show_print_type (const char *args, int from_tty)
669 cmd_show_list (showprinttypelist, from_tty, "");
672 static int print_methods = 1;
675 set_print_type_methods (const char *args,
676 int from_tty, struct cmd_list_element *c)
678 default_ptype_flags.print_methods = print_methods;
682 show_print_type_methods (struct ui_file *file, int from_tty,
683 struct cmd_list_element *c, const char *value)
685 fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
689 static int print_typedefs = 1;
692 set_print_type_typedefs (const char *args,
693 int from_tty, struct cmd_list_element *c)
695 default_ptype_flags.print_typedefs = print_typedefs;
699 show_print_type_typedefs (struct ui_file *file, int from_tty,
700 struct cmd_list_element *c, const char *value)
702 fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
707 _initialize_typeprint (void)
709 struct cmd_list_element *c;
711 c = add_com ("ptype", class_vars, ptype_command, _("\
712 Print definition of type TYPE.\n\
713 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
714 Argument may be any type (for example a type name defined by typedef,\n\
715 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
716 or \"enum ENUM-TAG\") or an expression.\n\
717 The selected stack frame's lexical context is used to look up the name.\n\
718 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
720 Available FLAGS are:\n\
721 /r print in \"raw\" form; do not substitute typedefs\n\
722 /m do not print methods defined in a class\n\
723 /M print methods defined in a class\n\
724 /t do not print typedefs defined in a class\n\
725 /T print typedefs defined in a class"));
726 set_cmd_completer (c, expression_completer);
728 c = add_com ("whatis", class_vars, whatis_command,
729 _("Print data type of expression EXP.\n\
730 Only one level of typedefs is unrolled. See also \"ptype\"."));
731 set_cmd_completer (c, expression_completer);
733 add_prefix_cmd ("type", no_class, show_print_type,
734 _("Generic command for showing type-printing settings."),
735 &showprinttypelist, "show print type ", 0, &showprintlist);
736 add_prefix_cmd ("type", no_class, set_print_type,
737 _("Generic command for setting how types print."),
738 &setprinttypelist, "show print type ", 0, &setprintlist);
740 add_setshow_boolean_cmd ("methods", no_class, &print_methods,
742 Set printing of methods defined in classes."), _("\
743 Show printing of methods defined in classes."), NULL,
744 set_print_type_methods,
745 show_print_type_methods,
746 &setprinttypelist, &showprinttypelist);
747 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
749 Set printing of typedefs defined in classes."), _("\
750 Show printing of typedefs defined in classes."), NULL,
751 set_print_type_typedefs,
752 show_print_type_typedefs,
753 &setprinttypelist, &showprinttypelist);
756 /* Print <not allocated> status to stream STREAM. */
759 val_print_not_allocated (struct ui_file *stream)
761 fprintf_filtered (stream, _("<not allocated>"));
764 /* Print <not associated> status to stream STREAM. */
767 val_print_not_associated (struct ui_file *stream)
769 fprintf_filtered (stream, _("<not associated>"));