1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 2000, 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_obstack.h"
27 #include "expression.h"
33 #include "gdb_string.h"
39 int vtblprint; /* Controls printing of vtbl's */
40 int objectprint; /* Controls looking up an object's derived type
41 using what we find in its vtables. */
42 int static_field_print; /* Controls printing of static fields. */
44 static struct obstack dont_print_vb_obstack;
45 static struct obstack dont_print_statmem_obstack;
47 extern void _initialize_cp_valprint (void);
49 static void cp_print_static_field (struct type *, struct value *,
50 struct ui_file *, int, int,
51 enum val_prettyprint);
53 static void cp_print_value (struct type *, struct type *, const bfd_byte *,
54 int, CORE_ADDR, struct ui_file *, int, int,
55 enum val_prettyprint, struct type **);
57 static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
59 struct ui_file *, int,
61 enum val_prettyprint);
65 cp_print_class_method (const bfd_byte *valaddr,
67 struct ui_file *stream)
70 struct fn_field *f = NULL;
79 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
81 domain = TYPE_DOMAIN_TYPE (target_type);
82 if (domain == (struct type *) NULL)
84 fprintf_filtered (stream, "<unknown>");
87 addr = unpack_pointer (type, valaddr);
88 if (METHOD_PTR_IS_VIRTUAL (addr))
90 offset = METHOD_PTR_TO_VOFFSET (addr);
91 len = TYPE_NFN_FIELDS (domain);
92 for (i = 0; i < len; i++)
94 f = TYPE_FN_FIELDLIST1 (domain, i);
95 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
97 check_stub_method_group (domain, i);
98 for (j = 0; j < len2; j++)
100 if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
110 sym = find_pc_function (addr);
113 /* 1997-08-01 Currently unsupported with HP aCC */
114 if (deprecated_hp_som_som_object_present)
116 fputs_filtered ("?? <not supported with HP aCC>", stream);
119 error ("invalid pointer to member function");
121 len = TYPE_NFN_FIELDS (domain);
122 for (i = 0; i < len; i++)
124 f = TYPE_FN_FIELDLIST1 (domain, i);
125 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
127 check_stub_method_group (domain, i);
128 for (j = 0; j < len2; j++)
130 if (strcmp (DEPRECATED_SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j))
139 char *demangled_name;
141 fprintf_filtered (stream, "&");
142 fputs_filtered (kind, stream);
143 demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
144 DMGL_ANSI | DMGL_PARAMS);
145 if (demangled_name == NULL)
146 fprintf_filtered (stream, "<badly mangled name %s>",
147 TYPE_FN_FIELD_PHYSNAME (f, j));
150 fputs_filtered (demangled_name, stream);
151 xfree (demangled_name);
156 fprintf_filtered (stream, "(");
157 type_print (type, "", stream, -1);
158 fprintf_filtered (stream, ") %d", (int) addr >> 3);
162 /* GCC versions after 2.4.5 use this. */
163 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
165 /* HP aCC uses different names. */
166 const char hpacc_vtbl_ptr_name[] = "__vfp";
167 const char hpacc_vtbl_ptr_type_name[] = "__vftyp";
169 /* Return truth value for assertion that TYPE is of the type
170 "pointer to virtual function". */
173 cp_is_vtbl_ptr_type (struct type *type)
175 char *typename = type_name_no_tag (type);
177 return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
180 /* Return truth value for the assertion that TYPE is of the type
181 "pointer to virtual function table". */
184 cp_is_vtbl_member (struct type *type)
186 /* With older versions of g++, the vtbl field pointed to an array
187 of structures. Nowadays it points directly to the structure. */
188 if (TYPE_CODE (type) == TYPE_CODE_PTR)
190 type = TYPE_TARGET_TYPE (type);
191 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
193 type = TYPE_TARGET_TYPE (type);
194 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
195 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
197 /* Virtual functions tables are full of pointers
198 to virtual functions. */
199 return cp_is_vtbl_ptr_type (type);
202 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
204 return cp_is_vtbl_ptr_type (type);
206 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
208 /* The type name of the thunk pointer is NULL when using dwarf2.
209 We could test for a pointer to a function, but there is
210 no type info for the virtual table either, so it wont help. */
211 return cp_is_vtbl_ptr_type (type);
217 /* Mutually recursive subroutines of cp_print_value and c_val_print to
218 print out a structure's fields: cp_print_value_fields and cp_print_value.
220 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
221 same meanings as in cp_print_value and c_val_print.
223 2nd argument REAL_TYPE is used to carry over the type of the derived
224 class across the recursion to base classes.
226 DONT_PRINT is an array of baseclass types that we
227 should not print, or zero if called from top level. */
230 cp_print_value_fields (struct type *type, struct type *real_type,
231 const bfd_byte *valaddr, int offset, CORE_ADDR address,
232 struct ui_file *stream, int format, int recurse,
233 enum val_prettyprint pretty,
234 struct type **dont_print_vb,int dont_print_statmem)
236 int i, len, n_baseclasses;
237 struct obstack tmp_obstack;
238 char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
241 CHECK_TYPEDEF (type);
243 fprintf_filtered (stream, "{");
244 len = TYPE_NFIELDS (type);
245 n_baseclasses = TYPE_N_BASECLASSES (type);
247 /* First, print out baseclasses such that we don't print
248 duplicates of virtual baseclasses. */
250 if (n_baseclasses > 0)
251 cp_print_value (type, real_type, valaddr, offset, address, stream,
252 format, recurse + 1, pretty, dont_print_vb);
254 /* Second, print out data fields */
256 /* If there are no data fields, or if the only field is the
257 * vtbl pointer, skip this part */
258 if ((len == n_baseclasses)
259 || ((len - n_baseclasses == 1)
260 && TYPE_HAS_VTABLE (type)
261 && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
262 hpacc_vtbl_ptr_name, 5) == 0)
264 fprintf_filtered (stream, "<No data fields>");
267 if (dont_print_statmem == 0)
269 /* If we're at top level, carve out a completely fresh
270 chunk of the obstack and use that until this particular
271 invocation returns. */
272 tmp_obstack = dont_print_statmem_obstack;
273 obstack_finish (&dont_print_statmem_obstack);
276 for (i = n_baseclasses; i < len; i++)
278 /* If requested, skip printing of static fields. */
279 if (!static_field_print && TYPE_FIELD_STATIC (type, i))
282 /* If a vtable pointer appears, we'll print it out later */
283 if (TYPE_HAS_VTABLE (type)
284 && strncmp (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name,
289 fprintf_filtered (stream, ", ");
290 else if (n_baseclasses > 0)
294 fprintf_filtered (stream, "\n");
295 print_spaces_filtered (2 + 2 * recurse, stream);
296 fputs_filtered ("members of ", stream);
297 fputs_filtered (type_name_no_tag (type), stream);
298 fputs_filtered (": ", stream);
305 fprintf_filtered (stream, "\n");
306 print_spaces_filtered (2 + 2 * recurse, stream);
310 wrap_here (n_spaces (2 + 2 * recurse));
314 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
315 fputs_filtered ("\"( ptr \"", stream);
317 fputs_filtered ("\"( nodef \"", stream);
318 if (TYPE_FIELD_STATIC (type, i))
319 fputs_filtered ("static ", stream);
320 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
322 DMGL_PARAMS | DMGL_ANSI);
323 fputs_filtered ("\" \"", stream);
324 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
326 DMGL_PARAMS | DMGL_ANSI);
327 fputs_filtered ("\") \"", stream);
331 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
333 if (TYPE_FIELD_STATIC (type, i))
334 fputs_filtered ("static ", stream);
335 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
337 DMGL_PARAMS | DMGL_ANSI);
338 annotate_field_name_end ();
339 /* do not print leading '=' in case of anonymous unions */
340 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
341 fputs_filtered (" = ", stream);
342 annotate_field_value ();
345 if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
349 /* Bitfields require special handling, especially due to byte
351 if (TYPE_FIELD_IGNORE (type, i))
353 fputs_filtered ("<optimized out or zero length>", stream);
357 v = value_from_longest
358 (TYPE_FIELD_TYPE (type, i),
359 unpack_field_as_long (type, valaddr + offset, i));
361 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v),
362 0, 0, stream, format, 0, recurse + 1, pretty);
367 if (TYPE_FIELD_IGNORE (type, i))
369 fputs_filtered ("<optimized out or zero length>", stream);
371 else if (TYPE_FIELD_STATIC (type, i))
373 struct value *v = value_static_field (type, i);
375 fputs_filtered ("<optimized out>", stream);
377 cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
378 stream, format, recurse + 1,
383 val_print (TYPE_FIELD_TYPE (type, i),
384 valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
385 address + TYPE_FIELD_BITPOS (type, i) / 8,
386 stream, format, 0, recurse + 1, pretty);
389 annotate_field_end ();
392 if (dont_print_statmem == 0)
394 /* Free the space used to deal with the printing
395 of the members from top level. */
396 obstack_free (&dont_print_statmem_obstack, last_dont_print);
397 dont_print_statmem_obstack = tmp_obstack;
402 fprintf_filtered (stream, "\n");
403 print_spaces_filtered (2 * recurse, stream);
405 } /* if there are data fields */
406 /* Now print out the virtual table pointer if there is one */
407 if (TYPE_HAS_VTABLE (type)
408 && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
409 hpacc_vtbl_ptr_name, 5) == 0)
412 /* First get the virtual table pointer and print it out */
415 fputs_filtered ("__vfp = ", stream);
418 fputs_filtered (", Virtual table at ", stream);
420 /* pai: FIXME 32x64 problem? */
421 /* Not sure what the best notation is in the case where there is no
423 v = value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long),
424 *(unsigned long *) (valaddr + offset));
426 val_print (value_type (v), value_contents (v), 0, 0,
427 stream, format, 0, recurse + 1, pretty);
432 /* Print out function pointers in vtable. */
434 /* FIXME: then-clause is for non-RRBC layout of virtual
435 * table. The RRBC case in the else-clause is yet to be
436 * implemented. The if (1) below should be changed to a
437 * test for whether the executable we have was compiled
438 * with a version of HP aCC that doesn't have RRBC
443 /* no RRBC support; function pointers embedded directly
446 int vfuncs = count_virtual_fns (real_type);
448 fputs_filtered (" {", stream);
450 /* FIXME : doesn't work at present */
452 fprintf_filtered (stream, "%d entr%s: ", vfuncs,
453 vfuncs == 1 ? "y" : "ies");
455 fputs_filtered ("not implemented", stream);
460 /* recursive function that prints all virtual function entries */
462 cp_print_hpacc_virtual_table_entries (real_type, &vfuncs, v,
463 stream, format, recurse,
466 fputs_filtered ("}", stream);
467 } /* non-RRBC case */
470 /* FIXME -- see comments above */
471 /* RRBC support present; function pointers are found
472 * by indirection through the class segment entries. */
480 fprintf_filtered (stream, "\n");
481 print_spaces_filtered (2 * recurse, stream);
484 } /* if vtable exists */
486 fprintf_filtered (stream, "}");
489 /* Special val_print routine to avoid printing multiple copies of virtual
493 cp_print_value (struct type *type, struct type *real_type,
494 const bfd_byte *valaddr, int offset, CORE_ADDR address,
495 struct ui_file *stream, int format, int recurse,
496 enum val_prettyprint pretty, struct type **dont_print_vb)
498 struct obstack tmp_obstack;
499 struct type **last_dont_print
500 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
501 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
503 struct type *thistype;
505 if (dont_print_vb == 0)
507 /* If we're at top level, carve out a completely fresh
508 chunk of the obstack and use that until this particular
509 invocation returns. */
510 tmp_obstack = dont_print_vb_obstack;
511 /* Bump up the high-water mark. Now alpha is omega. */
512 obstack_finish (&dont_print_vb_obstack);
515 for (i = 0; i < n_baseclasses; i++)
519 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
520 char *basename = TYPE_NAME (baseclass);
521 const bfd_byte *base_valaddr;
523 if (BASETYPE_VIA_VIRTUAL (type, i))
525 struct type **first_dont_print
526 = (struct type **) obstack_base (&dont_print_vb_obstack);
528 int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
532 if (baseclass == first_dont_print[j])
535 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
539 thistype = real_type;
540 if (TYPE_HAS_VTABLE (type) && BASETYPE_VIA_VIRTUAL (type, i))
542 /* Assume HP/Taligent runtime convention */
543 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
544 valaddr, offset, &boffset, &skip);
546 error ("Virtual base class offset not found from vtable while"
548 base_valaddr = valaddr;
552 boffset = baseclass_offset (type, i,
555 skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
557 if (BASETYPE_VIA_VIRTUAL (type, i))
559 /* The virtual base class pointer might have been
560 clobbered by the user program. Make sure that it
561 still points to a valid memory location. */
564 && ((boffset + offset) < 0
565 || (boffset + offset) >= TYPE_LENGTH (type)))
567 /* FIXME (alloca): unsafe if baseclass is really really large. */
568 bfd_byte *buf = alloca (TYPE_LENGTH (baseclass));
570 if (target_read_memory (address + boffset, buf,
571 TYPE_LENGTH (baseclass)) != 0)
573 address = address + boffset;
576 thistype = baseclass;
579 base_valaddr = valaddr;
582 base_valaddr = valaddr;
585 /* now do the printing */
588 fprintf_filtered (stream, "\n");
589 print_spaces_filtered (2 * recurse, stream);
591 fputs_filtered ("<", stream);
592 /* Not sure what the best notation is in the case where there is no
594 fputs_filtered (basename ? basename : "", stream);
595 fputs_filtered ("> = ", stream);
599 fprintf_filtered (stream, "<invalid address>");
601 cp_print_value_fields (baseclass, thistype, base_valaddr,
602 thisoffset + boffset, address + boffset,
606 obstack_base (&dont_print_vb_obstack)),
608 fputs_filtered (", ", stream);
614 if (dont_print_vb == 0)
616 /* Free the space used to deal with the printing
617 of this type from top level. */
618 obstack_free (&dont_print_vb_obstack, last_dont_print);
619 /* Reset watermark so that we can continue protecting
620 ourselves from whatever we were protecting ourselves. */
621 dont_print_vb_obstack = tmp_obstack;
625 /* Print value of a static member.
626 To avoid infinite recursion when printing a class that contains
627 a static instance of the class, we keep the addresses of all printed
628 static member classes in an obstack and refuse to print them more
631 VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
632 have the same meanings as in c_val_print. */
635 cp_print_static_field (struct type *type,
637 struct ui_file *stream,
640 enum val_prettyprint pretty)
642 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
644 CORE_ADDR *first_dont_print;
648 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
649 i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
654 if (VALUE_ADDRESS (val) == first_dont_print[i])
656 fputs_filtered ("<same as static member of an already"
663 obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
666 CHECK_TYPEDEF (type);
667 cp_print_value_fields (type, type, value_contents_all (val),
668 value_embedded_offset (val), VALUE_ADDRESS (val),
669 stream, format, recurse, pretty, NULL, 1);
672 val_print (type, value_contents_all (val),
673 value_embedded_offset (val), VALUE_ADDRESS (val),
674 stream, format, 0, recurse, pretty);
678 cp_print_class_member (const bfd_byte *valaddr, struct type *domain,
679 struct ui_file *stream, char *prefix)
682 /* VAL is a byte offset into the structure type DOMAIN.
683 Find the name of the field for that offset and
688 unsigned len = TYPE_NFIELDS (domain);
690 /* @@ Make VAL into bit offset */
692 /* Note: HP aCC generates offsets that are the real byte offsets added
693 to a constant bias 0x20000000 (1 << 29). This constant bias gets
694 shifted out in the code below -- joyous happenstance! */
696 /* Note: HP cfront uses a constant bias of 1; if we support this
697 compiler ever, we will have to adjust the computation below */
699 LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
700 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
702 int bitpos = TYPE_FIELD_BITPOS (domain, i);
706 if (val < bitpos && i != 0)
708 /* Somehow pointing into a field. */
710 extra = (val - TYPE_FIELD_BITPOS (domain, i));
721 fputs_filtered (prefix, stream);
722 name = type_name_no_tag (domain);
724 fputs_filtered (name, stream);
726 c_type_print_base (domain, stream, 0, 0);
727 fprintf_filtered (stream, "::");
728 fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
730 fprintf_filtered (stream, " + %d bytes", extra);
732 fprintf_filtered (stream, " (offset in bits)");
735 fprintf_filtered (stream, "%ld", (long) (val >> 3));
739 /* This function prints out virtual table entries for a class; it
740 * recurses on the base classes to find all virtual functions
741 * available in a class.
743 * pai/1997-05-21 Note: As the name suggests, it's currently
744 * implemented for HP aCC runtime only. g++ objects are handled
745 * differently and I have made no attempt to fold that logic in
746 * here. The runtime layout is different for the two cases. Also,
747 * this currently has only the code for non-RRBC layouts generated by
748 * the HP aCC compiler; RRBC code is stubbed out and will have to be
753 cp_print_hpacc_virtual_table_entries (struct type *type, int *vfuncs,
754 struct value *v, struct ui_file *stream,
755 int format, int recurse,
756 enum val_prettyprint pretty)
760 /* pai: FIXME this function doesn't work. It should handle a given
761 * virtual function only once (latest redefinition in class hierarchy)
764 /* Recursion on other classes that can share the same vtable */
765 struct type *pbc = primary_base_class (type);
767 cp_print_hpacc_virtual_table_entries (pbc, vfuncs, v, stream, format,
770 /* Now deal with vfuncs declared in this class */
771 for (fn = 0; fn < TYPE_NFN_FIELDS (type); fn++)
772 for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (type, fn); oi++)
773 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type, fn), oi))
776 const char *field_physname;
778 /* virtual function offset */
779 int vx = (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type, fn), oi)
782 /* Get the address of the vfunction entry */
783 struct value *vf = value_copy (v);
785 (void) value_fetch_lazy (vf);
786 /* adjust by offset */
787 vf->aligner.contents[0] += 4 * (HP_ACC_VFUNC_START + vx);
788 vf = value_ind (vf); /* get the entry */
789 /* make it a pointer */
790 deprecated_set_value_type (vf, value_type (v));
792 /* print out the entry */
793 val_print (value_type (vf), value_contents (vf), 0, 0,
794 stream, format, 0, recurse + 1, pretty);
796 = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi);
797 /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
798 vf_name = cplus_demangle (field_physname, DMGL_ARM);
799 fprintf_filtered (stream, " %s", vf_name);
801 fputs_filtered (", ", stream);
808 _initialize_cp_valprint (void)
810 deprecated_add_show_from_set
811 (add_set_cmd ("static-members", class_support, var_boolean,
812 (char *) &static_field_print,
813 "Set printing of C++ static members.",
816 /* Turn on printing of static fields. */
817 static_field_print = 1;
819 deprecated_add_show_from_set
820 (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
821 "Set printing of C++ virtual function tables.",
825 deprecated_add_show_from_set
826 (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
827 "Set printing of object's derived type based on vtable info.",
831 /* Give people the defaults which they are used to. */
834 obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
835 obstack_specify_allocation (&dont_print_statmem_obstack,
836 32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),