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. */
24 #include "gdb_obstack.h"
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 check_stub_method_group (domain
, i
);
101 for (j
= 0; j
< len2
; j
++)
103 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == offset
)
113 sym
= find_pc_function (addr
);
116 /* 1997-08-01 Currently unsupported with HP aCC */
117 if (hp_som_som_object_present
)
119 fputs_filtered ("?? <not supported with HP aCC>", stream
);
122 error ("invalid pointer to member function");
124 len
= TYPE_NFN_FIELDS (domain
);
125 for (i
= 0; i
< len
; i
++)
127 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
128 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
130 check_stub_method_group (domain
, i
);
131 for (j
= 0; j
< len2
; j
++)
133 if (STREQ (SYMBOL_NAME (sym
), TYPE_FN_FIELD_PHYSNAME (f
, j
)))
141 char *demangled_name
;
143 fprintf_filtered (stream
, "&");
144 fprintf_filtered (stream
, kind
);
145 demangled_name
= cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f
, j
),
146 DMGL_ANSI
| DMGL_PARAMS
);
147 if (demangled_name
== NULL
)
148 fprintf_filtered (stream
, "<badly mangled name %s>",
149 TYPE_FN_FIELD_PHYSNAME (f
, j
));
152 fputs_filtered (demangled_name
, stream
);
153 xfree (demangled_name
);
158 fprintf_filtered (stream
, "(");
159 type_print (type
, "", stream
, -1);
160 fprintf_filtered (stream
, ") %d", (int) addr
>> 3);
164 /* This was what it was for gcc 2.4.5 and earlier. */
165 static const char vtbl_ptr_name_old
[] =
167 CPLUS_MARKER
, 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_',
168 't', 'y', 'p', 'e', 0
171 /* It was changed to this after 2.4.5. */
172 const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
174 /* HP aCC uses different names */
175 const char hpacc_vtbl_ptr_name
[] = "__vfp";
176 const char hpacc_vtbl_ptr_type_name
[] = "__vftyp";
179 /* Return truth value for assertion that TYPE is of the type
180 "pointer to virtual function". */
183 cp_is_vtbl_ptr_type (struct type
*type
)
185 char *typename
= type_name_no_tag (type
);
187 return (typename
!= NULL
188 && (STREQ (typename
, vtbl_ptr_name
)
189 || STREQ (typename
, vtbl_ptr_name_old
)));
192 /* Return truth value for the assertion that TYPE is of the type
193 "pointer to virtual function table". */
196 cp_is_vtbl_member (struct type
*type
)
198 /* With older versions of g++, the vtbl field pointed to an array
199 of structures. Nowadays it points directly to the structure. */
200 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
202 type
= TYPE_TARGET_TYPE (type
);
203 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
205 type
= TYPE_TARGET_TYPE (type
);
206 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
207 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
209 /* Virtual functions tables are full of pointers
210 to virtual functions. */
211 return cp_is_vtbl_ptr_type (type
);
214 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
216 return cp_is_vtbl_ptr_type (type
);
218 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
220 /* The type name of the thunk pointer is NULL when using dwarf2.
221 We could test for a pointer to a function, but there is
222 no type info for the virtual table either, so it wont help. */
223 return cp_is_vtbl_ptr_type (type
);
229 /* Mutually recursive subroutines of cp_print_value and c_val_print to
230 print out a structure's fields: cp_print_value_fields and cp_print_value.
232 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
233 same meanings as in cp_print_value and c_val_print.
235 2nd argument REAL_TYPE is used to carry over the type of the derived
236 class across the recursion to base classes.
238 DONT_PRINT is an array of baseclass types that we
239 should not print, or zero if called from top level. */
242 cp_print_value_fields (struct type
*type
, struct type
*real_type
, char *valaddr
,
243 int offset
, CORE_ADDR address
, struct ui_file
*stream
,
244 int format
, int recurse
, enum val_prettyprint pretty
,
245 struct type
**dont_print_vb
, int dont_print_statmem
)
247 int i
, len
, n_baseclasses
;
248 struct obstack tmp_obstack
;
249 char *last_dont_print
= obstack_next_free (&dont_print_statmem_obstack
);
252 CHECK_TYPEDEF (type
);
254 fprintf_filtered (stream
, "{");
255 len
= TYPE_NFIELDS (type
);
256 n_baseclasses
= TYPE_N_BASECLASSES (type
);
258 /* First, print out baseclasses such that we don't print
259 duplicates of virtual baseclasses. */
261 if (n_baseclasses
> 0)
262 cp_print_value (type
, real_type
, valaddr
, offset
, address
, stream
,
263 format
, recurse
+ 1, pretty
, dont_print_vb
);
265 /* Second, print out data fields */
267 /* If there are no data fields, or if the only field is the
268 * vtbl pointer, skip this part */
269 if ((len
== n_baseclasses
)
270 || ((len
- n_baseclasses
== 1)
271 && TYPE_HAS_VTABLE (type
)
272 && STREQN (TYPE_FIELD_NAME (type
, n_baseclasses
),
273 hpacc_vtbl_ptr_name
, 5))
275 fprintf_filtered (stream
, "<No data fields>");
278 extern int inspect_it
;
280 if (dont_print_statmem
== 0)
282 /* If we're at top level, carve out a completely fresh
283 chunk of the obstack and use that until this particular
284 invocation returns. */
285 tmp_obstack
= dont_print_statmem_obstack
;
286 obstack_finish (&dont_print_statmem_obstack
);
289 for (i
= n_baseclasses
; i
< len
; i
++)
291 /* If requested, skip printing of static fields. */
292 if (!static_field_print
&& TYPE_FIELD_STATIC (type
, i
))
295 /* If a vtable pointer appears, we'll print it out later */
296 if (TYPE_HAS_VTABLE (type
)
297 && STREQN (TYPE_FIELD_NAME (type
, i
), hpacc_vtbl_ptr_name
, 5))
301 fprintf_filtered (stream
, ", ");
302 else if (n_baseclasses
> 0)
306 fprintf_filtered (stream
, "\n");
307 print_spaces_filtered (2 + 2 * recurse
, stream
);
308 fputs_filtered ("members of ", stream
);
309 fputs_filtered (type_name_no_tag (type
), stream
);
310 fputs_filtered (": ", stream
);
317 fprintf_filtered (stream
, "\n");
318 print_spaces_filtered (2 + 2 * recurse
, stream
);
322 wrap_here (n_spaces (2 + 2 * recurse
));
326 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
327 fputs_filtered ("\"( ptr \"", stream
);
329 fputs_filtered ("\"( nodef \"", stream
);
330 if (TYPE_FIELD_STATIC (type
, i
))
331 fputs_filtered ("static ", stream
);
332 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
334 DMGL_PARAMS
| DMGL_ANSI
);
335 fputs_filtered ("\" \"", stream
);
336 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
338 DMGL_PARAMS
| DMGL_ANSI
);
339 fputs_filtered ("\") \"", stream
);
343 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
345 if (TYPE_FIELD_STATIC (type
, i
))
346 fputs_filtered ("static ", stream
);
347 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
349 DMGL_PARAMS
| DMGL_ANSI
);
350 annotate_field_name_end ();
351 /* do not print leading '=' in case of anonymous unions */
352 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
353 fputs_filtered (" = ", stream
);
354 annotate_field_value ();
357 if (!TYPE_FIELD_STATIC (type
, i
) && TYPE_FIELD_PACKED (type
, i
))
361 /* Bitfields require special handling, especially due to byte
363 if (TYPE_FIELD_IGNORE (type
, i
))
365 fputs_filtered ("<optimized out or zero length>", stream
);
369 v
= value_from_longest
370 (TYPE_FIELD_TYPE (type
, i
),
371 unpack_field_as_long (type
, valaddr
+ offset
, i
));
373 val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
),
374 0, 0, stream
, format
, 0, recurse
+ 1, pretty
);
379 if (TYPE_FIELD_IGNORE (type
, i
))
381 fputs_filtered ("<optimized out or zero length>", stream
);
383 else if (TYPE_FIELD_STATIC (type
, i
))
385 struct value
*v
= value_static_field (type
, i
);
387 fputs_filtered ("<optimized out>", stream
);
389 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
), v
,
390 stream
, format
, recurse
+ 1,
395 val_print (TYPE_FIELD_TYPE (type
, i
),
396 valaddr
, offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
397 address
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
398 stream
, format
, 0, recurse
+ 1, pretty
);
401 annotate_field_end ();
404 if (dont_print_statmem
== 0)
406 /* Free the space used to deal with the printing
407 of the members from top level. */
408 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
409 dont_print_statmem_obstack
= tmp_obstack
;
414 fprintf_filtered (stream
, "\n");
415 print_spaces_filtered (2 * recurse
, stream
);
417 } /* if there are data fields */
418 /* Now print out the virtual table pointer if there is one */
419 if (TYPE_HAS_VTABLE (type
)
420 && STREQN (TYPE_FIELD_NAME (type
, n_baseclasses
),
425 /* First get the virtual table pointer and print it out */
428 fputs_filtered ("__vfp = ", stream
);
431 fputs_filtered (", Virtual table at ", stream
);
433 /* pai: FIXME 32x64 problem? */
434 /* Not sure what the best notation is in the case where there is no
436 v
= value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long
),
437 *(unsigned long *) (valaddr
+ offset
));
439 val_print (VALUE_TYPE (v
), VALUE_CONTENTS (v
), 0, 0,
440 stream
, format
, 0, recurse
+ 1, pretty
);
445 /* Print out function pointers in vtable. */
447 /* FIXME: then-clause is for non-RRBC layout of virtual
448 * table. The RRBC case in the else-clause is yet to be
449 * implemented. The if (1) below should be changed to a
450 * test for whether the executable we have was compiled
451 * with a version of HP aCC that doesn't have RRBC
456 /* no RRBC support; function pointers embedded directly
459 int vfuncs
= count_virtual_fns (real_type
);
461 fputs_filtered (" {", stream
);
463 /* FIXME : doesn't work at present */
465 fprintf_filtered (stream
, "%d entr%s: ", vfuncs
,
466 vfuncs
== 1 ? "y" : "ies");
468 fputs_filtered ("not implemented", stream
);
473 /* recursive function that prints all virtual function entries */
475 cp_print_hpacc_virtual_table_entries (real_type
, &vfuncs
, v
,
476 stream
, format
, recurse
,
479 fputs_filtered ("}", stream
);
480 } /* non-RRBC case */
483 /* FIXME -- see comments above */
484 /* RRBC support present; function pointers are found
485 * by indirection through the class segment entries. */
493 fprintf_filtered (stream
, "\n");
494 print_spaces_filtered (2 * recurse
, stream
);
497 } /* if vtable exists */
499 fprintf_filtered (stream
, "}");
502 /* Special val_print routine to avoid printing multiple copies of virtual
506 cp_print_value (struct type
*type
, struct type
*real_type
, char *valaddr
,
507 int offset
, CORE_ADDR address
, struct ui_file
*stream
,
508 int format
, int recurse
, enum val_prettyprint pretty
,
509 struct type
**dont_print_vb
)
511 struct obstack tmp_obstack
;
512 struct type
**last_dont_print
513 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
514 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
516 struct type
*thistype
;
518 if (dont_print_vb
== 0)
520 /* If we're at top level, carve out a completely fresh
521 chunk of the obstack and use that until this particular
522 invocation returns. */
523 tmp_obstack
= dont_print_vb_obstack
;
524 /* Bump up the high-water mark. Now alpha is omega. */
525 obstack_finish (&dont_print_vb_obstack
);
528 for (i
= 0; i
< n_baseclasses
; i
++)
532 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
533 char *basename
= TYPE_NAME (baseclass
);
536 if (BASETYPE_VIA_VIRTUAL (type
, i
))
538 struct type
**first_dont_print
539 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
541 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
545 if (baseclass
== first_dont_print
[j
])
548 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
552 thistype
= real_type
;
553 if (TYPE_HAS_VTABLE (type
) && BASETYPE_VIA_VIRTUAL (type
, i
))
555 /* Assume HP/Taligent runtime convention */
556 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
557 valaddr
, offset
, &boffset
, &skip
);
559 error ("Virtual base class offset not found from vtable while"
561 base_valaddr
= valaddr
;
565 boffset
= baseclass_offset (type
, i
,
568 skip
= ((boffset
== -1) || (boffset
+ offset
) < 0) ? 1 : -1;
570 if (BASETYPE_VIA_VIRTUAL (type
, i
))
572 /* The virtual base class pointer might have been
573 clobbered by the user program. Make sure that it
574 still points to a valid memory location. */
577 && ((boffset
+ offset
) < 0
578 || (boffset
+ offset
) >= TYPE_LENGTH (type
)))
580 /* FIXME (alloca): unsafe if baseclass is really really large. */
581 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
582 if (target_read_memory (address
+ offset
+ boffset
, base_valaddr
,
583 TYPE_LENGTH (baseclass
)) != 0)
587 thistype
= baseclass
;
590 base_valaddr
= valaddr
;
593 base_valaddr
= valaddr
;
596 /* now do the printing */
599 fprintf_filtered (stream
, "\n");
600 print_spaces_filtered (2 * recurse
, stream
);
602 fputs_filtered ("<", stream
);
603 /* Not sure what the best notation is in the case where there is no
605 fputs_filtered (basename
? basename
: "", stream
);
606 fputs_filtered ("> = ", stream
);
610 fprintf_filtered (stream
, "<invalid address>");
612 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
613 thisoffset
+ boffset
, address
, stream
, format
,
616 obstack_base (&dont_print_vb_obstack
)),
618 fputs_filtered (", ", stream
);
624 if (dont_print_vb
== 0)
626 /* Free the space used to deal with the printing
627 of this type from top level. */
628 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
629 /* Reset watermark so that we can continue protecting
630 ourselves from whatever we were protecting ourselves. */
631 dont_print_vb_obstack
= tmp_obstack
;
635 /* Print value of a static member.
636 To avoid infinite recursion when printing a class that contains
637 a static instance of the class, we keep the addresses of all printed
638 static member classes in an obstack and refuse to print them more
641 VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
642 have the same meanings as in c_val_print. */
645 cp_print_static_field (struct type
*type
,
647 struct ui_file
*stream
,
650 enum val_prettyprint pretty
)
652 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
654 CORE_ADDR
*first_dont_print
;
658 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
659 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
664 if (VALUE_ADDRESS (val
) == first_dont_print
[i
])
666 fputs_filtered ("<same as static member of an already"
673 obstack_grow (&dont_print_statmem_obstack
, (char *) &VALUE_ADDRESS (val
),
676 CHECK_TYPEDEF (type
);
677 cp_print_value_fields (type
, type
, VALUE_CONTENTS_ALL (val
),
678 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
679 stream
, format
, recurse
, pretty
, NULL
, 1);
682 val_print (type
, VALUE_CONTENTS_ALL (val
),
683 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
684 stream
, format
, 0, recurse
, pretty
);
688 cp_print_class_member (char *valaddr
, struct type
*domain
,
689 struct ui_file
*stream
, char *prefix
)
692 /* VAL is a byte offset into the structure type DOMAIN.
693 Find the name of the field for that offset and
697 register unsigned int i
;
698 unsigned len
= TYPE_NFIELDS (domain
);
700 /* @@ Make VAL into bit offset */
702 /* Note: HP aCC generates offsets that are the real byte offsets added
703 to a constant bias 0x20000000 (1 << 29). This constant bias gets
704 shifted out in the code below -- joyous happenstance! */
706 /* Note: HP cfront uses a constant bias of 1; if we support this
707 compiler ever, we will have to adjust the computation below */
709 LONGEST val
= unpack_long (builtin_type_int
, valaddr
) << 3;
710 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
712 int bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
716 if (val
< bitpos
&& i
!= 0)
718 /* Somehow pointing into a field. */
720 extra
= (val
- TYPE_FIELD_BITPOS (domain
, i
));
731 fprintf_filtered (stream
, prefix
);
732 name
= type_name_no_tag (domain
);
734 fputs_filtered (name
, stream
);
736 c_type_print_base (domain
, stream
, 0, 0);
737 fprintf_filtered (stream
, "::");
738 fputs_filtered (TYPE_FIELD_NAME (domain
, i
), stream
);
740 fprintf_filtered (stream
, " + %d bytes", extra
);
742 fprintf_filtered (stream
, " (offset in bits)");
745 fprintf_filtered (stream
, "%ld", (long) (val
>> 3));
749 /* This function prints out virtual table entries for a class; it
750 * recurses on the base classes to find all virtual functions
751 * available in a class.
753 * pai/1997-05-21 Note: As the name suggests, it's currently
754 * implemented for HP aCC runtime only. g++ objects are handled
755 * differently and I have made no attempt to fold that logic in
756 * here. The runtime layout is different for the two cases. Also,
757 * this currently has only the code for non-RRBC layouts generated by
758 * the HP aCC compiler; RRBC code is stubbed out and will have to be
763 cp_print_hpacc_virtual_table_entries (struct type
*type
, int *vfuncs
,
764 struct value
*v
, struct ui_file
*stream
,
765 int format
, int recurse
,
766 enum val_prettyprint pretty
)
770 /* pai: FIXME this function doesn't work. It should handle a given
771 * virtual function only once (latest redefinition in class hierarchy)
774 /* Recursion on other classes that can share the same vtable */
775 struct type
*pbc
= primary_base_class (type
);
777 cp_print_hpacc_virtual_table_entries (pbc
, vfuncs
, v
, stream
, format
,
780 /* Now deal with vfuncs declared in this class */
781 for (fn
= 0; fn
< TYPE_NFN_FIELDS (type
); fn
++)
782 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (type
, fn
); oi
++)
783 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type
, fn
), oi
))
786 const char *field_physname
;
788 /* virtual function offset */
789 int vx
= (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type
, fn
), oi
)
792 /* Get the address of the vfunction entry */
793 struct value
*vf
= value_copy (v
);
795 (void) value_fetch_lazy (vf
);
796 /* adjust by offset */
797 vf
->aligner
.contents
[0] += 4 * (HP_ACC_VFUNC_START
+ vx
);
798 vf
= value_ind (vf
); /* get the entry */
799 VALUE_TYPE (vf
) = VALUE_TYPE (v
); /* make it a pointer */
801 /* print out the entry */
802 val_print (VALUE_TYPE (vf
), VALUE_CONTENTS (vf
), 0, 0,
803 stream
, format
, 0, recurse
+ 1, pretty
);
805 = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type
, fn
), oi
);
806 /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
807 vf_name
= cplus_demangle (field_physname
, DMGL_ARM
);
808 fprintf_filtered (stream
, " %s", vf_name
);
810 fputs_filtered (", ", stream
);
817 _initialize_cp_valprint (void)
820 (add_set_cmd ("static-members", class_support
, var_boolean
,
821 (char *) &static_field_print
,
822 "Set printing of C++ static members.",
825 /* Turn on printing of static fields. */
826 static_field_print
= 1;
829 (add_set_cmd ("vtbl", class_support
, var_boolean
, (char *) &vtblprint
,
830 "Set printing of C++ virtual function tables.",
835 (add_set_cmd ("object", class_support
, var_boolean
, (char *) &objectprint
,
836 "Set printing of object's derived type based on vtable info.",
840 /* Give people the defaults which they are used to. */
843 obstack_begin (&dont_print_vb_obstack
, 32 * sizeof (struct type
*));
844 obstack_specify_allocation (&dont_print_statmem_obstack
,
845 32 * sizeof (CORE_ADDR
), sizeof (CORE_ADDR
),