1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_obstack.h"
26 #include "expression.h"
32 #include "gdb_string.h"
37 #include "cp-support.h"
39 #include "python/python.h"
41 /* Controls printing of vtbl's */
43 show_vtblprint (struct ui_file *file, int from_tty,
44 struct cmd_list_element *c, const char *value)
46 fprintf_filtered (file, _("\
47 Printing of C++ virtual function tables is %s.\n"),
51 /* Controls looking up an object's derived type using what we find in
54 show_objectprint (struct ui_file *file, int from_tty,
55 struct cmd_list_element *c,
58 fprintf_filtered (file, _("\
59 Printing of object's derived type based on vtable info is %s.\n"),
64 show_static_field_print (struct ui_file *file, int from_tty,
65 struct cmd_list_element *c, const char *value)
67 fprintf_filtered (file, _("Printing of C++ static members is %s.\n"),
72 static struct obstack dont_print_vb_obstack;
73 static struct obstack dont_print_statmem_obstack;
74 static struct obstack dont_print_stat_array_obstack;
76 extern void _initialize_cp_valprint (void);
78 static void cp_print_static_field (struct type *, struct value *,
79 struct ui_file *, int,
80 const struct value_print_options *);
82 static void cp_print_value (struct type *, struct type *, const gdb_byte *,
83 int, CORE_ADDR, struct ui_file *, int,
85 const struct value_print_options *, struct type **);
88 /* GCC versions after 2.4.5 use this. */
89 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
91 /* Return truth value for assertion that TYPE is of the type
92 "pointer to virtual function". */
95 cp_is_vtbl_ptr_type (struct type *type)
97 char *typename = type_name_no_tag (type);
99 return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
102 /* Return truth value for the assertion that TYPE is of the type
103 "pointer to virtual function table". */
106 cp_is_vtbl_member (struct type *type)
108 /* With older versions of g++, the vtbl field pointed to an array
109 of structures. Nowadays it points directly to the structure. */
110 if (TYPE_CODE (type) == TYPE_CODE_PTR)
112 type = TYPE_TARGET_TYPE (type);
113 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
115 type = TYPE_TARGET_TYPE (type);
116 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
117 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
119 /* Virtual functions tables are full of pointers
120 to virtual functions. */
121 return cp_is_vtbl_ptr_type (type);
124 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
126 return cp_is_vtbl_ptr_type (type);
128 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
130 /* The type name of the thunk pointer is NULL when using dwarf2.
131 We could test for a pointer to a function, but there is
132 no type info for the virtual table either, so it wont help. */
133 return cp_is_vtbl_ptr_type (type);
139 /* Mutually recursive subroutines of cp_print_value and c_val_print to
140 print out a structure's fields: cp_print_value_fields and cp_print_value.
142 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
143 same meanings as in cp_print_value and c_val_print.
145 2nd argument REAL_TYPE is used to carry over the type of the derived
146 class across the recursion to base classes.
148 DONT_PRINT is an array of baseclass types that we
149 should not print, or zero if called from top level. */
152 cp_print_value_fields (struct type *type, struct type *real_type,
153 const gdb_byte *valaddr, int offset, CORE_ADDR address,
154 struct ui_file *stream, int recurse,
155 const struct value *val,
156 const struct value_print_options *options,
157 struct type **dont_print_vb, int dont_print_statmem)
159 int i, len, n_baseclasses;
161 static int last_set_recurse = -1;
163 CHECK_TYPEDEF (type);
167 if (obstack_object_size (&dont_print_statmem_obstack) > 0)
168 obstack_free (&dont_print_statmem_obstack, NULL);
169 if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
170 obstack_free (&dont_print_stat_array_obstack, NULL);
173 fprintf_filtered (stream, "{");
174 len = TYPE_NFIELDS (type);
175 n_baseclasses = TYPE_N_BASECLASSES (type);
177 /* First, print out baseclasses such that we don't print
178 duplicates of virtual baseclasses. */
180 if (n_baseclasses > 0)
181 cp_print_value (type, real_type, valaddr, offset, address, stream,
182 recurse + 1, val, options, dont_print_vb);
184 /* Second, print out data fields */
186 /* If there are no data fields, skip this part */
187 if (len == n_baseclasses || !len)
188 fprintf_filtered (stream, "<No data fields>");
191 int statmem_obstack_initial_size = 0;
192 int stat_array_obstack_initial_size = 0;
194 if (dont_print_statmem == 0)
196 statmem_obstack_initial_size =
197 obstack_object_size (&dont_print_statmem_obstack);
199 if (last_set_recurse != recurse)
201 stat_array_obstack_initial_size =
202 obstack_object_size (&dont_print_stat_array_obstack);
204 last_set_recurse = recurse;
208 for (i = n_baseclasses; i < len; i++)
210 /* If requested, skip printing of static fields. */
211 if (!options->static_field_print
212 && field_is_static (&TYPE_FIELD (type, i)))
216 fprintf_filtered (stream, ", ");
217 else if (n_baseclasses > 0)
221 fprintf_filtered (stream, "\n");
222 print_spaces_filtered (2 + 2 * recurse, stream);
223 fputs_filtered ("members of ", stream);
224 fputs_filtered (type_name_no_tag (type), stream);
225 fputs_filtered (": ", stream);
232 fprintf_filtered (stream, "\n");
233 print_spaces_filtered (2 + 2 * recurse, stream);
237 wrap_here (n_spaces (2 + 2 * recurse));
239 if (options->inspect_it)
241 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
242 fputs_filtered ("\"( ptr \"", stream);
244 fputs_filtered ("\"( nodef \"", stream);
245 if (field_is_static (&TYPE_FIELD (type, i)))
246 fputs_filtered ("static ", stream);
247 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
248 current_language->la_language,
249 DMGL_PARAMS | DMGL_ANSI);
250 fputs_filtered ("\" \"", stream);
251 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
252 current_language->la_language,
253 DMGL_PARAMS | DMGL_ANSI);
254 fputs_filtered ("\") \"", stream);
258 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
260 if (field_is_static (&TYPE_FIELD (type, i)))
261 fputs_filtered ("static ", stream);
262 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
263 current_language->la_language,
264 DMGL_PARAMS | DMGL_ANSI);
265 annotate_field_name_end ();
266 /* do not print leading '=' in case of anonymous unions */
267 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
268 fputs_filtered (" = ", stream);
269 annotate_field_value ();
272 if (!field_is_static (&TYPE_FIELD (type, i))
273 && TYPE_FIELD_PACKED (type, i))
277 /* Bitfields require special handling, especially due to byte
279 if (TYPE_FIELD_IGNORE (type, i))
281 fputs_filtered ("<optimized out or zero length>", stream);
283 else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
284 TYPE_FIELD_BITSIZE (type, i)))
286 fputs_filtered (_("<value optimized out>"), stream);
290 struct value_print_options opts = *options;
293 v = value_from_longest
294 (TYPE_FIELD_TYPE (type, i),
295 unpack_field_as_long (type, valaddr + offset, i));
297 common_val_print (v, stream, recurse + 1, &opts,
303 if (TYPE_FIELD_IGNORE (type, i))
305 fputs_filtered ("<optimized out or zero length>", stream);
307 else if (field_is_static (&TYPE_FIELD (type, i)))
309 struct value *v = value_static_field (type, i);
312 fputs_filtered ("<optimized out>", stream);
314 cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
315 stream, recurse + 1, options);
319 struct value_print_options opts = *options;
322 val_print (TYPE_FIELD_TYPE (type, i),
323 valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
325 stream, recurse + 1, val, &opts,
329 annotate_field_end ();
332 if (dont_print_statmem == 0)
334 int obstack_final_size =
335 obstack_object_size (&dont_print_statmem_obstack);
337 if (obstack_final_size > statmem_obstack_initial_size) {
338 /* In effect, a pop of the printed-statics stack. */
341 obstack_next_free (&dont_print_statmem_obstack) -
342 (obstack_final_size - statmem_obstack_initial_size);
344 obstack_free (&dont_print_statmem_obstack,
348 if (last_set_recurse != recurse)
350 int obstack_final_size =
351 obstack_object_size (&dont_print_stat_array_obstack);
353 if (obstack_final_size > stat_array_obstack_initial_size)
356 obstack_next_free (&dont_print_stat_array_obstack) -
357 (obstack_final_size - stat_array_obstack_initial_size);
359 obstack_free (&dont_print_stat_array_obstack,
362 last_set_recurse = -1;
368 fprintf_filtered (stream, "\n");
369 print_spaces_filtered (2 * recurse, stream);
371 } /* if there are data fields */
373 fprintf_filtered (stream, "}");
376 /* Like cp_print_value_fields, but find the runtime type of the object
377 and pass it as the `real_type' argument to cp_print_value_fields.
378 This function is a hack to work around the fact that
379 common_val_print passes the embedded offset to val_print, but not
380 the enclosing type. */
383 cp_print_value_fields_rtti (struct type *type,
384 const gdb_byte *valaddr, int offset,
386 struct ui_file *stream, int recurse,
387 const struct value *val,
388 const struct value_print_options *options,
389 struct type **dont_print_vb,
390 int dont_print_statmem)
392 struct type *real_type = NULL;
394 /* We require all bits to be valid in order to attempt a
396 if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
397 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
400 int full, top, using_enc;
402 /* Ugh, we have to convert back to a value here. */
403 value = value_from_contents_and_address (type, valaddr + offset,
405 /* We don't actually care about most of the result here -- just the
406 type. We already have the correct offset, due to how val_print
407 was initially called. */
408 real_type = value_rtti_type (value, &full, &top, &using_enc);
414 cp_print_value_fields (type, real_type, valaddr, offset,
415 address, stream, recurse, val, options,
416 dont_print_vb, dont_print_statmem);
419 /* Special val_print routine to avoid printing multiple copies of virtual
423 cp_print_value (struct type *type, struct type *real_type,
424 const gdb_byte *valaddr, int offset, CORE_ADDR address,
425 struct ui_file *stream, int recurse,
426 const struct value *val,
427 const struct value_print_options *options,
428 struct type **dont_print_vb)
430 struct type **last_dont_print
431 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
432 struct obstack tmp_obstack = dont_print_vb_obstack;
433 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
435 struct type *thistype;
437 if (dont_print_vb == 0)
439 /* If we're at top level, carve out a completely fresh
440 chunk of the obstack and use that until this particular
441 invocation returns. */
442 /* Bump up the high-water mark. Now alpha is omega. */
443 obstack_finish (&dont_print_vb_obstack);
446 for (i = 0; i < n_baseclasses; i++)
450 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
451 char *basename = TYPE_NAME (baseclass);
452 const gdb_byte *base_valaddr;
454 if (BASETYPE_VIA_VIRTUAL (type, i))
456 struct type **first_dont_print
457 = (struct type **) obstack_base (&dont_print_vb_obstack);
459 int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
463 if (baseclass == first_dont_print[j])
466 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
470 thistype = real_type;
472 boffset = baseclass_offset (type, i, valaddr + offset, address + offset);
473 skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
475 if (BASETYPE_VIA_VIRTUAL (type, i))
477 /* The virtual base class pointer might have been
478 clobbered by the user program. Make sure that it
479 still points to a valid memory location. */
482 && ((boffset + offset) < 0
483 || (boffset + offset) >= TYPE_LENGTH (real_type)))
485 /* FIXME (alloca): unsafe if baseclass is really really large. */
486 gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
489 if (target_read_memory (address + boffset, buf,
490 TYPE_LENGTH (baseclass)) != 0)
492 address = address + boffset;
495 thistype = baseclass;
498 base_valaddr = valaddr;
501 base_valaddr = valaddr;
503 /* now do the printing */
506 fprintf_filtered (stream, "\n");
507 print_spaces_filtered (2 * recurse, stream);
509 fputs_filtered ("<", stream);
510 /* Not sure what the best notation is in the case where there is no
512 fputs_filtered (basename ? basename : "", stream);
513 fputs_filtered ("> = ", stream);
517 fprintf_filtered (stream, "<invalid address>");
522 /* Attempt to run the Python pretty-printers on the
523 baseclass if possible. */
525 result = apply_val_pretty_printer (baseclass, base_valaddr,
526 thisoffset + boffset,
528 stream, recurse, val,
533 cp_print_value_fields (baseclass, thistype, base_valaddr,
534 thisoffset + boffset, address,
535 stream, recurse, val, options,
537 obstack_base (&dont_print_vb_obstack)),
540 fputs_filtered (", ", stream);
546 if (dont_print_vb == 0)
548 /* Free the space used to deal with the printing
549 of this type from top level. */
550 obstack_free (&dont_print_vb_obstack, last_dont_print);
551 /* Reset watermark so that we can continue protecting
552 ourselves from whatever we were protecting ourselves. */
553 dont_print_vb_obstack = tmp_obstack;
557 /* Print value of a static member.
558 To avoid infinite recursion when printing a class that contains
559 a static instance of the class, we keep the addresses of all printed
560 static member classes in an obstack and refuse to print them more
563 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
564 have the same meanings as in c_val_print. */
567 cp_print_static_field (struct type *type,
569 struct ui_file *stream,
571 const struct value_print_options *options)
573 struct value_print_options opts;
575 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
577 CORE_ADDR *first_dont_print;
582 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
583 i = obstack_object_size (&dont_print_statmem_obstack)
584 / sizeof (CORE_ADDR);
588 if (value_address (val) == first_dont_print[i])
590 fputs_filtered ("<same as static member of an already"
597 addr = value_address (val);
598 obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
600 CHECK_TYPEDEF (type);
601 cp_print_value_fields (type, value_enclosing_type (val),
602 value_contents_for_printing (val),
603 value_embedded_offset (val), addr,
605 val, options, NULL, 1);
609 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
611 struct type **first_dont_print;
613 struct type *target_type = TYPE_TARGET_TYPE (type);
616 = (struct type **) obstack_base (&dont_print_stat_array_obstack);
617 i = obstack_object_size (&dont_print_stat_array_obstack)
618 / sizeof (CORE_ADDR);
622 if (target_type == first_dont_print[i])
624 fputs_filtered ("<same as static member of an already"
631 obstack_grow (&dont_print_stat_array_obstack, (char *) &target_type,
632 sizeof (struct type *));
637 val_print (type, value_contents_for_printing (val),
638 value_embedded_offset (val), value_address (val),
640 val, &opts, current_language);
644 /* Find the field in *DOMAIN, or its non-virtual base classes, with bit offset
645 OFFSET. Set *DOMAIN to the containing type and *FIELDNO to the containing
646 field number. If OFFSET is not exactly at the start of some field, set
650 cp_find_class_member (struct type **domain_p, int *fieldno,
657 *domain_p = check_typedef (*domain_p);
659 len = TYPE_NFIELDS (domain);
661 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
663 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
666 if (offset == bitpos)
673 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
675 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
676 LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
678 if (offset >= bitpos && offset < bitpos + bitsize)
680 *domain_p = TYPE_FIELD_TYPE (domain, i);
681 cp_find_class_member (domain_p, fieldno, offset - bitpos);
690 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
691 struct ui_file *stream, char *prefix)
693 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
695 /* VAL is a byte offset into the structure type DOMAIN.
696 Find the name of the field for that offset and
698 struct type *domain = TYPE_DOMAIN_TYPE (type);
700 unsigned int fieldno;
702 val = extract_signed_integer (valaddr, TYPE_LENGTH (type), byte_order);
704 /* Pointers to data members are usually byte offsets into an object.
705 Because a data member can have offset zero, and a NULL pointer to
706 member must be distinct from any valid non-NULL pointer to
707 member, either the value is biased or the NULL value has a
708 special representation; both are permitted by ISO C++. HP aCC
709 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
710 and other compilers which use the Itanium ABI use -1 as the NULL
711 value. GDB only supports that last form; to add support for
712 another form, make this into a cp-abi hook. */
716 fprintf_filtered (stream, "NULL");
720 cp_find_class_member (&domain, &fieldno, val << 3);
726 fputs_filtered (prefix, stream);
727 name = type_name_no_tag (domain);
729 fputs_filtered (name, stream);
731 c_type_print_base (domain, stream, 0, 0);
732 fprintf_filtered (stream, "::");
733 fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
736 fprintf_filtered (stream, "%ld", (long) val);
741 _initialize_cp_valprint (void)
743 add_setshow_boolean_cmd ("static-members", class_support,
744 &user_print_options.static_field_print, _("\
745 Set printing of C++ static members."), _("\
746 Show printing of C++ static members."), NULL,
748 show_static_field_print,
749 &setprintlist, &showprintlist);
751 add_setshow_boolean_cmd ("vtbl", class_support,
752 &user_print_options.vtblprint, _("\
753 Set printing of C++ virtual function tables."), _("\
754 Show printing of C++ virtual function tables."), NULL,
757 &setprintlist, &showprintlist);
759 add_setshow_boolean_cmd ("object", class_support,
760 &user_print_options.objectprint, _("\
761 Set printing of object's derived type based on vtable info."), _("\
762 Show printing of object's derived type based on vtable info."), NULL,
765 &setprintlist, &showprintlist);
767 obstack_begin (&dont_print_stat_array_obstack, 32 * sizeof (CORE_ADDR));
768 obstack_begin (&dont_print_statmem_obstack, 32 * sizeof (CORE_ADDR));
769 obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));