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"
38 #include "cp-support.h"
40 int vtblprint; /* Controls printing of vtbl's */
41 int objectprint; /* Controls looking up an object's derived type
42 using what we find in its vtables. */
43 int static_field_print; /* Controls printing of static fields. */
45 static struct obstack dont_print_vb_obstack;
46 static struct obstack dont_print_statmem_obstack;
48 extern void _initialize_cp_valprint (void);
50 static void cp_print_static_field (struct type *, struct value *,
51 struct ui_file *, int, int,
52 enum val_prettyprint);
54 static void cp_print_value (struct type *, struct type *, const bfd_byte *,
55 int, CORE_ADDR, struct ui_file *, int, int,
56 enum val_prettyprint, struct type **);
58 static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
60 struct ui_file *, int,
62 enum val_prettyprint);
66 cp_print_class_method (const bfd_byte *valaddr,
68 struct ui_file *stream)
71 struct fn_field *f = NULL;
80 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
82 domain = TYPE_DOMAIN_TYPE (target_type);
83 if (domain == (struct type *) NULL)
85 fprintf_filtered (stream, "<unknown>");
88 addr = unpack_pointer (type, valaddr);
89 if (METHOD_PTR_IS_VIRTUAL (addr))
91 offset = METHOD_PTR_TO_VOFFSET (addr);
92 len = TYPE_NFN_FIELDS (domain);
93 for (i = 0; i < len; i++)
95 f = TYPE_FN_FIELDLIST1 (domain, i);
96 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
98 check_stub_method_group (domain, i);
99 for (j = 0; j < len2; j++)
101 if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
111 sym = find_pc_function (addr);
114 /* 1997-08-01 Currently unsupported with HP aCC */
115 if (deprecated_hp_som_som_object_present)
117 fputs_filtered ("?? <not supported with HP aCC>", stream);
120 error ("invalid pointer to member function");
122 len = TYPE_NFN_FIELDS (domain);
123 for (i = 0; i < len; i++)
125 f = TYPE_FN_FIELDLIST1 (domain, i);
126 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
128 check_stub_method_group (domain, i);
129 for (j = 0; j < len2; j++)
131 if (strcmp (DEPRECATED_SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j))
140 char *demangled_name;
142 fprintf_filtered (stream, "&");
143 fputs_filtered (kind, stream);
144 demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
145 DMGL_ANSI | DMGL_PARAMS);
146 if (demangled_name == NULL)
147 fprintf_filtered (stream, "<badly mangled name %s>",
148 TYPE_FN_FIELD_PHYSNAME (f, j));
151 fputs_filtered (demangled_name, stream);
152 xfree (demangled_name);
157 fprintf_filtered (stream, "(");
158 type_print (type, "", stream, -1);
159 fprintf_filtered (stream, ") %d", (int) addr >> 3);
163 /* GCC versions after 2.4.5 use this. */
164 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
166 /* HP aCC uses different names. */
167 const char hpacc_vtbl_ptr_name[] = "__vfp";
168 const char hpacc_vtbl_ptr_type_name[] = "__vftyp";
170 /* Return truth value for assertion that TYPE is of the type
171 "pointer to virtual function". */
174 cp_is_vtbl_ptr_type (struct type *type)
176 char *typename = type_name_no_tag (type);
178 return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
181 /* Return truth value for the assertion that TYPE is of the type
182 "pointer to virtual function table". */
185 cp_is_vtbl_member (struct type *type)
187 /* With older versions of g++, the vtbl field pointed to an array
188 of structures. Nowadays it points directly to the structure. */
189 if (TYPE_CODE (type) == TYPE_CODE_PTR)
191 type = TYPE_TARGET_TYPE (type);
192 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
194 type = TYPE_TARGET_TYPE (type);
195 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
196 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
198 /* Virtual functions tables are full of pointers
199 to virtual functions. */
200 return cp_is_vtbl_ptr_type (type);
203 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
205 return cp_is_vtbl_ptr_type (type);
207 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
209 /* The type name of the thunk pointer is NULL when using dwarf2.
210 We could test for a pointer to a function, but there is
211 no type info for the virtual table either, so it wont help. */
212 return cp_is_vtbl_ptr_type (type);
218 /* Mutually recursive subroutines of cp_print_value and c_val_print to
219 print out a structure's fields: cp_print_value_fields and cp_print_value.
221 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
222 same meanings as in cp_print_value and c_val_print.
224 2nd argument REAL_TYPE is used to carry over the type of the derived
225 class across the recursion to base classes.
227 DONT_PRINT is an array of baseclass types that we
228 should not print, or zero if called from top level. */
231 cp_print_value_fields (struct type *type, struct type *real_type,
232 const bfd_byte *valaddr, int offset, CORE_ADDR address,
233 struct ui_file *stream, int format, int recurse,
234 enum val_prettyprint pretty,
235 struct type **dont_print_vb,int dont_print_statmem)
237 int i, len, n_baseclasses;
238 struct obstack tmp_obstack;
239 char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
242 CHECK_TYPEDEF (type);
244 fprintf_filtered (stream, "{");
245 len = TYPE_NFIELDS (type);
246 n_baseclasses = TYPE_N_BASECLASSES (type);
248 /* First, print out baseclasses such that we don't print
249 duplicates of virtual baseclasses. */
251 if (n_baseclasses > 0)
252 cp_print_value (type, real_type, valaddr, offset, address, stream,
253 format, recurse + 1, pretty, dont_print_vb);
255 /* Second, print out data fields */
257 /* If there are no data fields, or if the only field is the
258 * vtbl pointer, skip this part */
259 if ((len == n_baseclasses)
260 || ((len - n_baseclasses == 1)
261 && TYPE_HAS_VTABLE (type)
262 && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
263 hpacc_vtbl_ptr_name, 5) == 0)
265 fprintf_filtered (stream, "<No data fields>");
268 if (dont_print_statmem == 0)
270 /* If we're at top level, carve out a completely fresh
271 chunk of the obstack and use that until this particular
272 invocation returns. */
273 tmp_obstack = dont_print_statmem_obstack;
274 obstack_finish (&dont_print_statmem_obstack);
277 for (i = n_baseclasses; i < len; i++)
279 /* If requested, skip printing of static fields. */
280 if (!static_field_print && TYPE_FIELD_STATIC (type, i))
283 /* If a vtable pointer appears, we'll print it out later */
284 if (TYPE_HAS_VTABLE (type)
285 && strncmp (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name,
290 fprintf_filtered (stream, ", ");
291 else if (n_baseclasses > 0)
295 fprintf_filtered (stream, "\n");
296 print_spaces_filtered (2 + 2 * recurse, stream);
297 fputs_filtered ("members of ", stream);
298 fputs_filtered (type_name_no_tag (type), stream);
299 fputs_filtered (": ", stream);
306 fprintf_filtered (stream, "\n");
307 print_spaces_filtered (2 + 2 * recurse, stream);
311 wrap_here (n_spaces (2 + 2 * recurse));
315 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
316 fputs_filtered ("\"( ptr \"", stream);
318 fputs_filtered ("\"( nodef \"", stream);
319 if (TYPE_FIELD_STATIC (type, i))
320 fputs_filtered ("static ", stream);
321 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
323 DMGL_PARAMS | DMGL_ANSI);
324 fputs_filtered ("\" \"", stream);
325 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
327 DMGL_PARAMS | DMGL_ANSI);
328 fputs_filtered ("\") \"", stream);
332 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
334 if (TYPE_FIELD_STATIC (type, i))
335 fputs_filtered ("static ", stream);
336 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
338 DMGL_PARAMS | DMGL_ANSI);
339 annotate_field_name_end ();
340 /* do not print leading '=' in case of anonymous unions */
341 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
342 fputs_filtered (" = ", stream);
343 annotate_field_value ();
346 if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
350 /* Bitfields require special handling, especially due to byte
352 if (TYPE_FIELD_IGNORE (type, i))
354 fputs_filtered ("<optimized out or zero length>", stream);
358 v = value_from_longest
359 (TYPE_FIELD_TYPE (type, i),
360 unpack_field_as_long (type, valaddr + offset, i));
362 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v),
363 0, 0, stream, format, 0, recurse + 1, pretty);
368 if (TYPE_FIELD_IGNORE (type, i))
370 fputs_filtered ("<optimized out or zero length>", stream);
372 else if (TYPE_FIELD_STATIC (type, i))
374 struct value *v = value_static_field (type, i);
376 fputs_filtered ("<optimized out>", stream);
378 cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
379 stream, format, recurse + 1,
384 val_print (TYPE_FIELD_TYPE (type, i),
385 valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
386 address + TYPE_FIELD_BITPOS (type, i) / 8,
387 stream, format, 0, recurse + 1, pretty);
390 annotate_field_end ();
393 if (dont_print_statmem == 0)
395 /* Free the space used to deal with the printing
396 of the members from top level. */
397 obstack_free (&dont_print_statmem_obstack, last_dont_print);
398 dont_print_statmem_obstack = tmp_obstack;
403 fprintf_filtered (stream, "\n");
404 print_spaces_filtered (2 * recurse, stream);
406 } /* if there are data fields */
407 /* Now print out the virtual table pointer if there is one */
408 if (TYPE_HAS_VTABLE (type)
409 && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
410 hpacc_vtbl_ptr_name, 5) == 0)
413 /* First get the virtual table pointer and print it out */
416 fputs_filtered ("__vfp = ", stream);
419 fputs_filtered (", Virtual table at ", stream);
421 /* pai: FIXME 32x64 problem? */
422 /* Not sure what the best notation is in the case where there is no
424 v = value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long),
425 *(unsigned long *) (valaddr + offset));
427 val_print (value_type (v), value_contents (v), 0, 0,
428 stream, format, 0, recurse + 1, pretty);
433 /* Print out function pointers in vtable. */
435 /* FIXME: then-clause is for non-RRBC layout of virtual
436 * table. The RRBC case in the else-clause is yet to be
437 * implemented. The if (1) below should be changed to a
438 * test for whether the executable we have was compiled
439 * with a version of HP aCC that doesn't have RRBC
444 /* no RRBC support; function pointers embedded directly
447 int vfuncs = count_virtual_fns (real_type);
449 fputs_filtered (" {", stream);
451 /* FIXME : doesn't work at present */
453 fprintf_filtered (stream, "%d entr%s: ", vfuncs,
454 vfuncs == 1 ? "y" : "ies");
456 fputs_filtered ("not implemented", stream);
461 /* recursive function that prints all virtual function entries */
463 cp_print_hpacc_virtual_table_entries (real_type, &vfuncs, v,
464 stream, format, recurse,
467 fputs_filtered ("}", stream);
468 } /* non-RRBC case */
471 /* FIXME -- see comments above */
472 /* RRBC support present; function pointers are found
473 * by indirection through the class segment entries. */
481 fprintf_filtered (stream, "\n");
482 print_spaces_filtered (2 * recurse, stream);
485 } /* if vtable exists */
487 fprintf_filtered (stream, "}");
490 /* Special val_print routine to avoid printing multiple copies of virtual
494 cp_print_value (struct type *type, struct type *real_type,
495 const bfd_byte *valaddr, int offset, CORE_ADDR address,
496 struct ui_file *stream, int format, int recurse,
497 enum val_prettyprint pretty, struct type **dont_print_vb)
499 struct obstack tmp_obstack;
500 struct type **last_dont_print
501 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
502 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
504 struct type *thistype;
506 if (dont_print_vb == 0)
508 /* If we're at top level, carve out a completely fresh
509 chunk of the obstack and use that until this particular
510 invocation returns. */
511 tmp_obstack = dont_print_vb_obstack;
512 /* Bump up the high-water mark. Now alpha is omega. */
513 obstack_finish (&dont_print_vb_obstack);
516 for (i = 0; i < n_baseclasses; i++)
520 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
521 char *basename = TYPE_NAME (baseclass);
522 const bfd_byte *base_valaddr;
524 if (BASETYPE_VIA_VIRTUAL (type, i))
526 struct type **first_dont_print
527 = (struct type **) obstack_base (&dont_print_vb_obstack);
529 int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
533 if (baseclass == first_dont_print[j])
536 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
540 thistype = real_type;
541 if (TYPE_HAS_VTABLE (type) && BASETYPE_VIA_VIRTUAL (type, i))
543 /* Assume HP/Taligent runtime convention */
544 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
545 valaddr, offset, &boffset, &skip);
547 error ("Virtual base class offset not found from vtable while"
549 base_valaddr = valaddr;
553 boffset = baseclass_offset (type, i,
556 skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
558 if (BASETYPE_VIA_VIRTUAL (type, i))
560 /* The virtual base class pointer might have been
561 clobbered by the user program. Make sure that it
562 still points to a valid memory location. */
565 && ((boffset + offset) < 0
566 || (boffset + offset) >= TYPE_LENGTH (type)))
568 /* FIXME (alloca): unsafe if baseclass is really really large. */
569 bfd_byte *buf = alloca (TYPE_LENGTH (baseclass));
571 if (target_read_memory (address + boffset, buf,
572 TYPE_LENGTH (baseclass)) != 0)
574 address = address + boffset;
577 thistype = baseclass;
580 base_valaddr = valaddr;
583 base_valaddr = valaddr;
586 /* now do the printing */
589 fprintf_filtered (stream, "\n");
590 print_spaces_filtered (2 * recurse, stream);
592 fputs_filtered ("<", stream);
593 /* Not sure what the best notation is in the case where there is no
595 fputs_filtered (basename ? basename : "", stream);
596 fputs_filtered ("> = ", stream);
600 fprintf_filtered (stream, "<invalid address>");
602 cp_print_value_fields (baseclass, thistype, base_valaddr,
603 thisoffset + boffset, address + boffset,
607 obstack_base (&dont_print_vb_obstack)),
609 fputs_filtered (", ", stream);
615 if (dont_print_vb == 0)
617 /* Free the space used to deal with the printing
618 of this type from top level. */
619 obstack_free (&dont_print_vb_obstack, last_dont_print);
620 /* Reset watermark so that we can continue protecting
621 ourselves from whatever we were protecting ourselves. */
622 dont_print_vb_obstack = tmp_obstack;
626 /* Print value of a static member.
627 To avoid infinite recursion when printing a class that contains
628 a static instance of the class, we keep the addresses of all printed
629 static member classes in an obstack and refuse to print them more
632 VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
633 have the same meanings as in c_val_print. */
636 cp_print_static_field (struct type *type,
638 struct ui_file *stream,
641 enum val_prettyprint pretty)
643 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
645 CORE_ADDR *first_dont_print;
649 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
650 i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
655 if (VALUE_ADDRESS (val) == first_dont_print[i])
657 fputs_filtered ("<same as static member of an already"
664 obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
667 CHECK_TYPEDEF (type);
668 cp_print_value_fields (type, type, value_contents_all (val),
669 value_embedded_offset (val), VALUE_ADDRESS (val),
670 stream, format, recurse, pretty, NULL, 1);
673 val_print (type, value_contents_all (val),
674 value_embedded_offset (val), VALUE_ADDRESS (val),
675 stream, format, 0, recurse, pretty);
679 cp_print_class_member (const bfd_byte *valaddr, struct type *domain,
680 struct ui_file *stream, char *prefix)
683 /* VAL is a byte offset into the structure type DOMAIN.
684 Find the name of the field for that offset and
689 unsigned len = TYPE_NFIELDS (domain);
691 /* @@ Make VAL into bit offset */
693 /* Note: HP aCC generates offsets that are the real byte offsets added
694 to a constant bias 0x20000000 (1 << 29). This constant bias gets
695 shifted out in the code below -- joyous happenstance! */
697 /* Note: HP cfront uses a constant bias of 1; if we support this
698 compiler ever, we will have to adjust the computation below */
700 LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
701 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
703 int bitpos = TYPE_FIELD_BITPOS (domain, i);
707 if (val < bitpos && i != 0)
709 /* Somehow pointing into a field. */
711 extra = (val - TYPE_FIELD_BITPOS (domain, i));
722 fputs_filtered (prefix, stream);
723 name = type_name_no_tag (domain);
725 fputs_filtered (name, stream);
727 c_type_print_base (domain, stream, 0, 0);
728 fprintf_filtered (stream, "::");
729 fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
731 fprintf_filtered (stream, " + %d bytes", extra);
733 fprintf_filtered (stream, " (offset in bits)");
736 fprintf_filtered (stream, "%ld", (long) (val >> 3));
740 /* This function prints out virtual table entries for a class; it
741 * recurses on the base classes to find all virtual functions
742 * available in a class.
744 * pai/1997-05-21 Note: As the name suggests, it's currently
745 * implemented for HP aCC runtime only. g++ objects are handled
746 * differently and I have made no attempt to fold that logic in
747 * here. The runtime layout is different for the two cases. Also,
748 * this currently has only the code for non-RRBC layouts generated by
749 * the HP aCC compiler; RRBC code is stubbed out and will have to be
754 cp_print_hpacc_virtual_table_entries (struct type *type, int *vfuncs,
755 struct value *v, struct ui_file *stream,
756 int format, int recurse,
757 enum val_prettyprint pretty)
761 /* pai: FIXME this function doesn't work. It should handle a given
762 * virtual function only once (latest redefinition in class hierarchy)
765 /* Recursion on other classes that can share the same vtable */
766 struct type *pbc = primary_base_class (type);
768 cp_print_hpacc_virtual_table_entries (pbc, vfuncs, v, stream, format,
771 /* Now deal with vfuncs declared in this class */
772 for (fn = 0; fn < TYPE_NFN_FIELDS (type); fn++)
773 for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (type, fn); oi++)
774 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type, fn), oi))
777 const char *field_physname;
779 /* virtual function offset */
780 int vx = (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type, fn), oi)
783 /* Get the address of the vfunction entry */
784 struct value *vf = value_copy (v);
786 (void) value_fetch_lazy (vf);
787 /* adjust by offset */
788 /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
789 value_contents_writeable (vf)[0] += 4 * (HP_ACC_VFUNC_START + vx);
790 vf = value_ind (vf); /* get the entry */
791 /* make it a pointer */
792 deprecated_set_value_type (vf, value_type (v));
794 /* print out the entry */
795 val_print (value_type (vf), value_contents (vf), 0, 0,
796 stream, format, 0, recurse + 1, pretty);
798 = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi);
799 /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
800 vf_name = cplus_demangle (field_physname, DMGL_ARM);
801 fprintf_filtered (stream, " %s", vf_name);
803 fputs_filtered (", ", stream);
810 _initialize_cp_valprint (void)
812 deprecated_add_show_from_set
813 (add_set_cmd ("static-members", class_support, var_boolean,
814 (char *) &static_field_print,
815 "Set printing of C++ static members.",
818 /* Turn on printing of static fields. */
819 static_field_print = 1;
821 deprecated_add_show_from_set
822 (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
823 "Set printing of C++ virtual function tables.",
827 deprecated_add_show_from_set
828 (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
829 "Set printing of object's derived type based on vtable info.",
833 /* Give people the defaults which they are used to. */
836 obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
837 obstack_specify_allocation (&dont_print_statmem_obstack,
838 32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),