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, 2011
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"
40 #include "exceptions.h"
42 /* Controls printing of vtbl's. */
44 show_vtblprint (struct ui_file
*file
, int from_tty
,
45 struct cmd_list_element
*c
, const char *value
)
47 fprintf_filtered (file
, _("\
48 Printing of C++ virtual function tables is %s.\n"),
52 /* Controls looking up an object's derived type using what we find in
55 show_objectprint (struct ui_file
*file
, int from_tty
,
56 struct cmd_list_element
*c
,
59 fprintf_filtered (file
, _("\
60 Printing of object's derived type based on vtable info is %s.\n"),
65 show_static_field_print (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
,
69 fprintf_filtered (file
,
70 _("Printing of C++ static members is %s.\n"),
75 static struct obstack dont_print_vb_obstack
;
76 static struct obstack dont_print_statmem_obstack
;
77 static struct obstack dont_print_stat_array_obstack
;
79 extern void _initialize_cp_valprint (void);
81 static void cp_print_static_field (struct type
*, struct value
*,
82 struct ui_file
*, int,
83 const struct value_print_options
*);
85 static void cp_print_value (struct type
*, struct type
*,
86 const gdb_byte
*, int,
87 CORE_ADDR
, struct ui_file
*,
88 int, const struct value
*,
89 const struct value_print_options
*,
93 /* GCC versions after 2.4.5 use this. */
94 const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
96 /* Return truth value for assertion that TYPE is of the type
97 "pointer to virtual function". */
100 cp_is_vtbl_ptr_type (struct type
*type
)
102 char *typename
= type_name_no_tag (type
);
104 return (typename
!= NULL
&& !strcmp (typename
, vtbl_ptr_name
));
107 /* Return truth value for the assertion that TYPE is of the type
108 "pointer to virtual function table". */
111 cp_is_vtbl_member (struct type
*type
)
113 /* With older versions of g++, the vtbl field pointed to an array of
114 structures. Nowadays it points directly to the structure. */
115 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
117 type
= TYPE_TARGET_TYPE (type
);
118 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
120 type
= TYPE_TARGET_TYPE (type
);
121 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
122 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
124 /* Virtual functions tables are full of pointers
125 to virtual functions. */
126 return cp_is_vtbl_ptr_type (type
);
129 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
131 return cp_is_vtbl_ptr_type (type
);
133 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
135 /* The type name of the thunk pointer is NULL when using
136 dwarf2. We could test for a pointer to a function, but
137 there is no type info for the virtual table either, so it
139 return cp_is_vtbl_ptr_type (type
);
145 /* Mutually recursive subroutines of cp_print_value and c_val_print to
146 print out a structure's fields: cp_print_value_fields and
149 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
150 meanings as in cp_print_value and c_val_print.
152 2nd argument REAL_TYPE is used to carry over the type of the
153 derived class across the recursion to base classes.
155 DONT_PRINT is an array of baseclass types that we should not print,
156 or zero if called from top level. */
159 cp_print_value_fields (struct type
*type
, struct type
*real_type
,
160 const gdb_byte
*valaddr
, int offset
,
161 CORE_ADDR address
, struct ui_file
*stream
,
162 int recurse
, const struct value
*val
,
163 const struct value_print_options
*options
,
164 struct type
**dont_print_vb
,
165 int dont_print_statmem
)
167 int i
, len
, n_baseclasses
;
169 static int last_set_recurse
= -1;
171 CHECK_TYPEDEF (type
);
175 /* Any object can be left on obstacks only during an unexpected
178 if (obstack_object_size (&dont_print_statmem_obstack
) > 0)
180 obstack_free (&dont_print_statmem_obstack
, NULL
);
181 obstack_begin (&dont_print_statmem_obstack
,
182 32 * sizeof (CORE_ADDR
));
184 if (obstack_object_size (&dont_print_stat_array_obstack
) > 0)
186 obstack_free (&dont_print_stat_array_obstack
, NULL
);
187 obstack_begin (&dont_print_stat_array_obstack
,
188 32 * sizeof (struct type
*));
192 fprintf_filtered (stream
, "{");
193 len
= TYPE_NFIELDS (type
);
194 n_baseclasses
= TYPE_N_BASECLASSES (type
);
196 /* First, print out baseclasses such that we don't print
197 duplicates of virtual baseclasses. */
199 if (n_baseclasses
> 0)
200 cp_print_value (type
, real_type
, valaddr
,
201 offset
, address
, stream
,
202 recurse
+ 1, val
, options
,
205 /* Second, print out data fields */
207 /* If there are no data fields, skip this part */
208 if (len
== n_baseclasses
|| !len
)
209 fprintf_filtered (stream
, "<No data fields>");
212 int statmem_obstack_initial_size
= 0;
213 int stat_array_obstack_initial_size
= 0;
215 if (dont_print_statmem
== 0)
217 statmem_obstack_initial_size
=
218 obstack_object_size (&dont_print_statmem_obstack
);
220 if (last_set_recurse
!= recurse
)
222 stat_array_obstack_initial_size
=
223 obstack_object_size (&dont_print_stat_array_obstack
);
225 last_set_recurse
= recurse
;
229 for (i
= n_baseclasses
; i
< len
; i
++)
231 /* If requested, skip printing of static fields. */
232 if (!options
->static_field_print
233 && field_is_static (&TYPE_FIELD (type
, i
)))
237 fprintf_filtered (stream
, ", ");
238 else if (n_baseclasses
> 0)
242 fprintf_filtered (stream
, "\n");
243 print_spaces_filtered (2 + 2 * recurse
, stream
);
244 fputs_filtered ("members of ", stream
);
245 fputs_filtered (type_name_no_tag (type
), stream
);
246 fputs_filtered (": ", stream
);
253 fprintf_filtered (stream
, "\n");
254 print_spaces_filtered (2 + 2 * recurse
, stream
);
258 wrap_here (n_spaces (2 + 2 * recurse
));
260 if (options
->inspect_it
)
262 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
263 fputs_filtered ("\"( ptr \"", stream
);
265 fputs_filtered ("\"( nodef \"", stream
);
266 if (field_is_static (&TYPE_FIELD (type
, i
)))
267 fputs_filtered ("static ", stream
);
268 fprintf_symbol_filtered (stream
,
269 TYPE_FIELD_NAME (type
, i
),
270 current_language
->la_language
,
271 DMGL_PARAMS
| DMGL_ANSI
);
272 fputs_filtered ("\" \"", stream
);
273 fprintf_symbol_filtered (stream
,
274 TYPE_FIELD_NAME (type
, i
),
275 current_language
->la_language
,
276 DMGL_PARAMS
| DMGL_ANSI
);
277 fputs_filtered ("\") \"", stream
);
281 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
283 if (field_is_static (&TYPE_FIELD (type
, i
)))
284 fputs_filtered ("static ", stream
);
285 fprintf_symbol_filtered (stream
,
286 TYPE_FIELD_NAME (type
, i
),
287 current_language
->la_language
,
288 DMGL_PARAMS
| DMGL_ANSI
);
289 annotate_field_name_end ();
290 /* Do not print leading '=' in case of anonymous
292 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
293 fputs_filtered (" = ", stream
);
294 annotate_field_value ();
297 if (!field_is_static (&TYPE_FIELD (type
, i
))
298 && TYPE_FIELD_PACKED (type
, i
))
302 /* Bitfields require special handling, especially due to
303 byte order problems. */
304 if (TYPE_FIELD_IGNORE (type
, i
))
306 fputs_filtered ("<optimized out or zero length>", stream
);
308 else if (value_bits_synthetic_pointer (val
,
309 TYPE_FIELD_BITPOS (type
,
311 TYPE_FIELD_BITSIZE (type
,
314 fputs_filtered (_("<synthetic pointer>"), stream
);
316 else if (!value_bits_valid (val
,
317 TYPE_FIELD_BITPOS (type
, i
),
318 TYPE_FIELD_BITSIZE (type
, i
)))
320 val_print_optimized_out (stream
);
324 struct value_print_options opts
= *options
;
328 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
330 common_val_print (v
, stream
, recurse
+ 1, &opts
,
336 if (TYPE_FIELD_IGNORE (type
, i
))
338 fputs_filtered ("<optimized out or zero length>",
341 else if (field_is_static (&TYPE_FIELD (type
, i
)))
343 struct value
*v
= value_static_field (type
, i
);
346 val_print_optimized_out (stream
);
348 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
),
349 v
, stream
, recurse
+ 1,
354 struct value_print_options opts
= *options
;
357 val_print (TYPE_FIELD_TYPE (type
, i
),
359 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
361 stream
, recurse
+ 1, val
, &opts
,
365 annotate_field_end ();
368 if (dont_print_statmem
== 0)
370 int obstack_final_size
=
371 obstack_object_size (&dont_print_statmem_obstack
);
373 if (obstack_final_size
> statmem_obstack_initial_size
)
375 /* In effect, a pop of the printed-statics stack. */
378 obstack_next_free (&dont_print_statmem_obstack
) -
379 (obstack_final_size
- statmem_obstack_initial_size
);
381 obstack_free (&dont_print_statmem_obstack
,
385 if (last_set_recurse
!= recurse
)
387 int obstack_final_size
=
388 obstack_object_size (&dont_print_stat_array_obstack
);
390 if (obstack_final_size
> stat_array_obstack_initial_size
)
393 obstack_next_free (&dont_print_stat_array_obstack
)
394 - (obstack_final_size
395 - stat_array_obstack_initial_size
);
397 obstack_free (&dont_print_stat_array_obstack
,
400 last_set_recurse
= -1;
406 fprintf_filtered (stream
, "\n");
407 print_spaces_filtered (2 * recurse
, stream
);
409 } /* if there are data fields */
411 fprintf_filtered (stream
, "}");
414 /* Like cp_print_value_fields, but find the runtime type of the object
415 and pass it as the `real_type' argument to cp_print_value_fields.
416 This function is a hack to work around the fact that
417 common_val_print passes the embedded offset to val_print, but not
418 the enclosing type. */
421 cp_print_value_fields_rtti (struct type
*type
,
422 const gdb_byte
*valaddr
, int offset
,
424 struct ui_file
*stream
, int recurse
,
425 const struct value
*val
,
426 const struct value_print_options
*options
,
427 struct type
**dont_print_vb
,
428 int dont_print_statmem
)
430 struct type
*real_type
= NULL
;
432 /* We require all bits to be valid in order to attempt a
434 if (value_bits_valid (val
, TARGET_CHAR_BIT
* offset
,
435 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
438 int full
, top
, using_enc
;
440 /* Ugh, we have to convert back to a value here. */
441 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
443 /* We don't actually care about most of the result here -- just
444 the type. We already have the correct offset, due to how
445 val_print was initially called. */
446 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
452 cp_print_value_fields (type
, real_type
, valaddr
, offset
,
453 address
, stream
, recurse
, val
, options
,
454 dont_print_vb
, dont_print_statmem
);
457 /* Special val_print routine to avoid printing multiple copies of
458 virtual baseclasses. */
461 cp_print_value (struct type
*type
, struct type
*real_type
,
462 const gdb_byte
*valaddr
, int offset
,
463 CORE_ADDR address
, struct ui_file
*stream
,
464 int recurse
, const struct value
*val
,
465 const struct value_print_options
*options
,
466 struct type
**dont_print_vb
)
468 struct type
**last_dont_print
469 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
470 struct obstack tmp_obstack
= dont_print_vb_obstack
;
471 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
473 struct type
*thistype
;
475 if (dont_print_vb
== 0)
477 /* If we're at top level, carve out a completely fresh chunk of
478 the obstack and use that until this particular invocation
480 /* Bump up the high-water mark. Now alpha is omega. */
481 obstack_finish (&dont_print_vb_obstack
);
484 for (i
= 0; i
< n_baseclasses
; i
++)
488 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
489 char *basename
= TYPE_NAME (baseclass
);
490 const gdb_byte
*base_valaddr
= NULL
;
491 const struct value
*base_val
= NULL
;
492 volatile struct gdb_exception ex
;
494 if (BASETYPE_VIA_VIRTUAL (type
, i
))
496 struct type
**first_dont_print
497 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
499 int j
= (struct type
**)
500 obstack_next_free (&dont_print_vb_obstack
) - first_dont_print
;
503 if (baseclass
== first_dont_print
[j
])
506 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
510 thistype
= real_type
;
512 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
514 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
516 if (ex
.reason
< 0 && ex
.error
== NOT_AVAILABLE_ERROR
)
518 else if (ex
.reason
< 0)
524 if (BASETYPE_VIA_VIRTUAL (type
, i
))
526 /* The virtual base class pointer might have been
527 clobbered by the user program. Make sure that it
528 still points to a valid memory location. */
530 if ((boffset
+ offset
) < 0
531 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
))
533 /* FIXME (alloca): unsafe if baseclass is really
535 gdb_byte
*buf
= alloca (TYPE_LENGTH (baseclass
));
537 if (target_read_memory (address
+ boffset
, buf
,
538 TYPE_LENGTH (baseclass
)) != 0)
540 base_val
= value_from_contents_and_address (baseclass
,
545 thistype
= baseclass
;
546 base_valaddr
= value_contents_for_printing_const (base_val
);
550 base_valaddr
= valaddr
;
556 base_valaddr
= valaddr
;
561 /* Now do the printing. */
564 fprintf_filtered (stream
, "\n");
565 print_spaces_filtered (2 * recurse
, stream
);
567 fputs_filtered ("<", stream
);
568 /* Not sure what the best notation is in the case where there is
569 no baseclass name. */
570 fputs_filtered (basename
? basename
: "", stream
);
571 fputs_filtered ("> = ", stream
);
574 val_print_unavailable (stream
);
576 val_print_invalid_address (stream
);
581 /* Attempt to run the Python pretty-printers on the
582 baseclass if possible. */
584 result
= apply_val_pretty_printer (baseclass
, base_valaddr
,
585 thisoffset
+ boffset
,
586 value_address (base_val
),
587 stream
, recurse
, base_val
,
588 options
, current_language
);
593 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
594 thisoffset
+ boffset
,
595 value_address (base_val
),
596 stream
, recurse
, base_val
, options
,
598 obstack_base (&dont_print_vb_obstack
)),
601 fputs_filtered (", ", stream
);
607 if (dont_print_vb
== 0)
609 /* Free the space used to deal with the printing
610 of this type from top level. */
611 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
612 /* Reset watermark so that we can continue protecting
613 ourselves from whatever we were protecting ourselves. */
614 dont_print_vb_obstack
= tmp_obstack
;
618 /* Print value of a static member. To avoid infinite recursion when
619 printing a class that contains a static instance of the class, we
620 keep the addresses of all printed static member classes in an
621 obstack and refuse to print them more than once.
623 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
624 have the same meanings as in c_val_print. */
627 cp_print_static_field (struct type
*type
,
629 struct ui_file
*stream
,
631 const struct value_print_options
*options
)
633 struct value_print_options opts
;
635 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
637 CORE_ADDR
*first_dont_print
;
642 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
643 i
= obstack_object_size (&dont_print_statmem_obstack
)
644 / sizeof (CORE_ADDR
);
648 if (value_address (val
) == first_dont_print
[i
])
650 fputs_filtered ("<same as static member of an already"
657 addr
= value_address (val
);
658 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
660 CHECK_TYPEDEF (type
);
661 cp_print_value_fields (type
, value_enclosing_type (val
),
662 value_contents_for_printing (val
),
663 value_embedded_offset (val
), addr
,
664 stream
, recurse
, val
,
669 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
671 struct type
**first_dont_print
;
673 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
676 = (struct type
**) obstack_base (&dont_print_stat_array_obstack
);
677 i
= obstack_object_size (&dont_print_stat_array_obstack
)
678 / sizeof (struct type
*);
682 if (target_type
== first_dont_print
[i
])
684 fputs_filtered ("<same as static member of an already"
691 obstack_grow (&dont_print_stat_array_obstack
,
692 (char *) &target_type
,
693 sizeof (struct type
*));
698 val_print (type
, value_contents_for_printing (val
),
699 value_embedded_offset (val
),
701 stream
, recurse
, val
,
702 &opts
, current_language
);
706 /* Find the field in *DOMAIN, or its non-virtual base classes, with
707 bit offset OFFSET. Set *DOMAIN to the containing type and *FIELDNO
708 to the containing field number. If OFFSET is not exactly at the
709 start of some field, set *DOMAIN to NULL. */
712 cp_find_class_member (struct type
**domain_p
, int *fieldno
,
719 *domain_p
= check_typedef (*domain_p
);
721 len
= TYPE_NFIELDS (domain
);
723 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
725 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
728 if (offset
== bitpos
)
735 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
737 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
738 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain
, i
));
740 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
742 *domain_p
= TYPE_FIELD_TYPE (domain
, i
);
743 cp_find_class_member (domain_p
, fieldno
, offset
- bitpos
);
752 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
753 struct ui_file
*stream
, char *prefix
)
755 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
757 /* VAL is a byte offset into the structure type DOMAIN.
758 Find the name of the field for that offset and
760 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
762 unsigned int fieldno
;
764 val
= extract_signed_integer (valaddr
,
768 /* Pointers to data members are usually byte offsets into an object.
769 Because a data member can have offset zero, and a NULL pointer to
770 member must be distinct from any valid non-NULL pointer to
771 member, either the value is biased or the NULL value has a
772 special representation; both are permitted by ISO C++. HP aCC
773 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
774 and other compilers which use the Itanium ABI use -1 as the NULL
775 value. GDB only supports that last form; to add support for
776 another form, make this into a cp-abi hook. */
780 fprintf_filtered (stream
, "NULL");
784 cp_find_class_member (&domain
, &fieldno
, val
<< 3);
790 fputs_filtered (prefix
, stream
);
791 name
= type_name_no_tag (domain
);
793 fputs_filtered (name
, stream
);
795 c_type_print_base (domain
, stream
, 0, 0);
796 fprintf_filtered (stream
, "::");
797 fputs_filtered (TYPE_FIELD_NAME (domain
, fieldno
), stream
);
800 fprintf_filtered (stream
, "%ld", (long) val
);
805 _initialize_cp_valprint (void)
807 add_setshow_boolean_cmd ("static-members", class_support
,
808 &user_print_options
.static_field_print
, _("\
809 Set printing of C++ static members."), _("\
810 Show printing of C++ static members."), NULL
,
812 show_static_field_print
,
813 &setprintlist
, &showprintlist
);
815 add_setshow_boolean_cmd ("vtbl", class_support
,
816 &user_print_options
.vtblprint
, _("\
817 Set printing of C++ virtual function tables."), _("\
818 Show printing of C++ virtual function tables."), NULL
,
821 &setprintlist
, &showprintlist
);
823 add_setshow_boolean_cmd ("object", class_support
,
824 &user_print_options
.objectprint
, _("\
825 Set printing of object's derived type based on vtable info."), _("\
826 Show printing of object's derived type based on vtable info."), NULL
,
829 &setprintlist
, &showprintlist
);
831 obstack_begin (&dont_print_stat_array_obstack
,
832 32 * sizeof (struct type
*));
833 obstack_begin (&dont_print_statmem_obstack
,
834 32 * sizeof (CORE_ADDR
));
835 obstack_begin (&dont_print_vb_obstack
,
836 32 * sizeof (struct type
*));