Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / typeprint.c
CommitLineData
5796c8dc
SS
1/* Language independent support for printing types for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "gdb_obstack.h"
22#include "bfd.h" /* Binary File Description */
23#include "symtab.h"
24#include "gdbtypes.h"
25#include "expression.h"
26#include "value.h"
27#include "gdbcore.h"
28#include "command.h"
29#include "gdbcmd.h"
30#include "target.h"
31#include "language.h"
32#include "cp-abi.h"
33#include "typeprint.h"
34#include "gdb_string.h"
35#include "exceptions.h"
36#include "valprint.h"
37#include <errno.h>
ef5ccd6c
JM
38#include <ctype.h>
39#include "cli/cli-utils.h"
40#include "python/python.h"
41#include "completer.h"
5796c8dc
SS
42
43extern void _initialize_typeprint (void);
44
45static void ptype_command (char *, int);
46
47static void whatis_command (char *, int);
48
49static void whatis_exp (char *, int);
50
ef5ccd6c
JM
51const struct type_print_options type_print_raw_options =
52{
53 1, /* raw */
54 1, /* print_methods */
55 1, /* print_typedefs */
56 NULL, /* local_typedefs */
57 NULL, /* global_table */
58 NULL /* global_printers */
59};
60
61/* The default flags for 'ptype' and 'whatis'. */
62
63static struct type_print_options default_ptype_flags =
64{
65 0, /* raw */
66 1, /* print_methods */
67 1, /* print_typedefs */
68 NULL, /* local_typedefs */
69 NULL, /* global_table */
70 NULL /* global_printers */
71};
72
73\f
74
75/* A hash table holding typedef_field objects. This is more
76 complicated than an ordinary hash because it must also track the
77 lifetime of some -- but not all -- of the contained objects. */
78
79struct typedef_hash_table
80{
81 /* The actual hash table. */
82 htab_t table;
83
84 /* Storage for typedef_field objects that must be synthesized. */
85 struct obstack storage;
86};
87
88/* A hash function for a typedef_field. */
89
90static hashval_t
91hash_typedef_field (const void *p)
92{
93 const struct typedef_field *tf = p;
94 struct type *t = check_typedef (tf->type);
95
96 return htab_hash_string (TYPE_SAFE_NAME (t));
97}
98
99/* An equality function for a typedef field. */
100
101static int
102eq_typedef_field (const void *a, const void *b)
103{
104 const struct typedef_field *tfa = a;
105 const struct typedef_field *tfb = b;
106
107 return types_equal (tfa->type, tfb->type);
108}
109
110/* Add typedefs from T to the hash table TABLE. */
111
112void
113recursively_update_typedef_hash (struct typedef_hash_table *table,
114 struct type *t)
115{
116 int i;
117
118 if (table == NULL)
119 return;
120
121 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
122 {
123 struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
124 void **slot;
125
126 slot = htab_find_slot (table->table, tdef, INSERT);
127 /* Only add a given typedef name once. Really this shouldn't
128 happen; but it is safe enough to do the updates breadth-first
129 and thus use the most specific typedef. */
130 if (*slot == NULL)
131 *slot = tdef;
132 }
133
134 /* Recurse into superclasses. */
135 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
136 recursively_update_typedef_hash (table, TYPE_BASECLASS (t, i));
137}
138
139/* Add template parameters from T to the typedef hash TABLE. */
140
141void
142add_template_parameters (struct typedef_hash_table *table, struct type *t)
143{
144 int i;
145
146 if (table == NULL)
147 return;
148
149 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
150 {
151 struct typedef_field *tf;
152 void **slot;
153
154 /* We only want type-valued template parameters in the hash. */
155 if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
156 continue;
157
158 tf = XOBNEW (&table->storage, struct typedef_field);
159 tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
160 tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
161
162 slot = htab_find_slot (table->table, tf, INSERT);
163 if (*slot == NULL)
164 *slot = tf;
165 }
166}
167
168/* Create a new typedef-lookup hash table. */
169
170struct typedef_hash_table *
171create_typedef_hash (void)
172{
173 struct typedef_hash_table *result;
174
175 result = XNEW (struct typedef_hash_table);
176 result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
177 NULL, xcalloc, xfree);
178 obstack_init (&result->storage);
179
180 return result;
181}
182
183/* Free a typedef field table. */
184
185void
186free_typedef_hash (struct typedef_hash_table *table)
187{
188 if (table != NULL)
189 {
190 htab_delete (table->table);
191 obstack_free (&table->storage, NULL);
192 xfree (table);
193 }
194}
195
196/* A cleanup for freeing a typedef_hash_table. */
197
198static void
199do_free_typedef_hash (void *arg)
200{
201 free_typedef_hash (arg);
202}
203
204/* Return a new cleanup that frees TABLE. */
205
206struct cleanup *
207make_cleanup_free_typedef_hash (struct typedef_hash_table *table)
208{
209 return make_cleanup (do_free_typedef_hash, table);
210}
211
212/* Helper function for copy_typedef_hash. */
213
214static int
215copy_typedef_hash_element (void **slot, void *nt)
216{
217 htab_t new_table = nt;
218 void **new_slot;
219
220 new_slot = htab_find_slot (new_table, *slot, INSERT);
221 if (*new_slot == NULL)
222 *new_slot = *slot;
223
224 return 1;
225}
226
227/* Copy a typedef hash. */
228
229struct typedef_hash_table *
230copy_typedef_hash (struct typedef_hash_table *table)
231{
232 struct typedef_hash_table *result;
233
234 if (table == NULL)
235 return NULL;
236
237 result = create_typedef_hash ();
238 htab_traverse_noresize (table->table, copy_typedef_hash_element,
239 result->table);
240 return result;
241}
242
243/* A cleanup to free the global typedef hash. */
244
245static void
246do_free_global_table (void *arg)
247{
248 struct type_print_options *flags = arg;
249
250 free_typedef_hash (flags->global_typedefs);
251 free_type_printers (flags->global_printers);
252}
253
254/* Create the global typedef hash. */
255
256static struct cleanup *
257create_global_typedef_table (struct type_print_options *flags)
258{
259 gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL);
260 flags->global_typedefs = create_typedef_hash ();
261 flags->global_printers = start_type_printers ();
262 return make_cleanup (do_free_global_table, flags);
263}
264
265/* Look up the type T in the global typedef hash. If it is found,
266 return the typedef name. If it is not found, apply the
267 type-printers, if any, given by start_type_printers and return the
268 result. A NULL return means that the name was not found. */
269
270static const char *
271find_global_typedef (const struct type_print_options *flags,
272 struct type *t)
273{
274 char *applied;
275 void **slot;
276 struct typedef_field tf, *new_tf;
277
278 if (flags->global_typedefs == NULL)
279 return NULL;
280
281 tf.name = NULL;
282 tf.type = t;
283
284 slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT);
285 if (*slot != NULL)
286 {
287 new_tf = *slot;
288 return new_tf->name;
289 }
290
291 /* Put an entry into the hash table now, in case apply_type_printers
292 recurses. */
293 new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field);
294 new_tf->name = NULL;
295 new_tf->type = t;
296
297 *slot = new_tf;
298
299 applied = apply_type_printers (flags->global_printers, t);
300
301 if (applied != NULL)
302 {
303 new_tf->name = obstack_copy0 (&flags->global_typedefs->storage, applied,
304 strlen (applied));
305 xfree (applied);
306 }
307
308 return new_tf->name;
309}
310
311/* Look up the type T in the typedef hash table in with FLAGS. If T
312 is in the table, return its short (class-relative) typedef name.
313 Otherwise return NULL. If the table is NULL, this always returns
314 NULL. */
315
316const char *
317find_typedef_in_hash (const struct type_print_options *flags, struct type *t)
318{
319 if (flags->local_typedefs != NULL)
320 {
321 struct typedef_field tf, *found;
322
323 tf.name = NULL;
324 tf.type = t;
325 found = htab_find (flags->local_typedefs->table, &tf);
326
327 if (found != NULL)
328 return found->name;
329 }
330
331 return find_global_typedef (flags, t);
332}
333
334\f
5796c8dc
SS
335
336/* Print a description of a type in the format of a
337 typedef for the current language.
c50c785c 338 NEW is the new name for a type TYPE. */
5796c8dc
SS
339
340void
341typedef_print (struct type *type, struct symbol *new, struct ui_file *stream)
342{
343 LA_PRINT_TYPEDEF (type, new, stream);
344}
345
346/* The default way to print a typedef. */
347
348void
349default_print_typedef (struct type *type, struct symbol *new_symbol,
350 struct ui_file *stream)
351{
352 error (_("Language not supported."));
353}
354
355/* Print a description of a type TYPE in the form of a declaration of a
356 variable named VARSTRING. (VARSTRING is demangled if necessary.)
357 Output goes to STREAM (via stdio).
358 If SHOW is positive, we show the contents of the outermost level
359 of structure even if there is a type name that could be used instead.
360 If SHOW is negative, we never show the details of elements' types. */
361
362void
ef5ccd6c 363type_print (struct type *type, const char *varstring, struct ui_file *stream,
5796c8dc
SS
364 int show)
365{
ef5ccd6c 366 LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
5796c8dc
SS
367}
368
369/* Print TYPE to a string, returning it. The caller is responsible for
370 freeing the string. */
371
372char *
373type_to_string (struct type *type)
374{
375 char *s = NULL;
376 struct ui_file *stb;
377 struct cleanup *old_chain;
378 volatile struct gdb_exception except;
379
380 stb = mem_fileopen ();
381 old_chain = make_cleanup_ui_file_delete (stb);
382
383 TRY_CATCH (except, RETURN_MASK_ALL)
384 {
385 type_print (type, "", stb, -1);
386 s = ui_file_xstrdup (stb, NULL);
387 }
388 if (except.reason < 0)
389 s = NULL;
390
391 do_cleanups (old_chain);
392
393 return s;
394}
395
396/* Print type of EXP, or last thing in value history if EXP == NULL.
397 show is passed to type_print. */
398
399static void
400whatis_exp (char *exp, int show)
401{
402 struct expression *expr;
403 struct value *val;
ef5ccd6c 404 struct cleanup *old_chain;
5796c8dc
SS
405 struct type *real_type = NULL;
406 struct type *type;
407 int full = 0;
408 int top = -1;
409 int using_enc = 0;
410 struct value_print_options opts;
ef5ccd6c
JM
411 struct type_print_options flags = default_ptype_flags;
412
413 old_chain = make_cleanup (null_cleanup, NULL);
5796c8dc
SS
414
415 if (exp)
416 {
ef5ccd6c
JM
417 if (*exp == '/')
418 {
419 int seen_one = 0;
420
421 for (++exp; *exp && !isspace (*exp); ++exp)
422 {
423 switch (*exp)
424 {
425 case 'r':
426 flags.raw = 1;
427 break;
428 case 'm':
429 flags.print_methods = 0;
430 break;
431 case 'M':
432 flags.print_methods = 1;
433 break;
434 case 't':
435 flags.print_typedefs = 0;
436 break;
437 case 'T':
438 flags.print_typedefs = 1;
439 break;
440 default:
441 error (_("unrecognized flag '%c'"), *exp);
442 }
443 seen_one = 1;
444 }
445
446 if (!*exp && !seen_one)
447 error (_("flag expected"));
448 if (!isspace (*exp))
449 error (_("expected space after format"));
450 exp = skip_spaces (exp);
451 }
452
5796c8dc 453 expr = parse_expression (exp);
ef5ccd6c 454 make_cleanup (free_current_contents, &expr);
5796c8dc
SS
455 val = evaluate_type (expr);
456 }
457 else
458 val = access_value_history (0);
459
460 type = value_type (val);
461
462 get_user_print_options (&opts);
463 if (opts.objectprint)
464 {
465 if (((TYPE_CODE (type) == TYPE_CODE_PTR)
466 || (TYPE_CODE (type) == TYPE_CODE_REF))
467 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
ef5ccd6c 468 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
5796c8dc
SS
469 else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
470 real_type = value_rtti_type (val, &full, &top, &using_enc);
471 }
472
473 printf_filtered ("type = ");
474
ef5ccd6c
JM
475 if (!flags.raw)
476 create_global_typedef_table (&flags);
477
5796c8dc
SS
478 if (real_type)
479 {
480 printf_filtered ("/* real type = ");
481 type_print (real_type, "", gdb_stdout, -1);
482 if (! full)
483 printf_filtered (" (incomplete object)");
484 printf_filtered (" */\n");
485 }
486
ef5ccd6c 487 LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
5796c8dc
SS
488 printf_filtered ("\n");
489
ef5ccd6c 490 do_cleanups (old_chain);
5796c8dc
SS
491}
492
493static void
494whatis_command (char *exp, int from_tty)
495{
496 /* Most of the time users do not want to see all the fields
497 in a structure. If they do they can use the "ptype" command.
498 Hence the "-1" below. */
499 whatis_exp (exp, -1);
500}
501
502/* TYPENAME is either the name of a type, or an expression. */
503
504static void
505ptype_command (char *typename, int from_tty)
506{
507 whatis_exp (typename, 1);
508}
509
510/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
511 Used to print data from type structures in a specified type. For example,
512 array bounds may be characters or booleans in some languages, and this
513 allows the ranges to be printed in their "natural" form rather than as
514 decimal integer values.
515
516 FIXME: This is here simply because only the type printing routines
517 currently use it, and it wasn't clear if it really belonged somewhere
518 else (like printcmd.c). There are a lot of other gdb routines that do
519 something similar, but they are generally concerned with printing values
520 that come from the inferior in target byte order and target size. */
521
522void
523print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
524{
525 unsigned int i;
526 unsigned len;
527
528 CHECK_TYPEDEF (type);
529
530 switch (TYPE_CODE (type))
531 {
532
533 case TYPE_CODE_ENUM:
534 len = TYPE_NFIELDS (type);
535 for (i = 0; i < len; i++)
536 {
ef5ccd6c 537 if (TYPE_FIELD_ENUMVAL (type, i) == val)
5796c8dc
SS
538 {
539 break;
540 }
541 }
542 if (i < len)
543 {
544 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
545 }
546 else
547 {
548 print_longest (stream, 'd', 0, val);
549 }
550 break;
551
552 case TYPE_CODE_INT:
553 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
554 break;
555
556 case TYPE_CODE_CHAR:
557 LA_PRINT_CHAR ((unsigned char) val, type, stream);
558 break;
559
560 case TYPE_CODE_BOOL:
561 fprintf_filtered (stream, val ? "TRUE" : "FALSE");
562 break;
563
564 case TYPE_CODE_RANGE:
565 print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
566 return;
567
568 case TYPE_CODE_UNDEF:
569 case TYPE_CODE_PTR:
570 case TYPE_CODE_ARRAY:
571 case TYPE_CODE_STRUCT:
572 case TYPE_CODE_UNION:
573 case TYPE_CODE_FUNC:
574 case TYPE_CODE_FLT:
575 case TYPE_CODE_VOID:
576 case TYPE_CODE_SET:
577 case TYPE_CODE_STRING:
578 case TYPE_CODE_ERROR:
579 case TYPE_CODE_MEMBERPTR:
580 case TYPE_CODE_METHODPTR:
581 case TYPE_CODE_METHOD:
582 case TYPE_CODE_REF:
583 case TYPE_CODE_NAMESPACE:
584 error (_("internal error: unhandled type in print_type_scalar"));
585 break;
586
587 default:
588 error (_("Invalid type code in symbol table."));
589 }
590 gdb_flush (stream);
591}
592
593/* Dump details of a type specified either directly or indirectly.
594 Uses the same sort of type lookup mechanism as ptype_command()
595 and whatis_command(). */
596
597void
598maintenance_print_type (char *typename, int from_tty)
599{
600 struct value *val;
601 struct type *type;
602 struct cleanup *old_chain;
603 struct expression *expr;
604
605 if (typename != NULL)
606 {
607 expr = parse_expression (typename);
608 old_chain = make_cleanup (free_current_contents, &expr);
609 if (expr->elts[0].opcode == OP_TYPE)
610 {
c50c785c 611 /* The user expression names a type directly, just use that type. */
5796c8dc
SS
612 type = expr->elts[1].type;
613 }
614 else
615 {
616 /* The user expression may name a type indirectly by naming an
c50c785c 617 object of that type. Find that indirectly named type. */
5796c8dc
SS
618 val = evaluate_type (expr);
619 type = value_type (val);
620 }
621 if (type != NULL)
622 {
623 recursive_dump_type (type, 0);
624 }
625 do_cleanups (old_chain);
626 }
627}
628\f
629
ef5ccd6c
JM
630struct cmd_list_element *setprinttypelist;
631
632struct cmd_list_element *showprinttypelist;
633
634static void
635set_print_type (char *arg, int from_tty)
636{
637 printf_unfiltered (
638 "\"set print type\" must be followed by the name of a subcommand.\n");
639 help_list (setprintlist, "set print type ", -1, gdb_stdout);
640}
641
642static void
643show_print_type (char *args, int from_tty)
644{
645 cmd_show_list (showprinttypelist, from_tty, "");
646}
647
648static int print_methods = 1;
649
650static void
651set_print_type_methods (char *args, int from_tty, struct cmd_list_element *c)
652{
653 default_ptype_flags.print_methods = print_methods;
654}
655
656static void
657show_print_type_methods (struct ui_file *file, int from_tty,
658 struct cmd_list_element *c, const char *value)
659{
660 fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
661 value);
662}
663
664static int print_typedefs = 1;
665
666static void
667set_print_type_typedefs (char *args, int from_tty, struct cmd_list_element *c)
668{
669 default_ptype_flags.print_typedefs = print_typedefs;
670}
671
672static void
673show_print_type_typedefs (struct ui_file *file, int from_tty,
674 struct cmd_list_element *c, const char *value)
675{
676 fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
677 value);
678}
679
5796c8dc
SS
680void
681_initialize_typeprint (void)
682{
ef5ccd6c
JM
683 struct cmd_list_element *c;
684
685 c = add_com ("ptype", class_vars, ptype_command, _("\
5796c8dc 686Print definition of type TYPE.\n\
ef5ccd6c 687Usage: ptype[/FLAGS] TYPE-NAME | EXPRESSION\n\
5796c8dc
SS
688Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
689or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
a45ae5f8 690The selected stack frame's lexical context is used to look up the name.\n\
ef5ccd6c
JM
691Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
692\n\
693Available FLAGS are:\n\
694 /r print in \"raw\" form; do not substitute typedefs\n\
695 /m do not print methods defined in a class\n\
696 /M print methods defined in a class\n\
697 /t do not print typedefs defined in a class\n\
698 /T print typedefs defined in a class"));
699 set_cmd_completer (c, expression_completer);
700
701 c = add_com ("whatis", class_vars, whatis_command,
702 _("Print data type of expression EXP.\n\
a45ae5f8 703Only one level of typedefs is unrolled. See also \"ptype\"."));
ef5ccd6c
JM
704 set_cmd_completer (c, expression_completer);
705
706 add_prefix_cmd ("type", no_class, show_print_type,
707 _("Generic command for showing type-printing settings."),
708 &showprinttypelist, "show print type ", 0, &showprintlist);
709 add_prefix_cmd ("type", no_class, set_print_type,
710 _("Generic command for setting how types print."),
711 &setprinttypelist, "show print type ", 0, &setprintlist);
712
713 add_setshow_boolean_cmd ("methods", no_class, &print_methods,
714 _("\
715Set printing of methods defined in classes."), _("\
716Show printing of methods defined in classes."), NULL,
717 set_print_type_methods,
718 show_print_type_methods,
719 &setprinttypelist, &showprinttypelist);
720 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
721 _("\
722Set printing of typedefs defined in classes."), _("\
723Show printing of typedefs defined in classes."), NULL,
724 set_print_type_typedefs,
725 show_print_type_typedefs,
726 &setprinttypelist, &showprinttypelist);
5796c8dc 727}