1 /* Support for printing C++ values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 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. */
27 #include "expression.h"
33 #include "gdb_string.h"
38 /* Indication of presence of HP-compiled object files */
39 extern int hp_som_som_object_present; /* defined in symtab.c */
42 int vtblprint; /* Controls printing of vtbl's */
43 int objectprint; /* Controls looking up an object's derived type
44 using what we find in its vtables. */
45 int static_field_print; /* Controls printing of static fields. */
47 static struct obstack dont_print_vb_obstack;
48 static struct obstack dont_print_statmem_obstack;
50 extern void _initialize_cp_valprint (void);
52 static void cp_print_static_field (struct type *, struct value *,
53 struct ui_file *, int, int,
54 enum val_prettyprint);
56 static void cp_print_value (struct type *, struct type *, char *, int,
57 CORE_ADDR, struct ui_file *, int, int,
58 enum val_prettyprint, struct type **);
60 static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
62 struct ui_file *, int,
64 enum val_prettyprint);
68 cp_print_class_method (char *valaddr,
70 struct ui_file *stream)
73 struct fn_field *f = NULL;
82 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
84 domain = TYPE_DOMAIN_TYPE (target_type);
85 if (domain == (struct type *) NULL)
87 fprintf_filtered (stream, "<unknown>");
90 addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
91 if (METHOD_PTR_IS_VIRTUAL (addr))
93 offset = METHOD_PTR_TO_VOFFSET (addr);
94 len = TYPE_NFN_FIELDS (domain);
95 for (i = 0; i < len; i++)
97 f = TYPE_FN_FIELDLIST1 (domain, i);
98 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
100 for (j = 0; j < len2; j++)
103 if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
105 if (TYPE_FN_FIELD_STUB (f, j))
106 check_stub_method (domain, i, j);
115 sym = find_pc_function (addr);
118 /* 1997-08-01 Currently unsupported with HP aCC */
119 if (hp_som_som_object_present)
121 fputs_filtered ("?? <not supported with HP aCC>", stream);
124 error ("invalid pointer to member function");
126 len = TYPE_NFN_FIELDS (domain);
127 for (i = 0; i < len; i++)
129 f = TYPE_FN_FIELDLIST1 (domain, i);
130 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
132 for (j = 0; j < len2; j++)
135 if (TYPE_FN_FIELD_STUB (f, j))
136 check_stub_method (domain, i, j);
137 if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
147 char *demangled_name;
149 fprintf_filtered (stream, "&");
150 fprintf_filtered (stream, kind);
151 demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
152 DMGL_ANSI | DMGL_PARAMS);
153 if (demangled_name == NULL)
154 fprintf_filtered (stream, "<badly mangled name %s>",
155 TYPE_FN_FIELD_PHYSNAME (f, j));
158 fputs_filtered (demangled_name, stream);
159 xfree (demangled_name);
164 fprintf_filtered (stream, "(");
165 type_print (type, "", stream, -1);
166 fprintf_filtered (stream, ") %d", (int) addr >> 3);
170 /* This was what it was for gcc 2.4.5 and earlier. */
171 static const char vtbl_ptr_name_old[] =
173 CPLUS_MARKER, 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_',
174 't', 'y', 'p', 'e', 0
177 /* It was changed to this after 2.4.5. */
178 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
180 /* HP aCC uses different names */
181 const char hpacc_vtbl_ptr_name[] = "__vfp";
182 const char hpacc_vtbl_ptr_type_name[] = "__vftyp";
185 /* Return truth value for assertion that TYPE is of the type
186 "pointer to virtual function". */
189 cp_is_vtbl_ptr_type (struct type *type)
191 char *typename = type_name_no_tag (type);
193 return (typename != NULL
194 && (STREQ (typename, vtbl_ptr_name)
195 || STREQ (typename, vtbl_ptr_name_old)));
198 /* Return truth value for the assertion that TYPE is of the type
199 "pointer to virtual function table". */
202 cp_is_vtbl_member (struct type *type)
204 /* With older versions of g++, the vtbl field pointed to an array
205 of structures. Nowadays it points directly to the structure. */
206 if (TYPE_CODE (type) == TYPE_CODE_PTR)
208 type = TYPE_TARGET_TYPE (type);
209 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
211 type = TYPE_TARGET_TYPE (type);
212 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
213 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
215 /* Virtual functions tables are full of pointers
216 to virtual functions. */
217 return cp_is_vtbl_ptr_type (type);
220 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
222 return cp_is_vtbl_ptr_type (type);
224 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
226 /* The type name of the thunk pointer is NULL when using dwarf2.
227 We could test for a pointer to a function, but there is
228 no type info for the virtual table either, so it wont help. */
229 return cp_is_vtbl_ptr_type (type);
235 /* Mutually recursive subroutines of cp_print_value and c_val_print to
236 print out a structure's fields: cp_print_value_fields and cp_print_value.
238 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
239 same meanings as in cp_print_value and c_val_print.
241 2nd argument REAL_TYPE is used to carry over the type of the derived
242 class across the recursion to base classes.
244 DONT_PRINT is an array of baseclass types that we
245 should not print, or zero if called from top level. */
248 cp_print_value_fields (struct type *type, struct type *real_type, char *valaddr,
249 int offset, CORE_ADDR address, struct ui_file *stream,
250 int format, int recurse, enum val_prettyprint pretty,
251 struct type **dont_print_vb, int dont_print_statmem)
253 int i, len, n_baseclasses;
254 struct obstack tmp_obstack;
255 char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
258 CHECK_TYPEDEF (type);
260 fprintf_filtered (stream, "{");
261 len = TYPE_NFIELDS (type);
262 n_baseclasses = TYPE_N_BASECLASSES (type);
264 /* First, print out baseclasses such that we don't print
265 duplicates of virtual baseclasses. */
267 if (n_baseclasses > 0)
268 cp_print_value (type, real_type, valaddr, offset, address, stream,
269 format, recurse + 1, pretty, dont_print_vb);
271 /* Second, print out data fields */
273 /* If there are no data fields, or if the only field is the
274 * vtbl pointer, skip this part */
275 if ((len == n_baseclasses)
276 || ((len - n_baseclasses == 1)
277 && TYPE_HAS_VTABLE (type)
278 && STREQN (TYPE_FIELD_NAME (type, n_baseclasses),
279 hpacc_vtbl_ptr_name, 5))
281 fprintf_filtered (stream, "<No data fields>");
284 extern int inspect_it;
286 if (dont_print_statmem == 0)
288 /* If we're at top level, carve out a completely fresh
289 chunk of the obstack and use that until this particular
290 invocation returns. */
291 tmp_obstack = dont_print_statmem_obstack;
292 obstack_finish (&dont_print_statmem_obstack);
295 for (i = n_baseclasses; i < len; i++)
297 /* If requested, skip printing of static fields. */
298 if (!static_field_print && TYPE_FIELD_STATIC (type, i))
301 /* If a vtable pointer appears, we'll print it out later */
302 if (TYPE_HAS_VTABLE (type)
303 && STREQN (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name, 5))
307 fprintf_filtered (stream, ", ");
308 else if (n_baseclasses > 0)
312 fprintf_filtered (stream, "\n");
313 print_spaces_filtered (2 + 2 * recurse, stream);
314 fputs_filtered ("members of ", stream);
315 fputs_filtered (type_name_no_tag (type), stream);
316 fputs_filtered (": ", stream);
323 fprintf_filtered (stream, "\n");
324 print_spaces_filtered (2 + 2 * recurse, stream);
328 wrap_here (n_spaces (2 + 2 * recurse));
332 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
333 fputs_filtered ("\"( ptr \"", stream);
335 fputs_filtered ("\"( nodef \"", stream);
336 if (TYPE_FIELD_STATIC (type, i))
337 fputs_filtered ("static ", stream);
338 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
340 DMGL_PARAMS | DMGL_ANSI);
341 fputs_filtered ("\" \"", stream);
342 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
344 DMGL_PARAMS | DMGL_ANSI);
345 fputs_filtered ("\") \"", stream);
349 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
351 if (TYPE_FIELD_STATIC (type, i))
352 fputs_filtered ("static ", stream);
353 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
355 DMGL_PARAMS | DMGL_ANSI);
356 annotate_field_name_end ();
357 /* do not print leading '=' in case of anonymous unions */
358 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
359 fputs_filtered (" = ", stream);
360 annotate_field_value ();
363 if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
367 /* Bitfields require special handling, especially due to byte
369 if (TYPE_FIELD_IGNORE (type, i))
371 fputs_filtered ("<optimized out or zero length>", stream);
375 v = value_from_longest
376 (TYPE_FIELD_TYPE (type, i),
377 unpack_field_as_long (type, valaddr + offset, i));
379 val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v),
380 0, 0, stream, format, 0, recurse + 1, pretty);
385 if (TYPE_FIELD_IGNORE (type, i))
387 fputs_filtered ("<optimized out or zero length>", stream);
389 else if (TYPE_FIELD_STATIC (type, i))
391 struct value *v = value_static_field (type, i);
393 fputs_filtered ("<optimized out>", stream);
395 cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
396 stream, format, recurse + 1,
401 val_print (TYPE_FIELD_TYPE (type, i),
402 valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
403 address + TYPE_FIELD_BITPOS (type, i) / 8,
404 stream, format, 0, recurse + 1, pretty);
407 annotate_field_end ();
410 if (dont_print_statmem == 0)
412 /* Free the space used to deal with the printing
413 of the members from top level. */
414 obstack_free (&dont_print_statmem_obstack, last_dont_print);
415 dont_print_statmem_obstack = tmp_obstack;
420 fprintf_filtered (stream, "\n");
421 print_spaces_filtered (2 * recurse, stream);
423 } /* if there are data fields */
424 /* Now print out the virtual table pointer if there is one */
425 if (TYPE_HAS_VTABLE (type)
426 && STREQN (TYPE_FIELD_NAME (type, n_baseclasses),
431 /* First get the virtual table pointer and print it out */
434 fputs_filtered ("__vfp = ", stream);
437 fputs_filtered (", Virtual table at ", stream);
439 /* pai: FIXME 32x64 problem? */
440 /* Not sure what the best notation is in the case where there is no
442 v = value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long),
443 *(unsigned long *) (valaddr + offset));
445 val_print (VALUE_TYPE (v), VALUE_CONTENTS (v), 0, 0,
446 stream, format, 0, recurse + 1, pretty);
451 /* Print out function pointers in vtable. */
453 /* FIXME: then-clause is for non-RRBC layout of virtual
454 * table. The RRBC case in the else-clause is yet to be
455 * implemented. The if (1) below should be changed to a
456 * test for whether the executable we have was compiled
457 * with a version of HP aCC that doesn't have RRBC
462 /* no RRBC support; function pointers embedded directly
465 int vfuncs = count_virtual_fns (real_type);
467 fputs_filtered (" {", stream);
469 /* FIXME : doesn't work at present */
471 fprintf_filtered (stream, "%d entr%s: ", vfuncs,
472 vfuncs == 1 ? "y" : "ies");
474 fputs_filtered ("not implemented", stream);
479 /* recursive function that prints all virtual function entries */
481 cp_print_hpacc_virtual_table_entries (real_type, &vfuncs, v,
482 stream, format, recurse,
485 fputs_filtered ("}", stream);
486 } /* non-RRBC case */
489 /* FIXME -- see comments above */
490 /* RRBC support present; function pointers are found
491 * by indirection through the class segment entries. */
499 fprintf_filtered (stream, "\n");
500 print_spaces_filtered (2 * recurse, stream);
503 } /* if vtable exists */
505 fprintf_filtered (stream, "}");
508 /* Special val_print routine to avoid printing multiple copies of virtual
512 cp_print_value (struct type *type, struct type *real_type, char *valaddr,
513 int offset, CORE_ADDR address, struct ui_file *stream,
514 int format, int recurse, enum val_prettyprint pretty,
515 struct type **dont_print_vb)
517 struct obstack tmp_obstack;
518 struct type **last_dont_print
519 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
520 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
522 struct type *thistype;
524 if (dont_print_vb == 0)
526 /* If we're at top level, carve out a completely fresh
527 chunk of the obstack and use that until this particular
528 invocation returns. */
529 tmp_obstack = dont_print_vb_obstack;
530 /* Bump up the high-water mark. Now alpha is omega. */
531 obstack_finish (&dont_print_vb_obstack);
534 for (i = 0; i < n_baseclasses; i++)
538 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
539 char *basename = TYPE_NAME (baseclass);
542 if (BASETYPE_VIA_VIRTUAL (type, i))
544 struct type **first_dont_print
545 = (struct type **) obstack_base (&dont_print_vb_obstack);
547 int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
551 if (baseclass == first_dont_print[j])
554 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
558 thistype = real_type;
559 if (TYPE_HAS_VTABLE (type) && BASETYPE_VIA_VIRTUAL (type, i))
561 /* Assume HP/Taligent runtime convention */
562 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
563 valaddr, offset, &boffset, &skip);
565 error ("Virtual base class offset not found from vtable while"
567 base_valaddr = valaddr;
571 boffset = baseclass_offset (type, i,
574 skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
576 if (BASETYPE_VIA_VIRTUAL (type, i))
578 /* The virtual base class pointer might have been
579 clobbered by the user program. Make sure that it
580 still points to a valid memory location. */
583 && ((boffset + offset) < 0
584 || (boffset + offset) >= TYPE_LENGTH (type)))
586 /* FIXME (alloca): unsafe if baseclass is really really large. */
587 base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
588 if (target_read_memory (address + offset + boffset, base_valaddr,
589 TYPE_LENGTH (baseclass)) != 0)
593 thistype = baseclass;
596 base_valaddr = valaddr;
599 base_valaddr = valaddr;
602 /* now do the printing */
605 fprintf_filtered (stream, "\n");
606 print_spaces_filtered (2 * recurse, stream);
608 fputs_filtered ("<", stream);
609 /* Not sure what the best notation is in the case where there is no
611 fputs_filtered (basename ? basename : "", stream);
612 fputs_filtered ("> = ", stream);
616 fprintf_filtered (stream, "<invalid address>");
618 cp_print_value_fields (baseclass, thistype, base_valaddr,
619 thisoffset + boffset, address, stream, format,
622 obstack_base (&dont_print_vb_obstack)),
624 fputs_filtered (", ", stream);
630 if (dont_print_vb == 0)
632 /* Free the space used to deal with the printing
633 of this type from top level. */
634 obstack_free (&dont_print_vb_obstack, last_dont_print);
635 /* Reset watermark so that we can continue protecting
636 ourselves from whatever we were protecting ourselves. */
637 dont_print_vb_obstack = tmp_obstack;
641 /* Print value of a static member.
642 To avoid infinite recursion when printing a class that contains
643 a static instance of the class, we keep the addresses of all printed
644 static member classes in an obstack and refuse to print them more
647 VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
648 have the same meanings as in c_val_print. */
651 cp_print_static_field (struct type *type,
653 struct ui_file *stream,
656 enum val_prettyprint pretty)
658 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
660 CORE_ADDR *first_dont_print;
664 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
665 i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
670 if (VALUE_ADDRESS (val) == first_dont_print[i])
672 fputs_filtered ("<same as static member of an already"
679 obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
682 CHECK_TYPEDEF (type);
683 cp_print_value_fields (type, type, VALUE_CONTENTS_ALL (val),
684 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
685 stream, format, recurse, pretty, NULL, 1);
688 val_print (type, VALUE_CONTENTS_ALL (val),
689 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
690 stream, format, 0, recurse, pretty);
694 cp_print_class_member (char *valaddr, struct type *domain,
695 struct ui_file *stream, char *prefix)
698 /* VAL is a byte offset into the structure type DOMAIN.
699 Find the name of the field for that offset and
703 register unsigned int i;
704 unsigned len = TYPE_NFIELDS (domain);
706 /* @@ Make VAL into bit offset */
708 /* Note: HP aCC generates offsets that are the real byte offsets added
709 to a constant bias 0x20000000 (1 << 29). This constant bias gets
710 shifted out in the code below -- joyous happenstance! */
712 /* Note: HP cfront uses a constant bias of 1; if we support this
713 compiler ever, we will have to adjust the computation below */
715 LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
716 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
718 int bitpos = TYPE_FIELD_BITPOS (domain, i);
722 if (val < bitpos && i != 0)
724 /* Somehow pointing into a field. */
726 extra = (val - TYPE_FIELD_BITPOS (domain, i));
737 fprintf_filtered (stream, prefix);
738 name = type_name_no_tag (domain);
740 fputs_filtered (name, stream);
742 c_type_print_base (domain, stream, 0, 0);
743 fprintf_filtered (stream, "::");
744 fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
746 fprintf_filtered (stream, " + %d bytes", extra);
748 fprintf_filtered (stream, " (offset in bits)");
751 fprintf_filtered (stream, "%ld", (long) (val >> 3));
755 /* This function prints out virtual table entries for a class; it
756 * recurses on the base classes to find all virtual functions
757 * available in a class.
759 * pai/1997-05-21 Note: As the name suggests, it's currently
760 * implemented for HP aCC runtime only. g++ objects are handled
761 * differently and I have made no attempt to fold that logic in
762 * here. The runtime layout is different for the two cases. Also,
763 * this currently has only the code for non-RRBC layouts generated by
764 * the HP aCC compiler; RRBC code is stubbed out and will have to be
769 cp_print_hpacc_virtual_table_entries (struct type *type, int *vfuncs,
770 struct value *v, struct ui_file *stream,
771 int format, int recurse,
772 enum val_prettyprint pretty)
776 /* pai: FIXME this function doesn't work. It should handle a given
777 * virtual function only once (latest redefinition in class hierarchy)
780 /* Recursion on other classes that can share the same vtable */
781 struct type *pbc = primary_base_class (type);
783 cp_print_hpacc_virtual_table_entries (pbc, vfuncs, v, stream, format,
786 /* Now deal with vfuncs declared in this class */
787 for (fn = 0; fn < TYPE_NFN_FIELDS (type); fn++)
788 for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (type, fn); oi++)
789 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type, fn), oi))
792 const char *field_physname;
794 /* virtual function offset */
795 int vx = (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type, fn), oi)
798 /* Get the address of the vfunction entry */
799 struct value *vf = value_copy (v);
801 (void) value_fetch_lazy (vf);
802 /* adjust by offset */
803 vf->aligner.contents[0] += 4 * (HP_ACC_VFUNC_START + vx);
804 vf = value_ind (vf); /* get the entry */
805 VALUE_TYPE (vf) = VALUE_TYPE (v); /* make it a pointer */
807 /* print out the entry */
808 val_print (VALUE_TYPE (vf), VALUE_CONTENTS (vf), 0, 0,
809 stream, format, 0, recurse + 1, pretty);
811 = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi);
812 /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
813 vf_name = cplus_demangle (field_physname, DMGL_ARM);
814 fprintf_filtered (stream, " %s", vf_name);
816 fputs_filtered (", ", stream);
823 _initialize_cp_valprint (void)
826 (add_set_cmd ("static-members", class_support, var_boolean,
827 (char *) &static_field_print,
828 "Set printing of C++ static members.",
831 /* Turn on printing of static fields. */
832 static_field_print = 1;
835 (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
836 "Set printing of C++ virtual function tables.",
841 (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
842 "Set printing of object's derived type based on vtable info.",
846 /* Give people the defaults which they are used to. */
849 obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
850 obstack_specify_allocation (&dont_print_statmem_obstack,
851 32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),