1 /* Support for printing C++ values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_obstack.h"
26 #include "expression.h"
32 #include "gdb_string.h"
37 #include "cp-support.h"
39 #include "python/python.h"
41 /* Controls printing of vtbl's */
43 show_vtblprint (struct ui_file
*file
, int from_tty
,
44 struct cmd_list_element
*c
, const char *value
)
46 fprintf_filtered (file
, _("\
47 Printing of C++ virtual function tables is %s.\n"),
51 /* Controls looking up an object's derived type using what we find in
54 show_objectprint (struct ui_file
*file
, int from_tty
,
55 struct cmd_list_element
*c
,
58 fprintf_filtered (file
, _("\
59 Printing of object's derived type based on vtable info is %s.\n"),
64 show_static_field_print (struct ui_file
*file
, int from_tty
,
65 struct cmd_list_element
*c
, const char *value
)
67 fprintf_filtered (file
, _("Printing of C++ static members is %s.\n"),
72 static struct obstack dont_print_vb_obstack
;
73 static struct obstack dont_print_statmem_obstack
;
75 extern void _initialize_cp_valprint (void);
77 static void cp_print_static_field (struct type
*, struct value
*,
78 struct ui_file
*, int,
79 const struct value_print_options
*);
81 static void cp_print_value (struct type
*, struct type
*, const gdb_byte
*,
82 int, CORE_ADDR
, struct ui_file
*, int,
83 const struct value_print_options
*, struct type
**);
86 /* GCC versions after 2.4.5 use this. */
87 const char vtbl_ptr_name
[] = "__vtbl_ptr_type";
89 /* Return truth value for assertion that TYPE is of the type
90 "pointer to virtual function". */
93 cp_is_vtbl_ptr_type (struct type
*type
)
95 char *typename
= type_name_no_tag (type
);
97 return (typename
!= NULL
&& !strcmp (typename
, vtbl_ptr_name
));
100 /* Return truth value for the assertion that TYPE is of the type
101 "pointer to virtual function table". */
104 cp_is_vtbl_member (struct type
*type
)
106 /* With older versions of g++, the vtbl field pointed to an array
107 of structures. Nowadays it points directly to the structure. */
108 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
110 type
= TYPE_TARGET_TYPE (type
);
111 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
113 type
= TYPE_TARGET_TYPE (type
);
114 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* if not using thunks */
115 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
117 /* Virtual functions tables are full of pointers
118 to virtual functions. */
119 return cp_is_vtbl_ptr_type (type
);
122 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) /* if not using thunks */
124 return cp_is_vtbl_ptr_type (type
);
126 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
) /* if using thunks */
128 /* The type name of the thunk pointer is NULL when using dwarf2.
129 We could test for a pointer to a function, but there is
130 no type info for the virtual table either, so it wont help. */
131 return cp_is_vtbl_ptr_type (type
);
137 /* Mutually recursive subroutines of cp_print_value and c_val_print to
138 print out a structure's fields: cp_print_value_fields and cp_print_value.
140 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
141 same meanings as in cp_print_value and c_val_print.
143 2nd argument REAL_TYPE is used to carry over the type of the derived
144 class across the recursion to base classes.
146 DONT_PRINT is an array of baseclass types that we
147 should not print, or zero if called from top level. */
150 cp_print_value_fields (struct type
*type
, struct type
*real_type
,
151 const gdb_byte
*valaddr
, int offset
, CORE_ADDR address
,
152 struct ui_file
*stream
, int recurse
,
153 const struct value_print_options
*options
,
154 struct type
**dont_print_vb
, int dont_print_statmem
)
156 int i
, len
, n_baseclasses
;
159 CHECK_TYPEDEF (type
);
162 && obstack_object_size (&dont_print_statmem_obstack
) > 0)
163 obstack_free (&dont_print_statmem_obstack
, NULL
);
165 fprintf_filtered (stream
, "{");
166 len
= TYPE_NFIELDS (type
);
167 n_baseclasses
= TYPE_N_BASECLASSES (type
);
169 /* First, print out baseclasses such that we don't print
170 duplicates of virtual baseclasses. */
172 if (n_baseclasses
> 0)
173 cp_print_value (type
, real_type
, valaddr
, offset
, address
, stream
,
174 recurse
+ 1, options
, dont_print_vb
);
176 /* Second, print out data fields */
178 /* If there are no data fields, skip this part */
179 if (len
== n_baseclasses
|| !len
)
180 fprintf_filtered (stream
, "<No data fields>");
183 void *statmem_obstack_top
= NULL
;
185 if (dont_print_statmem
== 0)
187 /* Set the current printed-statics stack top. */
189 = obstack_next_free (&dont_print_statmem_obstack
);
192 for (i
= n_baseclasses
; i
< len
; i
++)
194 /* If requested, skip printing of static fields. */
195 if (!options
->static_field_print
196 && field_is_static (&TYPE_FIELD (type
, i
)))
200 fprintf_filtered (stream
, ", ");
201 else if (n_baseclasses
> 0)
205 fprintf_filtered (stream
, "\n");
206 print_spaces_filtered (2 + 2 * recurse
, stream
);
207 fputs_filtered ("members of ", stream
);
208 fputs_filtered (type_name_no_tag (type
), stream
);
209 fputs_filtered (": ", stream
);
216 fprintf_filtered (stream
, "\n");
217 print_spaces_filtered (2 + 2 * recurse
, stream
);
221 wrap_here (n_spaces (2 + 2 * recurse
));
223 if (options
->inspect_it
)
225 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
226 fputs_filtered ("\"( ptr \"", stream
);
228 fputs_filtered ("\"( nodef \"", stream
);
229 if (field_is_static (&TYPE_FIELD (type
, i
)))
230 fputs_filtered ("static ", stream
);
231 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
232 current_language
->la_language
,
233 DMGL_PARAMS
| DMGL_ANSI
);
234 fputs_filtered ("\" \"", stream
);
235 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
236 current_language
->la_language
,
237 DMGL_PARAMS
| DMGL_ANSI
);
238 fputs_filtered ("\") \"", stream
);
242 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
244 if (field_is_static (&TYPE_FIELD (type
, i
)))
245 fputs_filtered ("static ", stream
);
246 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
247 current_language
->la_language
,
248 DMGL_PARAMS
| DMGL_ANSI
);
249 annotate_field_name_end ();
250 /* do not print leading '=' in case of anonymous unions */
251 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
252 fputs_filtered (" = ", stream
);
253 annotate_field_value ();
256 if (!field_is_static (&TYPE_FIELD (type
, i
))
257 && TYPE_FIELD_PACKED (type
, i
))
261 /* Bitfields require special handling, especially due to byte
263 if (TYPE_FIELD_IGNORE (type
, i
))
265 fputs_filtered ("<optimized out or zero length>", stream
);
269 struct value_print_options opts
= *options
;
271 v
= value_from_longest
272 (TYPE_FIELD_TYPE (type
, i
),
273 unpack_field_as_long (type
, valaddr
+ offset
, i
));
275 common_val_print (v
, stream
, recurse
+ 1, &opts
,
281 if (TYPE_FIELD_IGNORE (type
, i
))
283 fputs_filtered ("<optimized out or zero length>", stream
);
285 else if (field_is_static (&TYPE_FIELD (type
, i
)))
287 struct value
*v
= value_static_field (type
, i
);
289 fputs_filtered ("<optimized out>", stream
);
291 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
), v
,
292 stream
, recurse
+ 1, options
);
296 struct value_print_options opts
= *options
;
298 val_print (TYPE_FIELD_TYPE (type
, i
),
299 valaddr
, offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
301 stream
, recurse
+ 1, &opts
,
305 annotate_field_end ();
308 if (dont_print_statmem
== 0)
310 /* In effect, a pop of the printed-statics stack. */
311 if (obstack_object_size (&dont_print_statmem_obstack
) > 0)
312 obstack_free (&dont_print_statmem_obstack
, statmem_obstack_top
);
317 fprintf_filtered (stream
, "\n");
318 print_spaces_filtered (2 * recurse
, stream
);
320 } /* if there are data fields */
322 fprintf_filtered (stream
, "}");
325 /* Like cp_print_value_fields, but find the runtime type of the object
326 and pass it as the `real_type' argument to cp_print_value_fields.
327 This function is a hack to work around the fact that
328 common_val_print passes the embedded offset to val_print, but not
329 the enclosing type. */
332 cp_print_value_fields_rtti (struct type
*type
,
333 const gdb_byte
*valaddr
, int offset
,
335 struct ui_file
*stream
, int recurse
,
336 const struct value_print_options
*options
,
337 struct type
**dont_print_vb
, int dont_print_statmem
)
340 int full
, top
, using_enc
;
341 struct type
*real_type
;
343 /* Ugh, we have to convert back to a value here. */
344 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
346 /* We don't actually care about most of the result here -- just the
347 type. We already have the correct offset, due to how val_print
348 was initially called. */
349 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
353 cp_print_value_fields (type
, real_type
, valaddr
, offset
,
354 address
, stream
, recurse
, options
,
355 dont_print_vb
, dont_print_statmem
);
358 /* Special val_print routine to avoid printing multiple copies of virtual
362 cp_print_value (struct type
*type
, struct type
*real_type
,
363 const gdb_byte
*valaddr
, int offset
, CORE_ADDR address
,
364 struct ui_file
*stream
, int recurse
,
365 const struct value_print_options
*options
,
366 struct type
**dont_print_vb
)
368 struct type
**last_dont_print
369 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
370 struct obstack tmp_obstack
= dont_print_vb_obstack
;
371 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
373 struct type
*thistype
;
375 if (dont_print_vb
== 0)
377 /* If we're at top level, carve out a completely fresh
378 chunk of the obstack and use that until this particular
379 invocation returns. */
380 /* Bump up the high-water mark. Now alpha is omega. */
381 obstack_finish (&dont_print_vb_obstack
);
384 for (i
= 0; i
< n_baseclasses
; i
++)
388 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
389 char *basename
= TYPE_NAME (baseclass
);
390 const gdb_byte
*base_valaddr
;
392 if (BASETYPE_VIA_VIRTUAL (type
, i
))
394 struct type
**first_dont_print
395 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
397 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
401 if (baseclass
== first_dont_print
[j
])
404 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
408 thistype
= real_type
;
410 boffset
= baseclass_offset (type
, i
, valaddr
+ offset
, address
+ offset
);
411 skip
= ((boffset
== -1) || (boffset
+ offset
) < 0) ? 1 : -1;
413 if (BASETYPE_VIA_VIRTUAL (type
, i
))
415 /* The virtual base class pointer might have been
416 clobbered by the user program. Make sure that it
417 still points to a valid memory location. */
420 && ((boffset
+ offset
) < 0
421 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
)))
423 /* FIXME (alloca): unsafe if baseclass is really really large. */
424 gdb_byte
*buf
= alloca (TYPE_LENGTH (baseclass
));
426 if (target_read_memory (address
+ boffset
, buf
,
427 TYPE_LENGTH (baseclass
)) != 0)
429 address
= address
+ boffset
;
432 thistype
= baseclass
;
435 base_valaddr
= valaddr
;
438 base_valaddr
= valaddr
;
440 /* now do the printing */
443 fprintf_filtered (stream
, "\n");
444 print_spaces_filtered (2 * recurse
, stream
);
446 fputs_filtered ("<", stream
);
447 /* Not sure what the best notation is in the case where there is no
449 fputs_filtered (basename
? basename
: "", stream
);
450 fputs_filtered ("> = ", stream
);
454 fprintf_filtered (stream
, "<invalid address>");
459 /* Attempt to run the Python pretty-printers on the
460 baseclass if possible. */
462 result
= apply_val_pretty_printer (baseclass
, base_valaddr
,
463 thisoffset
+ boffset
,
470 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
471 thisoffset
+ boffset
, address
,
472 stream
, recurse
, options
,
474 obstack_base (&dont_print_vb_obstack
)),
477 fputs_filtered (", ", stream
);
483 if (dont_print_vb
== 0)
485 /* Free the space used to deal with the printing
486 of this type from top level. */
487 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
488 /* Reset watermark so that we can continue protecting
489 ourselves from whatever we were protecting ourselves. */
490 dont_print_vb_obstack
= tmp_obstack
;
494 /* Print value of a static member.
495 To avoid infinite recursion when printing a class that contains
496 a static instance of the class, we keep the addresses of all printed
497 static member classes in an obstack and refuse to print them more
500 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
501 have the same meanings as in c_val_print. */
504 cp_print_static_field (struct type
*type
,
506 struct ui_file
*stream
,
508 const struct value_print_options
*options
)
510 struct value_print_options opts
;
511 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
513 CORE_ADDR
*first_dont_print
;
518 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
519 i
= obstack_object_size (&dont_print_statmem_obstack
)
520 / sizeof (CORE_ADDR
);
524 if (value_address (val
) == first_dont_print
[i
])
526 fputs_filtered ("<same as static member of an already"
533 addr
= value_address (val
);
534 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
537 CHECK_TYPEDEF (type
);
538 cp_print_value_fields (type
, value_enclosing_type (val
),
539 value_contents_all (val
),
540 value_embedded_offset (val
), addr
,
541 stream
, recurse
, options
, NULL
, 1);
547 val_print (type
, value_contents_all (val
),
548 value_embedded_offset (val
), value_address (val
),
549 stream
, recurse
, &opts
, current_language
);
553 /* Find the field in *DOMAIN, or its non-virtual base classes, with bit offset
554 OFFSET. Set *DOMAIN to the containing type and *FIELDNO to the containing
555 field number. If OFFSET is not exactly at the start of some field, set
559 cp_find_class_member (struct type
**domain_p
, int *fieldno
,
566 *domain_p
= check_typedef (*domain_p
);
568 len
= TYPE_NFIELDS (domain
);
570 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
572 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
575 if (offset
== bitpos
)
582 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
584 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
585 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain
, i
));
587 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
589 *domain_p
= TYPE_FIELD_TYPE (domain
, i
);
590 cp_find_class_member (domain_p
, fieldno
, offset
- bitpos
);
599 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
600 struct ui_file
*stream
, char *prefix
)
602 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
604 /* VAL is a byte offset into the structure type DOMAIN.
605 Find the name of the field for that offset and
607 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
609 unsigned int fieldno
;
611 val
= extract_signed_integer (valaddr
, TYPE_LENGTH (type
), byte_order
);
613 /* Pointers to data members are usually byte offsets into an object.
614 Because a data member can have offset zero, and a NULL pointer to
615 member must be distinct from any valid non-NULL pointer to
616 member, either the value is biased or the NULL value has a
617 special representation; both are permitted by ISO C++. HP aCC
618 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
619 and other compilers which use the Itanium ABI use -1 as the NULL
620 value. GDB only supports that last form; to add support for
621 another form, make this into a cp-abi hook. */
625 fprintf_filtered (stream
, "NULL");
629 cp_find_class_member (&domain
, &fieldno
, val
<< 3);
634 fputs_filtered (prefix
, stream
);
635 name
= type_name_no_tag (domain
);
637 fputs_filtered (name
, stream
);
639 c_type_print_base (domain
, stream
, 0, 0);
640 fprintf_filtered (stream
, "::");
641 fputs_filtered (TYPE_FIELD_NAME (domain
, fieldno
), stream
);
644 fprintf_filtered (stream
, "%ld", (long) val
);
649 _initialize_cp_valprint (void)
651 add_setshow_boolean_cmd ("static-members", class_support
,
652 &user_print_options
.static_field_print
, _("\
653 Set printing of C++ static members."), _("\
654 Show printing of C++ static members."), NULL
,
656 show_static_field_print
,
657 &setprintlist
, &showprintlist
);
659 add_setshow_boolean_cmd ("vtbl", class_support
,
660 &user_print_options
.vtblprint
, _("\
661 Set printing of C++ virtual function tables."), _("\
662 Show printing of C++ virtual function tables."), NULL
,
665 &setprintlist
, &showprintlist
);
667 add_setshow_boolean_cmd ("object", class_support
,
668 &user_print_options
.objectprint
, _("\
669 Set printing of object's derived type based on vtable info."), _("\
670 Show printing of object's derived type based on vtable info."), NULL
,
673 &setprintlist
, &showprintlist
);
675 obstack_begin (&dont_print_statmem_obstack
, 32 * sizeof (CORE_ADDR
));
676 obstack_begin (&dont_print_vb_obstack
, 32 * sizeof (struct type
*));