1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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 "common/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 (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)))
239 fputs_filtered (",", stream);
240 if (!options->prettyformat)
241 fputs_filtered (" ", stream);
243 else if (n_baseclasses > 0)
245 if (options->prettyformat)
247 fprintf_filtered (stream, "\n");
248 print_spaces_filtered (2 + 2 * recurse, stream);
249 fputs_filtered ("members of ", stream);
250 fputs_filtered (TYPE_NAME (type), stream);
251 fputs_filtered (":", stream);
256 if (options->prettyformat)
258 fprintf_filtered (stream, "\n");
259 print_spaces_filtered (2 + 2 * recurse, stream);
263 wrap_here (n_spaces (2 + 2 * recurse));
266 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
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 annotate_field_name_end ();
275 /* Do not print leading '=' in case of anonymous
277 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
278 fputs_filtered (" = ", stream);
279 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
287 byte order problems. */
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);
302 struct value_print_options opts = *options;
306 v = value_field_bitfield (type, i, valaddr, offset, val);
308 common_val_print (v, stream, recurse + 1, &opts,
314 if (TYPE_FIELD_IGNORE (type, i))
316 fputs_filtered ("<optimized out or zero length>",
319 else if (field_is_static (&TYPE_FIELD (type, i)))
321 struct value *v = NULL;
325 v = value_static_field (type, i);
328 catch (const gdb_exception_RETURN_MASK_ERROR &ex)
330 fprintf_filtered (stream,
331 _("<error reading variable: %s>"),
335 cp_print_static_field (TYPE_FIELD_TYPE (type, i),
336 v, stream, recurse + 1,
339 else if (i == vptr_fieldno && type == vptr_basetype)
341 int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
342 struct type *i_type = TYPE_FIELD_TYPE (type, i);
344 if (valprint_check_validity (stream, i_type, i_offset, val))
348 addr = extract_typed_address (valaddr + i_offset, i_type);
349 print_function_pointer_address (options,
350 get_type_arch (type),
356 struct value_print_options opts = *options;
359 val_print (TYPE_FIELD_TYPE (type, i),
360 offset + TYPE_FIELD_BITPOS (type, i) / 8,
362 stream, recurse + 1, val, &opts,
366 annotate_field_end ();
369 if (dont_print_statmem == 0)
371 size_t obstack_final_size =
372 obstack_object_size (&dont_print_statmem_obstack);
374 if (obstack_final_size > statmem_obstack_initial_size)
376 /* In effect, a pop of the printed-statics stack. */
378 = statmem_obstack_initial_size - obstack_final_size;
379 obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
382 if (last_set_recurse != recurse)
385 obstack_object_size (&dont_print_stat_array_obstack);
387 if (obstack_final_size > stat_array_obstack_initial_size)
390 (char *) obstack_next_free (&dont_print_stat_array_obstack)
391 - (obstack_final_size
392 - stat_array_obstack_initial_size);
394 obstack_free (&dont_print_stat_array_obstack,
397 last_set_recurse = -1;
401 if (options->prettyformat)
403 fprintf_filtered (stream, "\n");
404 print_spaces_filtered (2 * recurse, stream);
406 } /* if there are data fields */
408 fprintf_filtered (stream, "}");
411 /* Like cp_print_value_fields, but find the runtime type of the object
412 and pass it as the `real_type' argument to cp_print_value_fields.
413 This function is a hack to work around the fact that
414 common_val_print passes the embedded offset to val_print, but not
415 the enclosing type. */
418 cp_print_value_fields_rtti (struct type *type,
419 const gdb_byte *valaddr, LONGEST offset,
421 struct ui_file *stream, int recurse,
423 const struct value_print_options *options,
424 struct type **dont_print_vb,
425 int dont_print_statmem)
427 struct type *real_type = NULL;
429 /* We require all bits to be valid in order to attempt a
431 if (!value_bits_any_optimized_out (val,
432 TARGET_CHAR_BIT * offset,
433 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
439 /* Ugh, we have to convert back to a value here. */
440 value = value_from_contents_and_address (type, valaddr + offset,
442 type = value_type (value);
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, 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,
463 CORE_ADDR address, struct ui_file *stream,
464 int recurse, 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;
474 const gdb_byte *valaddr = value_contents_for_printing (val);
476 if (dont_print_vb == 0)
478 /* If we're at top level, carve out a completely fresh chunk of
479 the obstack and use that until this particular invocation
481 /* Bump up the high-water mark. Now alpha is omega. */
482 obstack_finish (&dont_print_vb_obstack);
485 for (i = 0; i < n_baseclasses; i++)
489 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
490 const char *basename = TYPE_NAME (baseclass);
491 struct value *base_val = NULL;
493 if (BASETYPE_VIA_VIRTUAL (type, i))
495 struct type **first_dont_print
496 = (struct type **) obstack_base (&dont_print_vb_obstack);
498 int j = (struct type **)
499 obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
502 if (baseclass == first_dont_print[j])
505 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
509 thistype = real_type;
513 boffset = baseclass_offset (type, i, valaddr, offset, address, val);
515 catch (const gdb_exception_RETURN_MASK_ERROR &ex)
517 if (ex.error == NOT_AVAILABLE_ERROR)
525 if (BASETYPE_VIA_VIRTUAL (type, i))
527 /* The virtual base class pointer might have been
528 clobbered by the user program. Make sure that it
529 still points to a valid memory location. */
531 if ((boffset + offset) < 0
532 || (boffset + offset) >= TYPE_LENGTH (real_type))
534 gdb::byte_vector buf (TYPE_LENGTH (baseclass));
536 if (target_read_memory (address + boffset, buf.data (),
537 TYPE_LENGTH (baseclass)) != 0)
539 base_val = value_from_contents_and_address (baseclass,
542 baseclass = value_type (base_val);
545 thistype = baseclass;
558 /* Now do the printing. */
559 if (options->prettyformat)
561 fprintf_filtered (stream, "\n");
562 print_spaces_filtered (2 * recurse, stream);
564 fputs_filtered ("<", stream);
565 /* Not sure what the best notation is in the case where there is
566 no baseclass name. */
567 fputs_filtered (basename ? basename : "", stream);
568 fputs_filtered ("> = ", stream);
571 val_print_unavailable (stream);
573 val_print_invalid_address (stream);
578 /* Attempt to run an extension language pretty-printer on the
579 baseclass if possible. */
582 = apply_ext_lang_val_pretty_printer (baseclass,
583 thisoffset + boffset,
584 value_address (base_val),
590 cp_print_value_fields (baseclass, thistype,
591 thisoffset + boffset,
592 value_address (base_val),
593 stream, recurse, base_val, options,
595 obstack_base (&dont_print_vb_obstack)),
598 fputs_filtered (", ", stream);
604 if (dont_print_vb == 0)
606 /* Free the space used to deal with the printing
607 of this type from top level. */
608 obstack_free (&dont_print_vb_obstack, last_dont_print);
609 /* Reset watermark so that we can continue protecting
610 ourselves from whatever we were protecting ourselves. */
611 dont_print_vb_obstack = tmp_obstack;
615 /* Print value of a static member. To avoid infinite recursion when
616 printing a class that contains a static instance of the class, we
617 keep the addresses of all printed static member classes in an
618 obstack and refuse to print them more than once.
620 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
621 have the same meanings as in c_val_print. */
624 cp_print_static_field (struct type *type,
626 struct ui_file *stream,
628 const struct value_print_options *options)
630 struct value_print_options opts;
632 if (value_entirely_optimized_out (val))
634 val_print_optimized_out (val, stream);
638 struct type *real_type = check_typedef (type);
639 if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
641 CORE_ADDR *first_dont_print;
646 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
647 i = obstack_object_size (&dont_print_statmem_obstack)
648 / sizeof (CORE_ADDR);
652 if (value_address (val) == first_dont_print[i])
654 fputs_filtered ("<same as static member of an already"
661 addr = value_address (val);
662 obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
664 cp_print_value_fields (type, value_enclosing_type (val),
665 value_embedded_offset (val), addr,
666 stream, recurse, val,
671 if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
673 struct type **first_dont_print;
675 struct type *target_type = TYPE_TARGET_TYPE (type);
678 = (struct type **) obstack_base (&dont_print_stat_array_obstack);
679 i = obstack_object_size (&dont_print_stat_array_obstack)
680 / sizeof (struct type *);
684 if (target_type == first_dont_print[i])
686 fputs_filtered ("<same as static member of an already"
693 obstack_grow (&dont_print_stat_array_obstack,
694 (char *) &target_type,
695 sizeof (struct type *));
701 value_embedded_offset (val),
703 stream, recurse, val,
704 &opts, current_language);
707 /* Find the field in *SELF, or its non-virtual base classes, with
708 bit offset OFFSET. Set *SELF to the containing type and *FIELDNO
709 to the containing field number. If OFFSET is not exactly at the
710 start of some field, set *SELF to NULL. */
713 cp_find_class_member (struct type **self_p, int *fieldno,
720 *self_p = check_typedef (*self_p);
722 len = TYPE_NFIELDS (self);
724 for (i = TYPE_N_BASECLASSES (self); i < len; i++)
726 LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
729 if (offset == bitpos)
736 for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
738 LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
739 LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
741 if (offset >= bitpos && offset < bitpos + bitsize)
743 *self_p = TYPE_FIELD_TYPE (self, i);
744 cp_find_class_member (self_p, fieldno, offset - bitpos);
753 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
754 struct ui_file *stream, const char *prefix)
756 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
758 /* VAL is a byte offset into the structure type SELF_TYPE.
759 Find the name of the field for that offset and
761 struct type *self_type = TYPE_SELF_TYPE (type);
765 val = extract_signed_integer (valaddr,
769 /* Pointers to data members are usually byte offsets into an object.
770 Because a data member can have offset zero, and a NULL pointer to
771 member must be distinct from any valid non-NULL pointer to
772 member, either the value is biased or the NULL value has a
773 special representation; both are permitted by ISO C++. HP aCC
774 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
775 and other compilers which use the Itanium ABI use -1 as the NULL
776 value. GDB only supports that last form; to add support for
777 another form, make this into a cp-abi hook. */
781 fprintf_filtered (stream, "NULL");
785 cp_find_class_member (&self_type, &fieldno, val << 3);
787 if (self_type != NULL)
791 fputs_filtered (prefix, stream);
792 name = TYPE_NAME (self_type);
794 fputs_filtered (name, stream);
796 c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
797 fprintf_filtered (stream, "::");
798 fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
801 fprintf_filtered (stream, "%ld", (long) val);
806 _initialize_cp_valprint (void)
808 add_setshow_boolean_cmd ("static-members", class_support,
809 &user_print_options.static_field_print, _("\
810 Set printing of C++ static members."), _("\
811 Show printing of C++ static members."), NULL,
813 show_static_field_print,
814 &setprintlist, &showprintlist);
816 add_setshow_boolean_cmd ("vtbl", class_support,
817 &user_print_options.vtblprint, _("\
818 Set printing of C++ virtual function tables."), _("\
819 Show printing of C++ virtual function tables."), NULL,
822 &setprintlist, &showprintlist);
824 add_setshow_boolean_cmd ("object", class_support,
825 &user_print_options.objectprint, _("\
826 Set printing of object's derived type based on vtable info."), _("\
827 Show printing of object's derived type based on vtable info."), NULL,
830 &setprintlist, &showprintlist);
832 obstack_begin (&dont_print_stat_array_obstack,
833 32 * sizeof (struct type *));
834 obstack_begin (&dont_print_statmem_obstack,
835 32 * sizeof (CORE_ADDR));
836 obstack_begin (&dont_print_vb_obstack,
837 32 * sizeof (struct type *));