1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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 "gdbsupport/byte-vector.h"
40 #include "cli/cli-style.h"
42 static struct obstack dont_print_vb_obstack
;
43 static struct obstack dont_print_statmem_obstack
;
44 static struct obstack dont_print_stat_array_obstack
;
46 static void cp_print_static_field (struct type
*, struct value
*,
47 struct ui_file
*, int,
48 const struct value_print_options
*);
50 static void cp_print_value (struct type
*, struct type
*,
52 CORE_ADDR
, struct ui_file
*,
54 const struct value_print_options
*,
58 /* GCC versions after 2.4.5 use this. */
59 const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
61 /* Return truth value for assertion that TYPE is of the type
62 "pointer to virtual function". */
65 cp_is_vtbl_ptr_type (struct type
*type
)
67 const char *type_name
= TYPE_NAME (type
);
69 return (type_name
!= NULL
&& !strcmp (type_name
, vtbl_ptr_name
));
72 /* Return truth value for the assertion that TYPE is of the type
73 "pointer to virtual function table". */
76 cp_is_vtbl_member (struct type
*type
)
78 /* With older versions of g++, the vtbl field pointed to an array of
79 structures. Nowadays it points directly to the structure. */
80 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
82 type
= TYPE_TARGET_TYPE (type
);
83 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
85 type
= TYPE_TARGET_TYPE (type
);
86 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
87 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
89 /* Virtual functions tables are full of pointers
90 to virtual functions. */
91 return cp_is_vtbl_ptr_type (type
);
94 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
96 return cp_is_vtbl_ptr_type (type
);
98 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
100 /* The type name of the thunk pointer is NULL when using
101 dwarf2. We could test for a pointer to a function, but
102 there is no type info for the virtual table either, so it
104 return cp_is_vtbl_ptr_type (type
);
110 /* Mutually recursive subroutines of cp_print_value and c_val_print to
111 print out a structure's fields: cp_print_value_fields and
114 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
115 meanings as in cp_print_value and c_val_print.
117 2nd argument REAL_TYPE is used to carry over the type of the
118 derived class across the recursion to base classes.
120 DONT_PRINT is an array of baseclass types that we should not print,
121 or zero if called from top level. */
124 cp_print_value_fields (struct type
*type
, struct type
*real_type
,
126 CORE_ADDR address
, struct ui_file
*stream
,
127 int recurse
, struct value
*val
,
128 const struct value_print_options
*options
,
129 struct type
**dont_print_vb
,
130 int dont_print_statmem
)
132 int i
, len
, n_baseclasses
;
134 static int last_set_recurse
= -1;
136 type
= check_typedef (type
);
140 /* Any object can be left on obstacks only during an unexpected
143 if (obstack_object_size (&dont_print_statmem_obstack
) > 0)
145 obstack_free (&dont_print_statmem_obstack
, NULL
);
146 obstack_begin (&dont_print_statmem_obstack
,
147 32 * sizeof (CORE_ADDR
));
149 if (obstack_object_size (&dont_print_stat_array_obstack
) > 0)
151 obstack_free (&dont_print_stat_array_obstack
, NULL
);
152 obstack_begin (&dont_print_stat_array_obstack
,
153 32 * sizeof (struct type
*));
157 fprintf_filtered (stream
, "{");
158 len
= TYPE_NFIELDS (type
);
159 n_baseclasses
= TYPE_N_BASECLASSES (type
);
161 /* First, print out baseclasses such that we don't print
162 duplicates of virtual baseclasses. */
164 if (n_baseclasses
> 0)
165 cp_print_value (type
, real_type
,
166 offset
, address
, stream
,
167 recurse
+ 1, val
, options
,
170 /* Second, print out data fields */
172 /* If there are no data fields, skip this part */
173 if (len
== n_baseclasses
|| !len
)
174 fprintf_styled (stream
, metadata_style
.style (), "<No data fields>");
177 size_t statmem_obstack_initial_size
= 0;
178 size_t stat_array_obstack_initial_size
= 0;
179 struct type
*vptr_basetype
= NULL
;
182 if (dont_print_statmem
== 0)
184 statmem_obstack_initial_size
=
185 obstack_object_size (&dont_print_statmem_obstack
);
187 if (last_set_recurse
!= recurse
)
189 stat_array_obstack_initial_size
=
190 obstack_object_size (&dont_print_stat_array_obstack
);
192 last_set_recurse
= recurse
;
196 vptr_fieldno
= get_vptr_fieldno (type
, &vptr_basetype
);
197 for (i
= n_baseclasses
; i
< len
; i
++)
199 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
201 /* If requested, skip printing of static fields. */
202 if (!options
->static_field_print
203 && field_is_static (&TYPE_FIELD (type
, i
)))
208 fputs_filtered (",", stream
);
209 if (!options
->prettyformat
)
210 fputs_filtered (" ", stream
);
212 else if (n_baseclasses
> 0)
214 if (options
->prettyformat
)
216 fprintf_filtered (stream
, "\n");
217 print_spaces_filtered (2 + 2 * recurse
, stream
);
218 fputs_filtered ("members of ", stream
);
219 fputs_filtered (TYPE_NAME (type
), stream
);
220 fputs_filtered (":", stream
);
225 if (options
->prettyformat
)
227 fprintf_filtered (stream
, "\n");
228 print_spaces_filtered (2 + 2 * recurse
, stream
);
232 wrap_here (n_spaces (2 + 2 * recurse
));
235 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
237 if (field_is_static (&TYPE_FIELD (type
, i
)))
239 fputs_filtered ("static ", stream
);
240 fprintf_symbol_filtered (stream
,
241 TYPE_FIELD_NAME (type
, i
),
242 current_language
->la_language
,
243 DMGL_PARAMS
| DMGL_ANSI
);
246 fputs_styled (TYPE_FIELD_NAME (type
, i
),
247 variable_name_style
.style (), stream
);
248 annotate_field_name_end ();
250 /* We tweak various options in a few cases below. */
251 value_print_options options_copy
= *options
;
252 value_print_options
*opts
= &options_copy
;
254 /* Do not print leading '=' in case of anonymous
256 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
257 fputs_filtered (" = ", stream
);
260 /* If this is an anonymous field then we want to consider it
261 as though it is at its parent's depth when it comes to the
263 if (opts
->max_depth
!= -1 && opts
->max_depth
< INT_MAX
)
266 annotate_field_value ();
268 if (!field_is_static (&TYPE_FIELD (type
, i
))
269 && TYPE_FIELD_PACKED (type
, i
))
273 /* Bitfields require special handling, especially due to
274 byte order problems. */
275 if (TYPE_FIELD_IGNORE (type
, i
))
277 fputs_styled ("<optimized out or zero length>",
278 metadata_style
.style (), stream
);
280 else if (value_bits_synthetic_pointer (val
,
281 TYPE_FIELD_BITPOS (type
,
283 TYPE_FIELD_BITSIZE (type
,
286 fputs_styled (_("<synthetic pointer>"),
287 metadata_style
.style (), stream
);
293 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
295 common_val_print (v
, stream
, recurse
+ 1,
296 opts
, current_language
);
301 if (TYPE_FIELD_IGNORE (type
, i
))
303 fputs_styled ("<optimized out or zero length>",
304 metadata_style
.style (), stream
);
306 else if (field_is_static (&TYPE_FIELD (type
, i
)))
310 struct value
*v
= value_static_field (type
, i
);
312 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
),
313 v
, stream
, recurse
+ 1,
316 catch (const gdb_exception_error
&ex
)
318 fprintf_styled (stream
, metadata_style
.style (),
319 _("<error reading variable: %s>"),
323 else if (i
== vptr_fieldno
&& type
== vptr_basetype
)
325 int i_offset
= offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8;
326 struct type
*i_type
= TYPE_FIELD_TYPE (type
, i
);
328 if (valprint_check_validity (stream
, i_type
, i_offset
, val
))
332 addr
= extract_typed_address (valaddr
+ i_offset
, i_type
);
333 print_function_pointer_address (opts
,
334 get_type_arch (type
),
341 val_print (TYPE_FIELD_TYPE (type
, i
),
342 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
344 stream
, recurse
+ 1, val
, opts
,
348 annotate_field_end ();
351 if (dont_print_statmem
== 0)
353 size_t obstack_final_size
=
354 obstack_object_size (&dont_print_statmem_obstack
);
356 if (obstack_final_size
> statmem_obstack_initial_size
)
358 /* In effect, a pop of the printed-statics stack. */
360 = statmem_obstack_initial_size
- obstack_final_size
;
361 obstack_blank_fast (&dont_print_statmem_obstack
, shrink_bytes
);
364 if (last_set_recurse
!= recurse
)
367 obstack_object_size (&dont_print_stat_array_obstack
);
369 if (obstack_final_size
> stat_array_obstack_initial_size
)
372 (char *) obstack_next_free (&dont_print_stat_array_obstack
)
373 - (obstack_final_size
374 - stat_array_obstack_initial_size
);
376 obstack_free (&dont_print_stat_array_obstack
,
379 last_set_recurse
= -1;
383 if (options
->prettyformat
)
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
, LONGEST offset
,
403 struct ui_file
*stream
, int recurse
,
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_any_optimized_out (val
,
414 TARGET_CHAR_BIT
* offset
,
415 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
421 /* Ugh, we have to convert back to a value here. */
422 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
424 type
= value_type (value
);
425 /* We don't actually care about most of the result here -- just
426 the type. We already have the correct offset, due to how
427 val_print was initially called. */
428 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
434 cp_print_value_fields (type
, real_type
, offset
,
435 address
, stream
, recurse
, val
, options
,
436 dont_print_vb
, dont_print_statmem
);
439 /* Special val_print routine to avoid printing multiple copies of
440 virtual baseclasses. */
443 cp_print_value (struct type
*type
, struct type
*real_type
,
445 CORE_ADDR address
, struct ui_file
*stream
,
446 int recurse
, struct value
*val
,
447 const struct value_print_options
*options
,
448 struct type
**dont_print_vb
)
450 struct type
**last_dont_print
451 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
452 struct obstack tmp_obstack
= dont_print_vb_obstack
;
453 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
455 struct type
*thistype
;
456 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
458 if (dont_print_vb
== 0)
460 /* If we're at top level, carve out a completely fresh chunk of
461 the obstack and use that until this particular invocation
463 /* Bump up the high-water mark. Now alpha is omega. */
464 obstack_finish (&dont_print_vb_obstack
);
467 for (i
= 0; i
< n_baseclasses
; i
++)
471 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
472 const char *basename
= TYPE_NAME (baseclass
);
473 struct value
*base_val
= NULL
;
475 if (BASETYPE_VIA_VIRTUAL (type
, i
))
477 struct type
**first_dont_print
478 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
480 int j
= (struct type
**)
481 obstack_next_free (&dont_print_vb_obstack
) - first_dont_print
;
484 if (baseclass
== first_dont_print
[j
])
487 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
491 thistype
= real_type
;
495 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
497 catch (const gdb_exception_error
&ex
)
499 if (ex
.error
== NOT_AVAILABLE_ERROR
)
507 if (BASETYPE_VIA_VIRTUAL (type
, i
))
509 /* The virtual base class pointer might have been
510 clobbered by the user program. Make sure that it
511 still points to a valid memory location. */
513 if ((boffset
+ offset
) < 0
514 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
))
516 gdb::byte_vector
buf (TYPE_LENGTH (baseclass
));
518 if (target_read_memory (address
+ boffset
, buf
.data (),
519 TYPE_LENGTH (baseclass
)) != 0)
521 base_val
= value_from_contents_and_address (baseclass
,
524 baseclass
= value_type (base_val
);
527 thistype
= baseclass
;
540 /* Now do the printing. */
541 if (options
->prettyformat
)
543 fprintf_filtered (stream
, "\n");
544 print_spaces_filtered (2 * recurse
, stream
);
546 fputs_filtered ("<", stream
);
547 /* Not sure what the best notation is in the case where there is
548 no baseclass name. */
549 fputs_filtered (basename
? basename
: "", stream
);
550 fputs_filtered ("> = ", stream
);
553 val_print_unavailable (stream
);
555 val_print_invalid_address (stream
);
560 if (options
->max_depth
> -1
561 && recurse
>= options
->max_depth
)
563 const struct language_defn
*language
= current_language
;
564 gdb_assert (language
->la_struct_too_deep_ellipsis
!= NULL
);
565 fputs_filtered (language
->la_struct_too_deep_ellipsis
, stream
);
569 /* Attempt to run an extension language pretty-printer on the
570 baseclass if possible. */
573 = apply_ext_lang_val_pretty_printer (baseclass
,
574 thisoffset
+ boffset
,
575 value_address (base_val
),
581 cp_print_value_fields (baseclass
, thistype
,
582 thisoffset
+ boffset
,
583 value_address (base_val
),
584 stream
, recurse
, base_val
, options
,
586 obstack_base (&dont_print_vb_obstack
)),
590 fputs_filtered (", ", stream
);
596 if (dont_print_vb
== 0)
598 /* Free the space used to deal with the printing
599 of this type from top level. */
600 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
601 /* Reset watermark so that we can continue protecting
602 ourselves from whatever we were protecting ourselves. */
603 dont_print_vb_obstack
= tmp_obstack
;
607 /* Print value of a static member. To avoid infinite recursion when
608 printing a class that contains a static instance of the class, we
609 keep the addresses of all printed static member classes in an
610 obstack and refuse to print them more than once.
612 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
613 have the same meanings as in c_val_print. */
616 cp_print_static_field (struct type
*type
,
618 struct ui_file
*stream
,
620 const struct value_print_options
*options
)
622 struct value_print_options opts
;
624 if (value_entirely_optimized_out (val
))
626 val_print_optimized_out (val
, stream
);
630 struct type
*real_type
= check_typedef (type
);
631 if (TYPE_CODE (real_type
) == TYPE_CODE_STRUCT
)
633 CORE_ADDR
*first_dont_print
;
638 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
639 i
= obstack_object_size (&dont_print_statmem_obstack
)
640 / sizeof (CORE_ADDR
);
644 if (value_address (val
) == first_dont_print
[i
])
646 fputs_styled (_("<same as static member of an already"
648 metadata_style
.style (), stream
);
653 addr
= value_address (val
);
654 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
656 cp_print_value_fields (type
, value_enclosing_type (val
),
657 value_embedded_offset (val
), addr
,
658 stream
, recurse
, val
,
663 if (TYPE_CODE (real_type
) == TYPE_CODE_ARRAY
)
665 struct type
**first_dont_print
;
667 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
670 = (struct type
**) obstack_base (&dont_print_stat_array_obstack
);
671 i
= obstack_object_size (&dont_print_stat_array_obstack
)
672 / sizeof (struct type
*);
676 if (target_type
== first_dont_print
[i
])
678 fputs_styled (_("<same as static member of an already"
680 metadata_style
.style (), stream
);
685 obstack_grow (&dont_print_stat_array_obstack
,
686 (char *) &target_type
,
687 sizeof (struct type
*));
692 common_val_print (val
, stream
, recurse
, &opts
, current_language
);
695 /* Find the field in *SELF, or its non-virtual base classes, with
696 bit offset OFFSET. Set *SELF to the containing type and *FIELDNO
697 to the containing field number. If OFFSET is not exactly at the
698 start of some field, set *SELF to NULL. */
701 cp_find_class_member (struct type
**self_p
, int *fieldno
,
708 *self_p
= check_typedef (*self_p
);
710 len
= TYPE_NFIELDS (self
);
712 for (i
= TYPE_N_BASECLASSES (self
); i
< len
; i
++)
714 LONGEST bitpos
= TYPE_FIELD_BITPOS (self
, i
);
717 if (offset
== bitpos
)
724 for (i
= 0; i
< TYPE_N_BASECLASSES (self
); i
++)
726 LONGEST bitpos
= TYPE_FIELD_BITPOS (self
, i
);
727 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self
, i
));
729 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
731 *self_p
= TYPE_FIELD_TYPE (self
, i
);
732 cp_find_class_member (self_p
, fieldno
, offset
- bitpos
);
741 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
742 struct ui_file
*stream
, const char *prefix
)
744 enum bfd_endian byte_order
= type_byte_order (type
);
746 /* VAL is a byte offset into the structure type SELF_TYPE.
747 Find the name of the field for that offset and
749 struct type
*self_type
= TYPE_SELF_TYPE (type
);
753 val
= extract_signed_integer (valaddr
,
757 /* Pointers to data members are usually byte offsets into an object.
758 Because a data member can have offset zero, and a NULL pointer to
759 member must be distinct from any valid non-NULL pointer to
760 member, either the value is biased or the NULL value has a
761 special representation; both are permitted by ISO C++. HP aCC
762 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
763 and other compilers which use the Itanium ABI use -1 as the NULL
764 value. GDB only supports that last form; to add support for
765 another form, make this into a cp-abi hook. */
769 fprintf_filtered (stream
, "NULL");
773 cp_find_class_member (&self_type
, &fieldno
, val
<< 3);
775 if (self_type
!= NULL
)
779 fputs_filtered (prefix
, stream
);
780 name
= TYPE_NAME (self_type
);
782 fputs_filtered (name
, stream
);
784 c_type_print_base (self_type
, stream
, 0, 0, &type_print_raw_options
);
785 fprintf_filtered (stream
, "::");
786 fputs_styled (TYPE_FIELD_NAME (self_type
, fieldno
),
787 variable_name_style
.style (), stream
);
790 fprintf_filtered (stream
, "%ld", (long) val
);
794 void _initialize_cp_valprint ();
796 _initialize_cp_valprint ()
798 obstack_begin (&dont_print_stat_array_obstack
,
799 32 * sizeof (struct type
*));
800 obstack_begin (&dont_print_statmem_obstack
,
801 32 * sizeof (CORE_ADDR
));
802 obstack_begin (&dont_print_vb_obstack
,
803 32 * sizeof (struct type
*));