1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-1989, 1991-1997, 2000-2003, 2005-2012 Free
4 Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_obstack.h"
25 #include "expression.h"
31 #include "gdb_string.h"
36 #include "cp-support.h"
38 #include "python/python.h"
39 #include "exceptions.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,
68 fprintf_filtered (file,
69 _("Printing of C++ static members is %s.\n"),
74 static struct obstack dont_print_vb_obstack;
75 static struct obstack dont_print_statmem_obstack;
76 static struct obstack dont_print_stat_array_obstack;
78 extern void _initialize_cp_valprint (void);
80 static void cp_print_static_field (struct type *, struct value *,
81 struct ui_file *, int,
82 const struct value_print_options *);
84 static void cp_print_value (struct type *, struct type *,
85 const gdb_byte *, int,
86 CORE_ADDR, struct ui_file *,
87 int, const struct value *,
88 const struct value_print_options *,
92 /* GCC versions after 2.4.5 use this. */
93 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
95 /* Return truth value for assertion that TYPE is of the type
96 "pointer to virtual function". */
99 cp_is_vtbl_ptr_type (struct type *type)
101 const char *typename = type_name_no_tag (type);
103 return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
106 /* Return truth value for the assertion that TYPE is of the type
107 "pointer to virtual function table". */
110 cp_is_vtbl_member (struct type *type)
112 /* With older versions of g++, the vtbl field pointed to an array of
113 structures. Nowadays it points directly to the structure. */
114 if (TYPE_CODE (type) == TYPE_CODE_PTR)
116 type = TYPE_TARGET_TYPE (type);
117 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
119 type = TYPE_TARGET_TYPE (type);
120 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
121 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
123 /* Virtual functions tables are full of pointers
124 to virtual functions. */
125 return cp_is_vtbl_ptr_type (type);
128 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
130 return cp_is_vtbl_ptr_type (type);
132 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
134 /* The type name of the thunk pointer is NULL when using
135 dwarf2. We could test for a pointer to a function, but
136 there is no type info for the virtual table either, so it
138 return cp_is_vtbl_ptr_type (type);
144 /* Mutually recursive subroutines of cp_print_value and c_val_print to
145 print out a structure's fields: cp_print_value_fields and
148 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
149 meanings as in cp_print_value and c_val_print.
151 2nd argument REAL_TYPE is used to carry over the type of the
152 derived class across the recursion to base classes.
154 DONT_PRINT is an array of baseclass types that we should not print,
155 or zero if called from top level. */
158 cp_print_value_fields (struct type *type, struct type *real_type,
159 const gdb_byte *valaddr, int offset,
160 CORE_ADDR address, struct ui_file *stream,
161 int recurse, const struct value *val,
162 const struct value_print_options *options,
163 struct type **dont_print_vb,
164 int dont_print_statmem)
166 int i, len, n_baseclasses;
168 static int last_set_recurse = -1;
170 CHECK_TYPEDEF (type);
174 /* Any object can be left on obstacks only during an unexpected
177 if (obstack_object_size (&dont_print_statmem_obstack) > 0)
179 obstack_free (&dont_print_statmem_obstack, NULL);
180 obstack_begin (&dont_print_statmem_obstack,
181 32 * sizeof (CORE_ADDR));
183 if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
185 obstack_free (&dont_print_stat_array_obstack, NULL);
186 obstack_begin (&dont_print_stat_array_obstack,
187 32 * sizeof (struct type *));
191 fprintf_filtered (stream, "{");
192 len = TYPE_NFIELDS (type);
193 n_baseclasses = TYPE_N_BASECLASSES (type);
195 /* First, print out baseclasses such that we don't print
196 duplicates of virtual baseclasses. */
198 if (n_baseclasses > 0)
199 cp_print_value (type, real_type, valaddr,
200 offset, address, stream,
201 recurse + 1, val, options,
204 /* Second, print out data fields */
206 /* If there are no data fields, skip this part */
207 if (len == n_baseclasses || !len)
208 fprintf_filtered (stream, "<No data fields>");
211 int statmem_obstack_initial_size = 0;
212 int stat_array_obstack_initial_size = 0;
213 struct type *vptr_basetype = NULL;
216 if (dont_print_statmem == 0)
218 statmem_obstack_initial_size =
219 obstack_object_size (&dont_print_statmem_obstack);
221 if (last_set_recurse != recurse)
223 stat_array_obstack_initial_size =
224 obstack_object_size (&dont_print_stat_array_obstack);
226 last_set_recurse = recurse;
230 vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
231 for (i = n_baseclasses; i < len; i++)
233 /* If requested, skip printing of static fields. */
234 if (!options->static_field_print
235 && field_is_static (&TYPE_FIELD (type, i)))
239 fprintf_filtered (stream, ", ");
240 else if (n_baseclasses > 0)
244 fprintf_filtered (stream, "\n");
245 print_spaces_filtered (2 + 2 * recurse, stream);
246 fputs_filtered ("members of ", stream);
247 fputs_filtered (type_name_no_tag (type), stream);
248 fputs_filtered (": ", stream);
255 fprintf_filtered (stream, "\n");
256 print_spaces_filtered (2 + 2 * recurse, stream);
260 wrap_here (n_spaces (2 + 2 * recurse));
262 if (options->inspect_it)
264 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
265 fputs_filtered ("\"( ptr \"", stream);
267 fputs_filtered ("\"( nodef \"", stream);
268 if (field_is_static (&TYPE_FIELD (type, i)))
269 fputs_filtered ("static ", stream);
270 fprintf_symbol_filtered (stream,
271 TYPE_FIELD_NAME (type, i),
272 current_language->la_language,
273 DMGL_PARAMS | DMGL_ANSI);
274 fputs_filtered ("\" \"", stream);
275 fprintf_symbol_filtered (stream,
276 TYPE_FIELD_NAME (type, i),
277 current_language->la_language,
278 DMGL_PARAMS | DMGL_ANSI);
279 fputs_filtered ("\") \"", stream);
283 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
285 if (field_is_static (&TYPE_FIELD (type, i)))
286 fputs_filtered ("static ", stream);
287 fprintf_symbol_filtered (stream,
288 TYPE_FIELD_NAME (type, i),
289 current_language->la_language,
290 DMGL_PARAMS | DMGL_ANSI);
291 annotate_field_name_end ();
292 /* Do not print leading '=' in case of anonymous
294 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
295 fputs_filtered (" = ", stream);
296 annotate_field_value ();
299 if (!field_is_static (&TYPE_FIELD (type, i))
300 && TYPE_FIELD_PACKED (type, i))
304 /* Bitfields require special handling, especially due to
305 byte order problems. */
306 if (TYPE_FIELD_IGNORE (type, i))
308 fputs_filtered ("<optimized out or zero length>", stream);
310 else if (value_bits_synthetic_pointer (val,
311 TYPE_FIELD_BITPOS (type,
313 TYPE_FIELD_BITSIZE (type,
316 fputs_filtered (_("<synthetic pointer>"), stream);
318 else if (!value_bits_valid (val,
319 TYPE_FIELD_BITPOS (type, i),
320 TYPE_FIELD_BITSIZE (type, i)))
322 val_print_optimized_out (stream);
326 struct value_print_options opts = *options;
330 v = value_field_bitfield (type, i, valaddr, offset, val);
332 common_val_print (v, stream, recurse + 1, &opts,
338 if (TYPE_FIELD_IGNORE (type, i))
340 fputs_filtered ("<optimized out or zero length>",
343 else if (field_is_static (&TYPE_FIELD (type, i)))
345 volatile struct gdb_exception ex;
346 struct value *v = NULL;
348 TRY_CATCH (ex, RETURN_MASK_ERROR)
350 v = value_static_field (type, i);
354 fprintf_filtered (stream,
355 _("<error reading variable: %s>"),
358 val_print_optimized_out (stream);
360 cp_print_static_field (TYPE_FIELD_TYPE (type, i),
361 v, stream, recurse + 1,
364 else if (i == vptr_fieldno && type == vptr_basetype)
366 int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
367 struct type *i_type = TYPE_FIELD_TYPE (type, i);
369 if (valprint_check_validity (stream, i_type, i_offset, val))
373 addr = extract_typed_address (valaddr + i_offset, i_type);
374 print_function_pointer_address (options,
375 get_type_arch (type),
381 struct value_print_options opts = *options;
384 val_print (TYPE_FIELD_TYPE (type, i),
386 offset + TYPE_FIELD_BITPOS (type, i) / 8,
388 stream, recurse + 1, val, &opts,
392 annotate_field_end ();
395 if (dont_print_statmem == 0)
397 int obstack_final_size =
398 obstack_object_size (&dont_print_statmem_obstack);
400 if (obstack_final_size > statmem_obstack_initial_size)
402 /* In effect, a pop of the printed-statics stack. */
405 obstack_next_free (&dont_print_statmem_obstack) -
406 (obstack_final_size - statmem_obstack_initial_size);
408 obstack_free (&dont_print_statmem_obstack,
412 if (last_set_recurse != recurse)
414 int obstack_final_size =
415 obstack_object_size (&dont_print_stat_array_obstack);
417 if (obstack_final_size > stat_array_obstack_initial_size)
420 obstack_next_free (&dont_print_stat_array_obstack)
421 - (obstack_final_size
422 - stat_array_obstack_initial_size);
424 obstack_free (&dont_print_stat_array_obstack,
427 last_set_recurse = -1;
433 fprintf_filtered (stream, "\n");
434 print_spaces_filtered (2 * recurse, stream);
436 } /* if there are data fields */
438 fprintf_filtered (stream, "}");
441 /* Like cp_print_value_fields, but find the runtime type of the object
442 and pass it as the `real_type' argument to cp_print_value_fields.
443 This function is a hack to work around the fact that
444 common_val_print passes the embedded offset to val_print, but not
445 the enclosing type. */
448 cp_print_value_fields_rtti (struct type *type,
449 const gdb_byte *valaddr, int offset,
451 struct ui_file *stream, int recurse,
452 const struct value *val,
453 const struct value_print_options *options,
454 struct type **dont_print_vb,
455 int dont_print_statmem)
457 struct type *real_type = NULL;
459 /* We require all bits to be valid in order to attempt a
461 if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
462 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
465 int full, top, using_enc;
467 /* Ugh, we have to convert back to a value here. */
468 value = value_from_contents_and_address (type, valaddr + offset,
470 /* We don't actually care about most of the result here -- just
471 the type. We already have the correct offset, due to how
472 val_print was initially called. */
473 real_type = value_rtti_type (value, &full, &top, &using_enc);
479 cp_print_value_fields (type, real_type, valaddr, offset,
480 address, stream, recurse, val, options,
481 dont_print_vb, dont_print_statmem);
484 /* Special val_print routine to avoid printing multiple copies of
485 virtual baseclasses. */
488 cp_print_value (struct type *type, struct type *real_type,
489 const gdb_byte *valaddr, int offset,
490 CORE_ADDR address, struct ui_file *stream,
491 int recurse, const struct value *val,
492 const struct value_print_options *options,
493 struct type **dont_print_vb)
495 struct type **last_dont_print
496 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
497 struct obstack tmp_obstack = dont_print_vb_obstack;
498 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
500 struct type *thistype;
502 if (dont_print_vb == 0)
504 /* If we're at top level, carve out a completely fresh chunk of
505 the obstack and use that until this particular invocation
507 /* Bump up the high-water mark. Now alpha is omega. */
508 obstack_finish (&dont_print_vb_obstack);
511 for (i = 0; i < n_baseclasses; i++)
515 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
516 const char *basename = TYPE_NAME (baseclass);
517 const gdb_byte *base_valaddr = NULL;
518 const struct value *base_val = NULL;
519 volatile struct gdb_exception ex;
521 if (BASETYPE_VIA_VIRTUAL (type, i))
523 struct type **first_dont_print
524 = (struct type **) obstack_base (&dont_print_vb_obstack);
526 int j = (struct type **)
527 obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
530 if (baseclass == first_dont_print[j])
533 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
537 thistype = real_type;
539 TRY_CATCH (ex, RETURN_MASK_ERROR)
541 boffset = baseclass_offset (type, i, valaddr, offset, address, val);
543 if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
545 else if (ex.reason < 0)
551 if (BASETYPE_VIA_VIRTUAL (type, i))
553 /* The virtual base class pointer might have been
554 clobbered by the user program. Make sure that it
555 still points to a valid memory location. */
557 if ((boffset + offset) < 0
558 || (boffset + offset) >= TYPE_LENGTH (real_type))
561 struct cleanup *back_to;
563 buf = xmalloc (TYPE_LENGTH (baseclass));
564 back_to = make_cleanup (xfree, buf);
566 if (target_read_memory (address + boffset, buf,
567 TYPE_LENGTH (baseclass)) != 0)
569 base_val = value_from_contents_and_address (baseclass,
574 thistype = baseclass;
575 base_valaddr = value_contents_for_printing_const (base_val);
576 do_cleanups (back_to);
580 base_valaddr = valaddr;
586 base_valaddr = valaddr;
591 /* Now do the printing. */
594 fprintf_filtered (stream, "\n");
595 print_spaces_filtered (2 * recurse, stream);
597 fputs_filtered ("<", stream);
598 /* Not sure what the best notation is in the case where there is
599 no baseclass name. */
600 fputs_filtered (basename ? basename : "", stream);
601 fputs_filtered ("> = ", stream);
604 val_print_unavailable (stream);
606 val_print_invalid_address (stream);
611 /* Attempt to run the Python pretty-printers on the
612 baseclass if possible. */
614 result = apply_val_pretty_printer (baseclass, base_valaddr,
615 thisoffset + boffset,
616 value_address (base_val),
617 stream, recurse, base_val,
618 options, current_language);
623 cp_print_value_fields (baseclass, thistype, base_valaddr,
624 thisoffset + boffset,
625 value_address (base_val),
626 stream, recurse, base_val, options,
628 obstack_base (&dont_print_vb_obstack)),
631 fputs_filtered (", ", stream);
637 if (dont_print_vb == 0)
639 /* Free the space used to deal with the printing
640 of this type from top level. */
641 obstack_free (&dont_print_vb_obstack, last_dont_print);
642 /* Reset watermark so that we can continue protecting
643 ourselves from whatever we were protecting ourselves. */
644 dont_print_vb_obstack = tmp_obstack;
648 /* Print value of a static member. To avoid infinite recursion when
649 printing a class that contains a static instance of the class, we
650 keep the addresses of all printed static member classes in an
651 obstack and refuse to print them more than once.
653 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
654 have the same meanings as in c_val_print. */
657 cp_print_static_field (struct type *type,
659 struct ui_file *stream,
661 const struct value_print_options *options)
663 struct value_print_options opts;
665 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
667 CORE_ADDR *first_dont_print;
672 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
673 i = obstack_object_size (&dont_print_statmem_obstack)
674 / sizeof (CORE_ADDR);
678 if (value_address (val) == first_dont_print[i])
680 fputs_filtered ("<same as static member of an already"
687 addr = value_address (val);
688 obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
690 CHECK_TYPEDEF (type);
691 cp_print_value_fields (type, value_enclosing_type (val),
692 value_contents_for_printing (val),
693 value_embedded_offset (val), addr,
694 stream, recurse, val,
699 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
701 struct type **first_dont_print;
703 struct type *target_type = TYPE_TARGET_TYPE (type);
706 = (struct type **) obstack_base (&dont_print_stat_array_obstack);
707 i = obstack_object_size (&dont_print_stat_array_obstack)
708 / sizeof (struct type *);
712 if (target_type == first_dont_print[i])
714 fputs_filtered ("<same as static member of an already"
721 obstack_grow (&dont_print_stat_array_obstack,
722 (char *) &target_type,
723 sizeof (struct type *));
728 val_print (type, value_contents_for_printing (val),
729 value_embedded_offset (val),
731 stream, recurse, val,
732 &opts, current_language);
736 /* Find the field in *DOMAIN, or its non-virtual base classes, with
737 bit offset OFFSET. Set *DOMAIN to the containing type and *FIELDNO
738 to the containing field number. If OFFSET is not exactly at the
739 start of some field, set *DOMAIN to NULL. */
742 cp_find_class_member (struct type **domain_p, int *fieldno,
749 *domain_p = check_typedef (*domain_p);
751 len = TYPE_NFIELDS (domain);
753 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
755 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
758 if (offset == bitpos)
765 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
767 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
768 LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
770 if (offset >= bitpos && offset < bitpos + bitsize)
772 *domain_p = TYPE_FIELD_TYPE (domain, i);
773 cp_find_class_member (domain_p, fieldno, offset - bitpos);
782 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
783 struct ui_file *stream, char *prefix)
785 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
787 /* VAL is a byte offset into the structure type DOMAIN.
788 Find the name of the field for that offset and
790 struct type *domain = TYPE_DOMAIN_TYPE (type);
792 unsigned int fieldno;
794 val = extract_signed_integer (valaddr,
798 /* Pointers to data members are usually byte offsets into an object.
799 Because a data member can have offset zero, and a NULL pointer to
800 member must be distinct from any valid non-NULL pointer to
801 member, either the value is biased or the NULL value has a
802 special representation; both are permitted by ISO C++. HP aCC
803 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
804 and other compilers which use the Itanium ABI use -1 as the NULL
805 value. GDB only supports that last form; to add support for
806 another form, make this into a cp-abi hook. */
810 fprintf_filtered (stream, "NULL");
814 cp_find_class_member (&domain, &fieldno, val << 3);
820 fputs_filtered (prefix, stream);
821 name = type_name_no_tag (domain);
823 fputs_filtered (name, stream);
825 c_type_print_base (domain, stream, 0, 0);
826 fprintf_filtered (stream, "::");
827 fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
830 fprintf_filtered (stream, "%ld", (long) val);
835 _initialize_cp_valprint (void)
837 add_setshow_boolean_cmd ("static-members", class_support,
838 &user_print_options.static_field_print, _("\
839 Set printing of C++ static members."), _("\
840 Show printing of C++ static members."), NULL,
842 show_static_field_print,
843 &setprintlist, &showprintlist);
845 add_setshow_boolean_cmd ("vtbl", class_support,
846 &user_print_options.vtblprint, _("\
847 Set printing of C++ virtual function tables."), _("\
848 Show printing of C++ virtual function tables."), NULL,
851 &setprintlist, &showprintlist);
853 add_setshow_boolean_cmd ("object", class_support,
854 &user_print_options.objectprint, _("\
855 Set printing of object's derived type based on vtable info."), _("\
856 Show printing of object's derived type based on vtable info."), NULL,
859 &setprintlist, &showprintlist);
861 obstack_begin (&dont_print_stat_array_obstack,
862 32 * sizeof (struct type *));
863 obstack_begin (&dont_print_statmem_obstack,
864 32 * sizeof (CORE_ADDR));
865 obstack_begin (&dont_print_vb_obstack,
866 32 * sizeof (struct type *));