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"
41 int vtblprint
; /* Controls printing of vtbl's */
42 int objectprint
; /* Controls looking up an object's derived type
43 using what we find in its vtables. */
44 int static_field_print
; /* Controls printing of static fields. */
46 static struct obstack dont_print_vb_obstack
;
47 static struct obstack dont_print_statmem_obstack
;
49 extern void _initialize_cp_valprint (void);
51 static void cp_print_static_field (struct type
*, struct value
*,
52 struct ui_file
*, int, int,
53 enum val_prettyprint
);
55 static void cp_print_value (struct type
*, struct type
*, const bfd_byte
*,
56 int, CORE_ADDR
, struct ui_file
*, int, int,
57 enum val_prettyprint
, struct type
**);
59 static void cp_print_hpacc_virtual_table_entries (struct type
*, int *,
61 struct ui_file
*, int,
63 enum val_prettyprint
);
67 cp_print_class_method (const bfd_byte
*valaddr
,
69 struct ui_file
*stream
)
72 struct fn_field
*f
= NULL
;
81 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
83 domain
= TYPE_DOMAIN_TYPE (target_type
);
84 if (domain
== (struct type
*) NULL
)
86 fprintf_filtered (stream
, "<unknown>");
89 addr
= unpack_pointer (type
, valaddr
);
90 if (METHOD_PTR_IS_VIRTUAL (addr
))
92 offset
= METHOD_PTR_TO_VOFFSET (addr
);
93 len
= TYPE_NFN_FIELDS (domain
);
94 for (i
= 0; i
< len
; i
++)
96 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
97 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
99 check_stub_method_group (domain
, i
);
100 for (j
= 0; j
< len2
; j
++)
102 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == offset
)
112 sym
= find_pc_function (addr
);
115 /* 1997-08-01 Currently unsupported with HP aCC */
116 if (deprecated_hp_som_som_object_present
)
118 fputs_filtered ("?? <not supported with HP aCC>", stream
);
121 error (_("invalid pointer to member function"));
123 len
= TYPE_NFN_FIELDS (domain
);
124 for (i
= 0; i
< len
; i
++)
126 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
127 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
129 check_stub_method_group (domain
, i
);
130 for (j
= 0; j
< len2
; j
++)
132 if (strcmp (DEPRECATED_SYMBOL_NAME (sym
), TYPE_FN_FIELD_PHYSNAME (f
, j
))
141 char *demangled_name
;
143 fprintf_filtered (stream
, "&");
144 fputs_filtered (kind
, stream
);
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 /* GCC versions after 2.4.5 use this. */
165 const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
167 /* HP aCC uses different names. */
168 const char hpacc_vtbl_ptr_name
[] = "__vfp";
169 const char hpacc_vtbl_ptr_type_name
[] = "__vftyp";
171 /* Return truth value for assertion that TYPE is of the type
172 "pointer to virtual function". */
175 cp_is_vtbl_ptr_type (struct type
*type
)
177 char *typename
= type_name_no_tag (type
);
179 return (typename
!= NULL
&& !strcmp (typename
, vtbl_ptr_name
));
182 /* Return truth value for the assertion that TYPE is of the type
183 "pointer to virtual function table". */
186 cp_is_vtbl_member (struct type
*type
)
188 /* With older versions of g++, the vtbl field pointed to an array
189 of structures. Nowadays it points directly to the structure. */
190 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
192 type
= TYPE_TARGET_TYPE (type
);
193 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
195 type
= TYPE_TARGET_TYPE (type
);
196 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
197 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
199 /* Virtual functions tables are full of pointers
200 to virtual functions. */
201 return cp_is_vtbl_ptr_type (type
);
204 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
206 return cp_is_vtbl_ptr_type (type
);
208 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
210 /* The type name of the thunk pointer is NULL when using dwarf2.
211 We could test for a pointer to a function, but there is
212 no type info for the virtual table either, so it wont help. */
213 return cp_is_vtbl_ptr_type (type
);
219 /* Mutually recursive subroutines of cp_print_value and c_val_print to
220 print out a structure's fields: cp_print_value_fields and cp_print_value.
222 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
223 same meanings as in cp_print_value and c_val_print.
225 2nd argument REAL_TYPE is used to carry over the type of the derived
226 class across the recursion to base classes.
228 DONT_PRINT is an array of baseclass types that we
229 should not print, or zero if called from top level. */
232 cp_print_value_fields (struct type
*type
, struct type
*real_type
,
233 const bfd_byte
*valaddr
, int offset
, CORE_ADDR address
,
234 struct ui_file
*stream
, int format
, int recurse
,
235 enum val_prettyprint pretty
,
236 struct type
**dont_print_vb
,int dont_print_statmem
)
238 int i
, len
, n_baseclasses
;
239 struct obstack tmp_obstack
;
240 char *last_dont_print
= obstack_next_free (&dont_print_statmem_obstack
);
243 CHECK_TYPEDEF (type
);
245 fprintf_filtered (stream
, "{");
246 len
= TYPE_NFIELDS (type
);
247 n_baseclasses
= TYPE_N_BASECLASSES (type
);
249 /* First, print out baseclasses such that we don't print
250 duplicates of virtual baseclasses. */
252 if (n_baseclasses
> 0)
253 cp_print_value (type
, real_type
, valaddr
, offset
, address
, stream
,
254 format
, recurse
+ 1, pretty
, dont_print_vb
);
256 /* Second, print out data fields */
258 /* If there are no data fields, or if the only field is the
259 * vtbl pointer, skip this part */
260 if ((len
== n_baseclasses
)
261 || ((len
- n_baseclasses
== 1)
262 && TYPE_HAS_VTABLE (type
)
263 && strncmp (TYPE_FIELD_NAME (type
, n_baseclasses
),
264 hpacc_vtbl_ptr_name
, 5) == 0)
266 fprintf_filtered (stream
, "<No data fields>");
269 if (dont_print_statmem
== 0)
271 /* If we're at top level, carve out a completely fresh
272 chunk of the obstack and use that until this particular
273 invocation returns. */
274 tmp_obstack
= dont_print_statmem_obstack
;
275 obstack_finish (&dont_print_statmem_obstack
);
278 for (i
= n_baseclasses
; i
< len
; i
++)
280 /* If requested, skip printing of static fields. */
281 if (!static_field_print
&& TYPE_FIELD_STATIC (type
, i
))
284 /* If a vtable pointer appears, we'll print it out later */
285 if (TYPE_HAS_VTABLE (type
)
286 && strncmp (TYPE_FIELD_NAME (type
, i
), hpacc_vtbl_ptr_name
,
291 fprintf_filtered (stream
, ", ");
292 else if (n_baseclasses
> 0)
296 fprintf_filtered (stream
, "\n");
297 print_spaces_filtered (2 + 2 * recurse
, stream
);
298 fputs_filtered ("members of ", stream
);
299 fputs_filtered (type_name_no_tag (type
), stream
);
300 fputs_filtered (": ", stream
);
307 fprintf_filtered (stream
, "\n");
308 print_spaces_filtered (2 + 2 * recurse
, stream
);
312 wrap_here (n_spaces (2 + 2 * recurse
));
316 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
317 fputs_filtered ("\"( ptr \"", stream
);
319 fputs_filtered ("\"( nodef \"", stream
);
320 if (TYPE_FIELD_STATIC (type
, i
))
321 fputs_filtered ("static ", stream
);
322 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
323 current_language
->la_language
,
324 DMGL_PARAMS
| DMGL_ANSI
);
325 fputs_filtered ("\" \"", stream
);
326 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
327 current_language
->la_language
,
328 DMGL_PARAMS
| DMGL_ANSI
);
329 fputs_filtered ("\") \"", stream
);
333 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
335 if (TYPE_FIELD_STATIC (type
, i
))
336 fputs_filtered ("static ", stream
);
337 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
338 current_language
->la_language
,
339 DMGL_PARAMS
| DMGL_ANSI
);
340 annotate_field_name_end ();
341 /* do not print leading '=' in case of anonymous unions */
342 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
343 fputs_filtered (" = ", stream
);
344 annotate_field_value ();
347 if (!TYPE_FIELD_STATIC (type
, i
) && TYPE_FIELD_PACKED (type
, i
))
351 /* Bitfields require special handling, especially due to byte
353 if (TYPE_FIELD_IGNORE (type
, i
))
355 fputs_filtered ("<optimized out or zero length>", stream
);
359 v
= value_from_longest
360 (TYPE_FIELD_TYPE (type
, i
),
361 unpack_field_as_long (type
, valaddr
+ offset
, i
));
363 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
),
364 0, 0, stream
, format
, 0, recurse
+ 1, pretty
);
369 if (TYPE_FIELD_IGNORE (type
, i
))
371 fputs_filtered ("<optimized out or zero length>", stream
);
373 else if (TYPE_FIELD_STATIC (type
, i
))
375 struct value
*v
= value_static_field (type
, i
);
377 fputs_filtered ("<optimized out>", stream
);
379 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
), v
,
380 stream
, format
, recurse
+ 1,
385 val_print (TYPE_FIELD_TYPE (type
, i
),
386 valaddr
, offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
387 address
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
388 stream
, format
, 0, recurse
+ 1, pretty
);
391 annotate_field_end ();
394 if (dont_print_statmem
== 0)
396 /* Free the space used to deal with the printing
397 of the members from top level. */
398 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
399 dont_print_statmem_obstack
= tmp_obstack
;
404 fprintf_filtered (stream
, "\n");
405 print_spaces_filtered (2 * recurse
, stream
);
407 } /* if there are data fields */
408 /* Now print out the virtual table pointer if there is one */
409 if (TYPE_HAS_VTABLE (type
)
410 && strncmp (TYPE_FIELD_NAME (type
, n_baseclasses
),
411 hpacc_vtbl_ptr_name
, 5) == 0)
414 /* First get the virtual table pointer and print it out */
417 fputs_filtered ("__vfp = ", stream
);
420 fputs_filtered (", Virtual table at ", stream
);
422 /* pai: FIXME 32x64 problem? */
423 /* Not sure what the best notation is in the case where there is no
425 v
= value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long
),
426 *(unsigned long *) (valaddr
+ offset
));
428 val_print (value_type (v
), value_contents (v
), 0, 0,
429 stream
, format
, 0, recurse
+ 1, pretty
);
434 /* Print out function pointers in vtable. */
436 /* FIXME: then-clause is for non-RRBC layout of virtual
437 * table. The RRBC case in the else-clause is yet to be
438 * implemented. The if (1) below should be changed to a
439 * test for whether the executable we have was compiled
440 * with a version of HP aCC that doesn't have RRBC
445 /* no RRBC support; function pointers embedded directly
448 int vfuncs
= count_virtual_fns (real_type
);
450 fputs_filtered (" {", stream
);
452 /* FIXME : doesn't work at present */
454 fprintf_filtered (stream
, "%d entr%s: ", vfuncs
,
455 vfuncs
== 1 ? "y" : "ies");
457 fputs_filtered ("not implemented", stream
);
462 /* recursive function that prints all virtual function entries */
464 cp_print_hpacc_virtual_table_entries (real_type
, &vfuncs
, v
,
465 stream
, format
, recurse
,
468 fputs_filtered ("}", stream
);
469 } /* non-RRBC case */
472 /* FIXME -- see comments above */
473 /* RRBC support present; function pointers are found
474 * by indirection through the class segment entries. */
482 fprintf_filtered (stream
, "\n");
483 print_spaces_filtered (2 * recurse
, stream
);
486 } /* if vtable exists */
488 fprintf_filtered (stream
, "}");
491 /* Special val_print routine to avoid printing multiple copies of virtual
495 cp_print_value (struct type
*type
, struct type
*real_type
,
496 const bfd_byte
*valaddr
, int offset
, CORE_ADDR address
,
497 struct ui_file
*stream
, int format
, int recurse
,
498 enum val_prettyprint pretty
, struct type
**dont_print_vb
)
500 struct obstack tmp_obstack
;
501 struct type
**last_dont_print
502 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
503 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
505 struct type
*thistype
;
507 if (dont_print_vb
== 0)
509 /* If we're at top level, carve out a completely fresh
510 chunk of the obstack and use that until this particular
511 invocation returns. */
512 tmp_obstack
= dont_print_vb_obstack
;
513 /* Bump up the high-water mark. Now alpha is omega. */
514 obstack_finish (&dont_print_vb_obstack
);
517 for (i
= 0; i
< n_baseclasses
; i
++)
521 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
522 char *basename
= TYPE_NAME (baseclass
);
523 const bfd_byte
*base_valaddr
;
525 if (BASETYPE_VIA_VIRTUAL (type
, i
))
527 struct type
**first_dont_print
528 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
530 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
534 if (baseclass
== first_dont_print
[j
])
537 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
541 thistype
= real_type
;
542 if (TYPE_HAS_VTABLE (type
) && BASETYPE_VIA_VIRTUAL (type
, i
))
544 /* Assume HP/Taligent runtime convention */
545 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
546 valaddr
, offset
, &boffset
, &skip
);
548 error (_("Virtual base class offset not found from vtable while"
550 base_valaddr
= valaddr
;
554 boffset
= baseclass_offset (type
, i
,
557 skip
= ((boffset
== -1) || (boffset
+ offset
) < 0) ? 1 : -1;
559 if (BASETYPE_VIA_VIRTUAL (type
, i
))
561 /* The virtual base class pointer might have been
562 clobbered by the user program. Make sure that it
563 still points to a valid memory location. */
566 && ((boffset
+ offset
) < 0
567 || (boffset
+ offset
) >= TYPE_LENGTH (type
)))
569 /* FIXME (alloca): unsafe if baseclass is really really large. */
570 bfd_byte
*buf
= alloca (TYPE_LENGTH (baseclass
));
572 if (target_read_memory (address
+ boffset
, buf
,
573 TYPE_LENGTH (baseclass
)) != 0)
575 address
= address
+ boffset
;
578 thistype
= baseclass
;
581 base_valaddr
= valaddr
;
584 base_valaddr
= valaddr
;
587 /* now do the printing */
590 fprintf_filtered (stream
, "\n");
591 print_spaces_filtered (2 * recurse
, stream
);
593 fputs_filtered ("<", stream
);
594 /* Not sure what the best notation is in the case where there is no
596 fputs_filtered (basename
? basename
: "", stream
);
597 fputs_filtered ("> = ", stream
);
601 fprintf_filtered (stream
, "<invalid address>");
603 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
604 thisoffset
+ boffset
, address
+ boffset
,
608 obstack_base (&dont_print_vb_obstack
)),
610 fputs_filtered (", ", stream
);
616 if (dont_print_vb
== 0)
618 /* Free the space used to deal with the printing
619 of this type from top level. */
620 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
621 /* Reset watermark so that we can continue protecting
622 ourselves from whatever we were protecting ourselves. */
623 dont_print_vb_obstack
= tmp_obstack
;
627 /* Print value of a static member.
628 To avoid infinite recursion when printing a class that contains
629 a static instance of the class, we keep the addresses of all printed
630 static member classes in an obstack and refuse to print them more
633 VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
634 have the same meanings as in c_val_print. */
637 cp_print_static_field (struct type
*type
,
639 struct ui_file
*stream
,
642 enum val_prettyprint pretty
)
644 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
646 CORE_ADDR
*first_dont_print
;
650 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
651 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
656 if (VALUE_ADDRESS (val
) == first_dont_print
[i
])
658 fputs_filtered ("<same as static member of an already"
665 obstack_grow (&dont_print_statmem_obstack
, (char *) &VALUE_ADDRESS (val
),
668 CHECK_TYPEDEF (type
);
669 cp_print_value_fields (type
, type
, value_contents_all (val
),
670 value_embedded_offset (val
), VALUE_ADDRESS (val
),
671 stream
, format
, recurse
, pretty
, NULL
, 1);
674 val_print (type
, value_contents_all (val
),
675 value_embedded_offset (val
), VALUE_ADDRESS (val
),
676 stream
, format
, 0, recurse
, pretty
);
680 cp_print_class_member (const bfd_byte
*valaddr
, struct type
*domain
,
681 struct ui_file
*stream
, char *prefix
)
684 /* VAL is a byte offset into the structure type DOMAIN.
685 Find the name of the field for that offset and
690 unsigned len
= TYPE_NFIELDS (domain
);
692 /* @@ Make VAL into bit offset */
694 /* Note: HP aCC generates offsets that are the real byte offsets added
695 to a constant bias 0x20000000 (1 << 29). This constant bias gets
696 shifted out in the code below -- joyous happenstance! */
698 /* Note: HP cfront uses a constant bias of 1; if we support this
699 compiler ever, we will have to adjust the computation below */
701 LONGEST val
= unpack_long (builtin_type_int
, valaddr
) << 3;
702 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
704 int bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
708 if (val
< bitpos
&& i
!= 0)
710 /* Somehow pointing into a field. */
712 extra
= (val
- TYPE_FIELD_BITPOS (domain
, i
));
723 fputs_filtered (prefix
, stream
);
724 name
= type_name_no_tag (domain
);
726 fputs_filtered (name
, stream
);
728 c_type_print_base (domain
, stream
, 0, 0);
729 fprintf_filtered (stream
, "::");
730 fputs_filtered (TYPE_FIELD_NAME (domain
, i
), stream
);
732 fprintf_filtered (stream
, " + %d bytes", extra
);
734 fprintf_filtered (stream
, " (offset in bits)");
737 fprintf_filtered (stream
, "%ld", (long) (val
>> 3));
741 /* This function prints out virtual table entries for a class; it
742 * recurses on the base classes to find all virtual functions
743 * available in a class.
745 * pai/1997-05-21 Note: As the name suggests, it's currently
746 * implemented for HP aCC runtime only. g++ objects are handled
747 * differently and I have made no attempt to fold that logic in
748 * here. The runtime layout is different for the two cases. Also,
749 * this currently has only the code for non-RRBC layouts generated by
750 * the HP aCC compiler; RRBC code is stubbed out and will have to be
755 cp_print_hpacc_virtual_table_entries (struct type
*type
, int *vfuncs
,
756 struct value
*v
, struct ui_file
*stream
,
757 int format
, int recurse
,
758 enum val_prettyprint pretty
)
762 /* pai: FIXME this function doesn't work. It should handle a given
763 * virtual function only once (latest redefinition in class hierarchy)
766 /* Recursion on other classes that can share the same vtable */
767 struct type
*pbc
= primary_base_class (type
);
769 cp_print_hpacc_virtual_table_entries (pbc
, vfuncs
, v
, stream
, format
,
772 /* Now deal with vfuncs declared in this class */
773 for (fn
= 0; fn
< TYPE_NFN_FIELDS (type
); fn
++)
774 for (oi
= 0; oi
< TYPE_FN_FIELDLIST_LENGTH (type
, fn
); oi
++)
775 if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type
, fn
), oi
))
778 const char *field_physname
;
780 /* virtual function offset */
781 int vx
= (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type
, fn
), oi
)
784 /* Get the address of the vfunction entry */
785 struct value
*vf
= value_copy (v
);
787 (void) value_fetch_lazy (vf
);
788 /* adjust by offset */
789 /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
790 value_contents_writeable (vf
)[0] += 4 * (HP_ACC_VFUNC_START
+ vx
);
791 vf
= value_ind (vf
); /* get the entry */
792 /* make it a pointer */
793 deprecated_set_value_type (vf
, value_type (v
));
795 /* print out the entry */
796 val_print (value_type (vf
), value_contents (vf
), 0, 0,
797 stream
, format
, 0, recurse
+ 1, pretty
);
799 = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type
, fn
), oi
);
800 /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
801 vf_name
= cplus_demangle (field_physname
, DMGL_ARM
);
802 fprintf_filtered (stream
, " %s", vf_name
);
804 fputs_filtered (", ", stream
);
811 _initialize_cp_valprint (void)
813 deprecated_add_show_from_set
814 (add_set_cmd ("static-members", class_support
, var_boolean
,
815 (char *) &static_field_print
,
816 "Set printing of C++ static members.",
819 /* Turn on printing of static fields. */
820 static_field_print
= 1;
822 deprecated_add_show_from_set
823 (add_set_cmd ("vtbl", class_support
, var_boolean
, (char *) &vtblprint
,
824 "Set printing of C++ virtual function tables.",
828 deprecated_add_show_from_set
829 (add_set_cmd ("object", class_support
, var_boolean
, (char *) &objectprint
,
830 "Set printing of object's derived type based on vtable info.",
834 /* Give people the defaults which they are used to. */
837 obstack_begin (&dont_print_vb_obstack
, 32 * sizeof (struct type
*));
838 obstack_specify_allocation (&dont_print_statmem_obstack
,
839 32 * sizeof (CORE_ADDR
), sizeof (CORE_ADDR
),