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 /* Any object can be left on obstacks only during an unexpected error. */
169 if (obstack_object_size (&dont_print_statmem_obstack
) > 0)
171 obstack_free (&dont_print_statmem_obstack
, NULL
);
172 obstack_begin (&dont_print_statmem_obstack
, 32 * sizeof (CORE_ADDR
));
174 if (obstack_object_size (&dont_print_stat_array_obstack
) > 0)
176 obstack_free (&dont_print_stat_array_obstack
, NULL
);
177 obstack_begin (&dont_print_stat_array_obstack
,
178 32 * sizeof (struct type
*));
182 fprintf_filtered (stream
, "{");
183 len
= TYPE_NFIELDS (type
);
184 n_baseclasses
= TYPE_N_BASECLASSES (type
);
186 /* First, print out baseclasses such that we don't print
187 duplicates of virtual baseclasses. */
189 if (n_baseclasses
> 0)
190 cp_print_value (type
, real_type
, valaddr
, offset
, address
, stream
,
191 recurse
+ 1, val
, options
, dont_print_vb
);
193 /* Second, print out data fields */
195 /* If there are no data fields, skip this part */
196 if (len
== n_baseclasses
|| !len
)
197 fprintf_filtered (stream
, "<No data fields>");
200 int statmem_obstack_initial_size
= 0;
201 int stat_array_obstack_initial_size
= 0;
203 if (dont_print_statmem
== 0)
205 statmem_obstack_initial_size
=
206 obstack_object_size (&dont_print_statmem_obstack
);
208 if (last_set_recurse
!= recurse
)
210 stat_array_obstack_initial_size
=
211 obstack_object_size (&dont_print_stat_array_obstack
);
213 last_set_recurse
= recurse
;
217 for (i
= n_baseclasses
; i
< len
; i
++)
219 /* If requested, skip printing of static fields. */
220 if (!options
->static_field_print
221 && field_is_static (&TYPE_FIELD (type
, i
)))
225 fprintf_filtered (stream
, ", ");
226 else if (n_baseclasses
> 0)
230 fprintf_filtered (stream
, "\n");
231 print_spaces_filtered (2 + 2 * recurse
, stream
);
232 fputs_filtered ("members of ", stream
);
233 fputs_filtered (type_name_no_tag (type
), stream
);
234 fputs_filtered (": ", stream
);
241 fprintf_filtered (stream
, "\n");
242 print_spaces_filtered (2 + 2 * recurse
, stream
);
246 wrap_here (n_spaces (2 + 2 * recurse
));
248 if (options
->inspect_it
)
250 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
251 fputs_filtered ("\"( ptr \"", stream
);
253 fputs_filtered ("\"( nodef \"", stream
);
254 if (field_is_static (&TYPE_FIELD (type
, i
)))
255 fputs_filtered ("static ", stream
);
256 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
257 current_language
->la_language
,
258 DMGL_PARAMS
| DMGL_ANSI
);
259 fputs_filtered ("\" \"", stream
);
260 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
261 current_language
->la_language
,
262 DMGL_PARAMS
| DMGL_ANSI
);
263 fputs_filtered ("\") \"", stream
);
267 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
269 if (field_is_static (&TYPE_FIELD (type
, i
)))
270 fputs_filtered ("static ", stream
);
271 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
272 current_language
->la_language
,
273 DMGL_PARAMS
| DMGL_ANSI
);
274 annotate_field_name_end ();
275 /* do not print leading '=' in case of anonymous unions */
276 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
277 fputs_filtered (" = ", stream
);
278 annotate_field_value ();
281 if (!field_is_static (&TYPE_FIELD (type
, i
))
282 && TYPE_FIELD_PACKED (type
, i
))
286 /* Bitfields require special handling, especially due to byte
288 if (TYPE_FIELD_IGNORE (type
, i
))
290 fputs_filtered ("<optimized out or zero length>", stream
);
292 else if (value_bits_synthetic_pointer (val
,
293 TYPE_FIELD_BITPOS (type
,
295 TYPE_FIELD_BITSIZE (type
,
298 fputs_filtered (_("<synthetic pointer>"), stream
);
300 else if (!value_bits_valid (val
, TYPE_FIELD_BITPOS (type
, i
),
301 TYPE_FIELD_BITSIZE (type
, i
)))
303 fputs_filtered (_("<value optimized out>"), stream
);
307 struct value_print_options opts
= *options
;
310 v
= value_from_longest
311 (TYPE_FIELD_TYPE (type
, i
),
312 unpack_field_as_long (type
, valaddr
+ offset
, i
));
314 common_val_print (v
, stream
, recurse
+ 1, &opts
,
320 if (TYPE_FIELD_IGNORE (type
, i
))
322 fputs_filtered ("<optimized out or zero length>", stream
);
324 else if (field_is_static (&TYPE_FIELD (type
, i
)))
326 struct value
*v
= value_static_field (type
, i
);
329 fputs_filtered ("<optimized out>", stream
);
331 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
), v
,
332 stream
, recurse
+ 1, options
);
336 struct value_print_options opts
= *options
;
339 val_print (TYPE_FIELD_TYPE (type
, i
),
340 valaddr
, offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
342 stream
, recurse
+ 1, val
, &opts
,
346 annotate_field_end ();
349 if (dont_print_statmem
== 0)
351 int obstack_final_size
=
352 obstack_object_size (&dont_print_statmem_obstack
);
354 if (obstack_final_size
> statmem_obstack_initial_size
) {
355 /* In effect, a pop of the printed-statics stack. */
358 obstack_next_free (&dont_print_statmem_obstack
) -
359 (obstack_final_size
- statmem_obstack_initial_size
);
361 obstack_free (&dont_print_statmem_obstack
,
365 if (last_set_recurse
!= recurse
)
367 int obstack_final_size
=
368 obstack_object_size (&dont_print_stat_array_obstack
);
370 if (obstack_final_size
> stat_array_obstack_initial_size
)
373 obstack_next_free (&dont_print_stat_array_obstack
) -
374 (obstack_final_size
- stat_array_obstack_initial_size
);
376 obstack_free (&dont_print_stat_array_obstack
,
379 last_set_recurse
= -1;
385 fprintf_filtered (stream
, "\n");
386 print_spaces_filtered (2 * recurse
, stream
);
388 } /* if there are data fields */
390 fprintf_filtered (stream
, "}");
393 /* Like cp_print_value_fields, but find the runtime type of the object
394 and pass it as the `real_type' argument to cp_print_value_fields.
395 This function is a hack to work around the fact that
396 common_val_print passes the embedded offset to val_print, but not
397 the enclosing type. */
400 cp_print_value_fields_rtti (struct type
*type
,
401 const gdb_byte
*valaddr
, int offset
,
403 struct ui_file
*stream
, int recurse
,
404 const struct value
*val
,
405 const struct value_print_options
*options
,
406 struct type
**dont_print_vb
,
407 int dont_print_statmem
)
409 struct type
*real_type
= NULL
;
411 /* We require all bits to be valid in order to attempt a
413 if (value_bits_valid (val
, TARGET_CHAR_BIT
* offset
,
414 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
417 int full
, top
, using_enc
;
419 /* Ugh, we have to convert back to a value here. */
420 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
422 /* We don't actually care about most of the result here -- just the
423 type. We already have the correct offset, due to how val_print
424 was initially called. */
425 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
431 cp_print_value_fields (type
, real_type
, valaddr
, offset
,
432 address
, stream
, recurse
, val
, options
,
433 dont_print_vb
, dont_print_statmem
);
436 /* Special val_print routine to avoid printing multiple copies of virtual
440 cp_print_value (struct type
*type
, struct type
*real_type
,
441 const gdb_byte
*valaddr
, int offset
, CORE_ADDR address
,
442 struct ui_file
*stream
, int recurse
,
443 const struct value
*val
,
444 const struct value_print_options
*options
,
445 struct type
**dont_print_vb
)
447 struct type
**last_dont_print
448 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
449 struct obstack tmp_obstack
= dont_print_vb_obstack
;
450 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
452 struct type
*thistype
;
454 if (dont_print_vb
== 0)
456 /* If we're at top level, carve out a completely fresh
457 chunk of the obstack and use that until this particular
458 invocation returns. */
459 /* Bump up the high-water mark. Now alpha is omega. */
460 obstack_finish (&dont_print_vb_obstack
);
463 for (i
= 0; i
< n_baseclasses
; i
++)
467 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
468 char *basename
= TYPE_NAME (baseclass
);
469 const gdb_byte
*base_valaddr
;
471 if (BASETYPE_VIA_VIRTUAL (type
, i
))
473 struct type
**first_dont_print
474 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
476 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
480 if (baseclass
== first_dont_print
[j
])
483 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
487 thistype
= real_type
;
489 boffset
= baseclass_offset (type
, i
, valaddr
+ offset
, address
+ offset
);
490 skip
= ((boffset
== -1) || (boffset
+ offset
) < 0) ? 1 : -1;
492 if (BASETYPE_VIA_VIRTUAL (type
, i
))
494 /* The virtual base class pointer might have been
495 clobbered by the user program. Make sure that it
496 still points to a valid memory location. */
499 && ((boffset
+ offset
) < 0
500 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
)))
502 /* FIXME (alloca): unsafe if baseclass is really really large. */
503 gdb_byte
*buf
= alloca (TYPE_LENGTH (baseclass
));
506 if (target_read_memory (address
+ boffset
, buf
,
507 TYPE_LENGTH (baseclass
)) != 0)
509 address
= address
+ boffset
;
512 thistype
= baseclass
;
515 base_valaddr
= valaddr
;
518 base_valaddr
= valaddr
;
520 /* now do the printing */
523 fprintf_filtered (stream
, "\n");
524 print_spaces_filtered (2 * recurse
, stream
);
526 fputs_filtered ("<", stream
);
527 /* Not sure what the best notation is in the case where there is no
529 fputs_filtered (basename
? basename
: "", stream
);
530 fputs_filtered ("> = ", stream
);
534 fprintf_filtered (stream
, "<invalid address>");
539 /* Attempt to run the Python pretty-printers on the
540 baseclass if possible. */
542 result
= apply_val_pretty_printer (baseclass
, base_valaddr
,
543 thisoffset
+ boffset
,
545 stream
, recurse
, val
,
550 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
551 thisoffset
+ boffset
, address
,
552 stream
, recurse
, val
, options
,
554 obstack_base (&dont_print_vb_obstack
)),
557 fputs_filtered (", ", stream
);
563 if (dont_print_vb
== 0)
565 /* Free the space used to deal with the printing
566 of this type from top level. */
567 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
568 /* Reset watermark so that we can continue protecting
569 ourselves from whatever we were protecting ourselves. */
570 dont_print_vb_obstack
= tmp_obstack
;
574 /* Print value of a static member.
575 To avoid infinite recursion when printing a class that contains
576 a static instance of the class, we keep the addresses of all printed
577 static member classes in an obstack and refuse to print them more
580 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
581 have the same meanings as in c_val_print. */
584 cp_print_static_field (struct type
*type
,
586 struct ui_file
*stream
,
588 const struct value_print_options
*options
)
590 struct value_print_options opts
;
592 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
594 CORE_ADDR
*first_dont_print
;
599 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
600 i
= obstack_object_size (&dont_print_statmem_obstack
)
601 / sizeof (CORE_ADDR
);
605 if (value_address (val
) == first_dont_print
[i
])
607 fputs_filtered ("<same as static member of an already"
614 addr
= value_address (val
);
615 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
617 CHECK_TYPEDEF (type
);
618 cp_print_value_fields (type
, value_enclosing_type (val
),
619 value_contents_for_printing (val
),
620 value_embedded_offset (val
), addr
,
622 val
, options
, NULL
, 1);
626 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
628 struct type
**first_dont_print
;
630 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
633 = (struct type
**) obstack_base (&dont_print_stat_array_obstack
);
634 i
= obstack_object_size (&dont_print_stat_array_obstack
)
635 / sizeof (struct type
*);
639 if (target_type
== first_dont_print
[i
])
641 fputs_filtered ("<same as static member of an already"
648 obstack_grow (&dont_print_stat_array_obstack
, (char *) &target_type
,
649 sizeof (struct type
*));
654 val_print (type
, value_contents_for_printing (val
),
655 value_embedded_offset (val
), value_address (val
),
657 val
, &opts
, current_language
);
661 /* Find the field in *DOMAIN, or its non-virtual base classes, with bit offset
662 OFFSET. Set *DOMAIN to the containing type and *FIELDNO to the containing
663 field number. If OFFSET is not exactly at the start of some field, set
667 cp_find_class_member (struct type
**domain_p
, int *fieldno
,
674 *domain_p
= check_typedef (*domain_p
);
676 len
= TYPE_NFIELDS (domain
);
678 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
680 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
683 if (offset
== bitpos
)
690 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
692 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
693 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain
, i
));
695 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
697 *domain_p
= TYPE_FIELD_TYPE (domain
, i
);
698 cp_find_class_member (domain_p
, fieldno
, offset
- bitpos
);
707 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
708 struct ui_file
*stream
, char *prefix
)
710 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
712 /* VAL is a byte offset into the structure type DOMAIN.
713 Find the name of the field for that offset and
715 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
717 unsigned int fieldno
;
719 val
= extract_signed_integer (valaddr
, TYPE_LENGTH (type
), byte_order
);
721 /* Pointers to data members are usually byte offsets into an object.
722 Because a data member can have offset zero, and a NULL pointer to
723 member must be distinct from any valid non-NULL pointer to
724 member, either the value is biased or the NULL value has a
725 special representation; both are permitted by ISO C++. HP aCC
726 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
727 and other compilers which use the Itanium ABI use -1 as the NULL
728 value. GDB only supports that last form; to add support for
729 another form, make this into a cp-abi hook. */
733 fprintf_filtered (stream
, "NULL");
737 cp_find_class_member (&domain
, &fieldno
, val
<< 3);
743 fputs_filtered (prefix
, stream
);
744 name
= type_name_no_tag (domain
);
746 fputs_filtered (name
, stream
);
748 c_type_print_base (domain
, stream
, 0, 0);
749 fprintf_filtered (stream
, "::");
750 fputs_filtered (TYPE_FIELD_NAME (domain
, fieldno
), stream
);
753 fprintf_filtered (stream
, "%ld", (long) val
);
758 _initialize_cp_valprint (void)
760 add_setshow_boolean_cmd ("static-members", class_support
,
761 &user_print_options
.static_field_print
, _("\
762 Set printing of C++ static members."), _("\
763 Show printing of C++ static members."), NULL
,
765 show_static_field_print
,
766 &setprintlist
, &showprintlist
);
768 add_setshow_boolean_cmd ("vtbl", class_support
,
769 &user_print_options
.vtblprint
, _("\
770 Set printing of C++ virtual function tables."), _("\
771 Show printing of C++ virtual function tables."), NULL
,
774 &setprintlist
, &showprintlist
);
776 add_setshow_boolean_cmd ("object", class_support
,
777 &user_print_options
.objectprint
, _("\
778 Set printing of object's derived type based on vtable info."), _("\
779 Show printing of object's derived type based on vtable info."), NULL
,
782 &setprintlist
, &showprintlist
);
784 obstack_begin (&dont_print_stat_array_obstack
, 32 * sizeof (struct type
*));
785 obstack_begin (&dont_print_statmem_obstack
, 32 * sizeof (CORE_ADDR
));
786 obstack_begin (&dont_print_vb_obstack
, 32 * sizeof (struct type
*));