1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "gdb_obstack.h"
24 #include "expression.h"
34 #include "cp-support.h"
36 #include "extension.h"
37 #include "typeprint.h"
38 #include "byte-vector.h"
40 /* Controls printing of vtbl's. */
42 show_vtblprint (struct ui_file
*file
, int from_tty
,
43 struct cmd_list_element
*c
, const char *value
)
45 fprintf_filtered (file
, _("\
46 Printing of C++ virtual function tables is %s.\n"),
50 /* Controls looking up an object's derived type using what we find in
53 show_objectprint (struct ui_file
*file
, int from_tty
,
54 struct cmd_list_element
*c
,
57 fprintf_filtered (file
, _("\
58 Printing of object's derived type based on vtable info is %s.\n"),
63 show_static_field_print (struct ui_file
*file
, int from_tty
,
64 struct cmd_list_element
*c
,
67 fprintf_filtered (file
,
68 _("Printing of C++ static members is %s.\n"),
73 static struct obstack dont_print_vb_obstack
;
74 static struct obstack dont_print_statmem_obstack
;
75 static struct obstack dont_print_stat_array_obstack
;
77 static void cp_print_static_field (struct type
*, struct value
*,
78 struct ui_file
*, int,
79 const struct value_print_options
*);
81 static void cp_print_value (struct type
*, struct type
*,
83 CORE_ADDR
, struct ui_file
*,
85 const struct value_print_options
*,
89 /* GCC versions after 2.4.5 use this. */
90 extern const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
92 /* Return truth value for assertion that TYPE is of the type
93 "pointer to virtual function". */
96 cp_is_vtbl_ptr_type (struct type
*type
)
98 const char *type_name
= type_name_no_tag (type
);
100 return (type_name
!= NULL
&& !strcmp (type_name
, vtbl_ptr_name
));
103 /* Return truth value for the assertion that TYPE is of the type
104 "pointer to virtual function table". */
107 cp_is_vtbl_member (struct type
*type
)
109 /* With older versions of g++, the vtbl field pointed to an array of
110 structures. Nowadays it points directly to the structure. */
111 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
113 type
= TYPE_TARGET_TYPE (type
);
114 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
116 type
= TYPE_TARGET_TYPE (type
);
117 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
118 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
120 /* Virtual functions tables are full of pointers
121 to virtual functions. */
122 return cp_is_vtbl_ptr_type (type
);
125 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
127 return cp_is_vtbl_ptr_type (type
);
129 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
131 /* The type name of the thunk pointer is NULL when using
132 dwarf2. We could test for a pointer to a function, but
133 there is no type info for the virtual table either, so it
135 return cp_is_vtbl_ptr_type (type
);
141 /* Mutually recursive subroutines of cp_print_value and c_val_print to
142 print out a structure's fields: cp_print_value_fields and
145 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
146 meanings as in cp_print_value and c_val_print.
148 2nd argument REAL_TYPE is used to carry over the type of the
149 derived class across the recursion to base classes.
151 DONT_PRINT is an array of baseclass types that we should not print,
152 or zero if called from top level. */
155 cp_print_value_fields (struct type
*type
, struct type
*real_type
,
157 CORE_ADDR address
, struct ui_file
*stream
,
158 int recurse
, struct value
*val
,
159 const struct value_print_options
*options
,
160 struct type
**dont_print_vb
,
161 int dont_print_statmem
)
163 int i
, len
, n_baseclasses
;
165 static int last_set_recurse
= -1;
167 type
= check_typedef (type
);
171 /* Any object can be left on obstacks only during an unexpected
174 if (obstack_object_size (&dont_print_statmem_obstack
) > 0)
176 obstack_free (&dont_print_statmem_obstack
, NULL
);
177 obstack_begin (&dont_print_statmem_obstack
,
178 32 * sizeof (CORE_ADDR
));
180 if (obstack_object_size (&dont_print_stat_array_obstack
) > 0)
182 obstack_free (&dont_print_stat_array_obstack
, NULL
);
183 obstack_begin (&dont_print_stat_array_obstack
,
184 32 * sizeof (struct type
*));
188 fprintf_filtered (stream
, "{");
189 len
= TYPE_NFIELDS (type
);
190 n_baseclasses
= TYPE_N_BASECLASSES (type
);
192 /* First, print out baseclasses such that we don't print
193 duplicates of virtual baseclasses. */
195 if (n_baseclasses
> 0)
196 cp_print_value (type
, real_type
,
197 offset
, address
, stream
,
198 recurse
+ 1, val
, options
,
201 /* Second, print out data fields */
203 /* If there are no data fields, skip this part */
204 if (len
== n_baseclasses
|| !len
)
205 fprintf_filtered (stream
, "<No data fields>");
208 size_t statmem_obstack_initial_size
= 0;
209 size_t stat_array_obstack_initial_size
= 0;
210 struct type
*vptr_basetype
= NULL
;
213 if (dont_print_statmem
== 0)
215 statmem_obstack_initial_size
=
216 obstack_object_size (&dont_print_statmem_obstack
);
218 if (last_set_recurse
!= recurse
)
220 stat_array_obstack_initial_size
=
221 obstack_object_size (&dont_print_stat_array_obstack
);
223 last_set_recurse
= recurse
;
227 vptr_fieldno
= get_vptr_fieldno (type
, &vptr_basetype
);
228 for (i
= n_baseclasses
; i
< len
; i
++)
230 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
232 /* If requested, skip printing of static fields. */
233 if (!options
->static_field_print
234 && field_is_static (&TYPE_FIELD (type
, i
)))
238 fprintf_filtered (stream
, ", ");
239 else if (n_baseclasses
> 0)
241 if (options
->prettyformat
)
243 fprintf_filtered (stream
, "\n");
244 print_spaces_filtered (2 + 2 * recurse
, stream
);
245 fputs_filtered ("members of ", stream
);
246 fputs_filtered (type_name_no_tag (type
), stream
);
247 fputs_filtered (": ", stream
);
252 if (options
->prettyformat
)
254 fprintf_filtered (stream
, "\n");
255 print_spaces_filtered (2 + 2 * recurse
, stream
);
259 wrap_here (n_spaces (2 + 2 * recurse
));
262 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
264 if (field_is_static (&TYPE_FIELD (type
, i
)))
265 fputs_filtered ("static ", stream
);
266 fprintf_symbol_filtered (stream
,
267 TYPE_FIELD_NAME (type
, i
),
268 current_language
->la_language
,
269 DMGL_PARAMS
| DMGL_ANSI
);
270 annotate_field_name_end ();
271 /* Do not print leading '=' in case of anonymous
273 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
274 fputs_filtered (" = ", stream
);
275 annotate_field_value ();
277 if (!field_is_static (&TYPE_FIELD (type
, i
))
278 && TYPE_FIELD_PACKED (type
, i
))
282 /* Bitfields require special handling, especially due to
283 byte order problems. */
284 if (TYPE_FIELD_IGNORE (type
, i
))
286 fputs_filtered ("<optimized out or zero length>", stream
);
288 else if (value_bits_synthetic_pointer (val
,
289 TYPE_FIELD_BITPOS (type
,
291 TYPE_FIELD_BITSIZE (type
,
294 fputs_filtered (_("<synthetic pointer>"), stream
);
298 struct value_print_options opts
= *options
;
302 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
304 common_val_print (v
, stream
, recurse
+ 1, &opts
,
310 if (TYPE_FIELD_IGNORE (type
, i
))
312 fputs_filtered ("<optimized out or zero length>",
315 else if (field_is_static (&TYPE_FIELD (type
, i
)))
317 struct value
*v
= NULL
;
321 v
= value_static_field (type
, i
);
324 CATCH (ex
, RETURN_MASK_ERROR
)
326 fprintf_filtered (stream
,
327 _("<error reading variable: %s>"),
332 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
),
333 v
, stream
, recurse
+ 1,
336 else if (i
== vptr_fieldno
&& type
== vptr_basetype
)
338 int i_offset
= offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8;
339 struct type
*i_type
= TYPE_FIELD_TYPE (type
, i
);
341 if (valprint_check_validity (stream
, i_type
, i_offset
, val
))
345 addr
= extract_typed_address (valaddr
+ i_offset
, i_type
);
346 print_function_pointer_address (options
,
347 get_type_arch (type
),
353 struct value_print_options opts
= *options
;
356 val_print (TYPE_FIELD_TYPE (type
, i
),
357 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
359 stream
, recurse
+ 1, val
, &opts
,
363 annotate_field_end ();
366 if (dont_print_statmem
== 0)
368 size_t obstack_final_size
=
369 obstack_object_size (&dont_print_statmem_obstack
);
371 if (obstack_final_size
> statmem_obstack_initial_size
)
373 /* In effect, a pop of the printed-statics stack. */
376 (char *) obstack_next_free (&dont_print_statmem_obstack
) -
377 (obstack_final_size
- statmem_obstack_initial_size
);
379 obstack_free (&dont_print_statmem_obstack
,
383 if (last_set_recurse
!= recurse
)
385 size_t obstack_final_size
=
386 obstack_object_size (&dont_print_stat_array_obstack
);
388 if (obstack_final_size
> stat_array_obstack_initial_size
)
391 (char *) obstack_next_free (&dont_print_stat_array_obstack
)
392 - (obstack_final_size
393 - stat_array_obstack_initial_size
);
395 obstack_free (&dont_print_stat_array_obstack
,
398 last_set_recurse
= -1;
402 if (options
->prettyformat
)
404 fprintf_filtered (stream
, "\n");
405 print_spaces_filtered (2 * recurse
, stream
);
407 } /* if there are data fields */
409 fprintf_filtered (stream
, "}");
412 /* Like cp_print_value_fields, but find the runtime type of the object
413 and pass it as the `real_type' argument to cp_print_value_fields.
414 This function is a hack to work around the fact that
415 common_val_print passes the embedded offset to val_print, but not
416 the enclosing type. */
419 cp_print_value_fields_rtti (struct type
*type
,
420 const gdb_byte
*valaddr
, LONGEST offset
,
422 struct ui_file
*stream
, int recurse
,
424 const struct value_print_options
*options
,
425 struct type
**dont_print_vb
,
426 int dont_print_statmem
)
428 struct type
*real_type
= NULL
;
430 /* We require all bits to be valid in order to attempt a
432 if (!value_bits_any_optimized_out (val
,
433 TARGET_CHAR_BIT
* offset
,
434 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
440 /* Ugh, we have to convert back to a value here. */
441 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
443 type
= value_type (value
);
444 /* We don't actually care about most of the result here -- just
445 the type. We already have the correct offset, due to how
446 val_print was initially called. */
447 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
453 cp_print_value_fields (type
, real_type
, offset
,
454 address
, stream
, recurse
, val
, options
,
455 dont_print_vb
, dont_print_statmem
);
458 /* Special val_print routine to avoid printing multiple copies of
459 virtual baseclasses. */
462 cp_print_value (struct type
*type
, struct type
*real_type
,
464 CORE_ADDR address
, struct ui_file
*stream
,
465 int recurse
, struct value
*val
,
466 const struct value_print_options
*options
,
467 struct type
**dont_print_vb
)
469 struct type
**last_dont_print
470 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
471 struct obstack tmp_obstack
= dont_print_vb_obstack
;
472 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
474 struct type
*thistype
;
475 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
477 if (dont_print_vb
== 0)
479 /* If we're at top level, carve out a completely fresh chunk of
480 the obstack and use that until this particular invocation
482 /* Bump up the high-water mark. Now alpha is omega. */
483 obstack_finish (&dont_print_vb_obstack
);
486 for (i
= 0; i
< n_baseclasses
; i
++)
490 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
491 const char *basename
= TYPE_NAME (baseclass
);
492 struct value
*base_val
= NULL
;
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
;
514 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
516 CATCH (ex
, RETURN_MASK_ERROR
)
518 if (ex
.error
== NOT_AVAILABLE_ERROR
)
527 if (BASETYPE_VIA_VIRTUAL (type
, i
))
529 /* The virtual base class pointer might have been
530 clobbered by the user program. Make sure that it
531 still points to a valid memory location. */
533 if ((boffset
+ offset
) < 0
534 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
))
536 gdb::byte_vector
buf (TYPE_LENGTH (baseclass
));
538 if (target_read_memory (address
+ boffset
, buf
.data (),
539 TYPE_LENGTH (baseclass
)) != 0)
541 base_val
= value_from_contents_and_address (baseclass
,
544 baseclass
= value_type (base_val
);
547 thistype
= baseclass
;
560 /* Now do the printing. */
561 if (options
->prettyformat
)
563 fprintf_filtered (stream
, "\n");
564 print_spaces_filtered (2 * recurse
, stream
);
566 fputs_filtered ("<", stream
);
567 /* Not sure what the best notation is in the case where there is
568 no baseclass name. */
569 fputs_filtered (basename
? basename
: "", stream
);
570 fputs_filtered ("> = ", stream
);
573 val_print_unavailable (stream
);
575 val_print_invalid_address (stream
);
580 /* Attempt to run an extension language pretty-printer on the
581 baseclass if possible. */
584 = apply_ext_lang_val_pretty_printer (baseclass
,
585 thisoffset
+ boffset
,
586 value_address (base_val
),
592 cp_print_value_fields (baseclass
, thistype
,
593 thisoffset
+ boffset
,
594 value_address (base_val
),
595 stream
, recurse
, base_val
, options
,
597 obstack_base (&dont_print_vb_obstack
)),
600 fputs_filtered (", ", stream
);
606 if (dont_print_vb
== 0)
608 /* Free the space used to deal with the printing
609 of this type from top level. */
610 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
611 /* Reset watermark so that we can continue protecting
612 ourselves from whatever we were protecting ourselves. */
613 dont_print_vb_obstack
= tmp_obstack
;
617 /* Print value of a static member. To avoid infinite recursion when
618 printing a class that contains a static instance of the class, we
619 keep the addresses of all printed static member classes in an
620 obstack and refuse to print them more than once.
622 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
623 have the same meanings as in c_val_print. */
626 cp_print_static_field (struct type
*type
,
628 struct ui_file
*stream
,
630 const struct value_print_options
*options
)
632 struct value_print_options opts
;
634 if (value_entirely_optimized_out (val
))
636 val_print_optimized_out (val
, stream
);
640 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
642 CORE_ADDR
*first_dont_print
;
647 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
648 i
= obstack_object_size (&dont_print_statmem_obstack
)
649 / sizeof (CORE_ADDR
);
653 if (value_address (val
) == first_dont_print
[i
])
655 fputs_filtered ("<same as static member of an already"
662 addr
= value_address (val
);
663 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
665 type
= check_typedef (type
);
666 cp_print_value_fields (type
, value_enclosing_type (val
),
667 value_embedded_offset (val
), addr
,
668 stream
, recurse
, val
,
673 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
675 struct type
**first_dont_print
;
677 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
680 = (struct type
**) obstack_base (&dont_print_stat_array_obstack
);
681 i
= obstack_object_size (&dont_print_stat_array_obstack
)
682 / sizeof (struct type
*);
686 if (target_type
== first_dont_print
[i
])
688 fputs_filtered ("<same as static member of an already"
695 obstack_grow (&dont_print_stat_array_obstack
,
696 (char *) &target_type
,
697 sizeof (struct type
*));
703 value_embedded_offset (val
),
705 stream
, recurse
, val
,
706 &opts
, current_language
);
709 /* Find the field in *SELF, or its non-virtual base classes, with
710 bit offset OFFSET. Set *SELF to the containing type and *FIELDNO
711 to the containing field number. If OFFSET is not exactly at the
712 start of some field, set *SELF to NULL. */
715 cp_find_class_member (struct type
**self_p
, int *fieldno
,
722 *self_p
= check_typedef (*self_p
);
724 len
= TYPE_NFIELDS (self
);
726 for (i
= TYPE_N_BASECLASSES (self
); i
< len
; i
++)
728 LONGEST bitpos
= TYPE_FIELD_BITPOS (self
, i
);
731 if (offset
== bitpos
)
738 for (i
= 0; i
< TYPE_N_BASECLASSES (self
); i
++)
740 LONGEST bitpos
= TYPE_FIELD_BITPOS (self
, i
);
741 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self
, i
));
743 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
745 *self_p
= TYPE_FIELD_TYPE (self
, i
);
746 cp_find_class_member (self_p
, fieldno
, offset
- bitpos
);
755 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
756 struct ui_file
*stream
, const char *prefix
)
758 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
760 /* VAL is a byte offset into the structure type SELF_TYPE.
761 Find the name of the field for that offset and
763 struct type
*self_type
= TYPE_SELF_TYPE (type
);
767 val
= extract_signed_integer (valaddr
,
771 /* Pointers to data members are usually byte offsets into an object.
772 Because a data member can have offset zero, and a NULL pointer to
773 member must be distinct from any valid non-NULL pointer to
774 member, either the value is biased or the NULL value has a
775 special representation; both are permitted by ISO C++. HP aCC
776 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
777 and other compilers which use the Itanium ABI use -1 as the NULL
778 value. GDB only supports that last form; to add support for
779 another form, make this into a cp-abi hook. */
783 fprintf_filtered (stream
, "NULL");
787 cp_find_class_member (&self_type
, &fieldno
, val
<< 3);
789 if (self_type
!= NULL
)
793 fputs_filtered (prefix
, stream
);
794 name
= type_name_no_tag (self_type
);
796 fputs_filtered (name
, stream
);
798 c_type_print_base (self_type
, stream
, 0, 0, &type_print_raw_options
);
799 fprintf_filtered (stream
, "::");
800 fputs_filtered (TYPE_FIELD_NAME (self_type
, fieldno
), stream
);
803 fprintf_filtered (stream
, "%ld", (long) val
);
808 _initialize_cp_valprint (void)
810 add_setshow_boolean_cmd ("static-members", class_support
,
811 &user_print_options
.static_field_print
, _("\
812 Set printing of C++ static members."), _("\
813 Show printing of C++ static members."), NULL
,
815 show_static_field_print
,
816 &setprintlist
, &showprintlist
);
818 add_setshow_boolean_cmd ("vtbl", class_support
,
819 &user_print_options
.vtblprint
, _("\
820 Set printing of C++ virtual function tables."), _("\
821 Show printing of C++ virtual function tables."), NULL
,
824 &setprintlist
, &showprintlist
);
826 add_setshow_boolean_cmd ("object", class_support
,
827 &user_print_options
.objectprint
, _("\
828 Set printing of object's derived type based on vtable info."), _("\
829 Show printing of object's derived type based on vtable info."), NULL
,
832 &setprintlist
, &showprintlist
);
834 obstack_begin (&dont_print_stat_array_obstack
,
835 32 * sizeof (struct type
*));
836 obstack_begin (&dont_print_statmem_obstack
,
837 32 * sizeof (CORE_ADDR
));
838 obstack_begin (&dont_print_vb_obstack
,
839 32 * sizeof (struct type
*));