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
;
157 char *last_dont_print
= obstack_next_free (&dont_print_statmem_obstack
);
160 CHECK_TYPEDEF (type
);
162 fprintf_filtered (stream
, "{");
163 len
= TYPE_NFIELDS (type
);
164 n_baseclasses
= TYPE_N_BASECLASSES (type
);
166 /* First, print out baseclasses such that we don't print
167 duplicates of virtual baseclasses. */
169 if (n_baseclasses
> 0)
170 cp_print_value (type
, real_type
, valaddr
, offset
, address
, stream
,
171 recurse
+ 1, options
, dont_print_vb
);
173 /* Second, print out data fields */
175 /* If there are no data fields, skip this part */
176 if (len
== n_baseclasses
|| !len
)
177 fprintf_filtered (stream
, "<No data fields>");
180 struct obstack tmp_obstack
= dont_print_statmem_obstack
;
182 if (dont_print_statmem
== 0)
184 /* If we're at top level, carve out a completely fresh
185 chunk of the obstack and use that until this particular
186 invocation returns. */
187 obstack_finish (&dont_print_statmem_obstack
);
190 for (i
= n_baseclasses
; i
< len
; i
++)
192 /* If requested, skip printing of static fields. */
193 if (!options
->static_field_print
194 && field_is_static (&TYPE_FIELD (type
, i
)))
198 fprintf_filtered (stream
, ", ");
199 else if (n_baseclasses
> 0)
203 fprintf_filtered (stream
, "\n");
204 print_spaces_filtered (2 + 2 * recurse
, stream
);
205 fputs_filtered ("members of ", stream
);
206 fputs_filtered (type_name_no_tag (type
), stream
);
207 fputs_filtered (": ", stream
);
214 fprintf_filtered (stream
, "\n");
215 print_spaces_filtered (2 + 2 * recurse
, stream
);
219 wrap_here (n_spaces (2 + 2 * recurse
));
221 if (options
->inspect_it
)
223 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
224 fputs_filtered ("\"( ptr \"", stream
);
226 fputs_filtered ("\"( nodef \"", stream
);
227 if (field_is_static (&TYPE_FIELD (type
, i
)))
228 fputs_filtered ("static ", stream
);
229 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
230 current_language
->la_language
,
231 DMGL_PARAMS
| DMGL_ANSI
);
232 fputs_filtered ("\" \"", stream
);
233 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
234 current_language
->la_language
,
235 DMGL_PARAMS
| DMGL_ANSI
);
236 fputs_filtered ("\") \"", stream
);
240 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
242 if (field_is_static (&TYPE_FIELD (type
, i
)))
243 fputs_filtered ("static ", stream
);
244 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
245 current_language
->la_language
,
246 DMGL_PARAMS
| DMGL_ANSI
);
247 annotate_field_name_end ();
248 /* do not print leading '=' in case of anonymous unions */
249 if (strcmp (TYPE_FIELD_NAME (type
, i
), ""))
250 fputs_filtered (" = ", stream
);
251 annotate_field_value ();
254 if (!field_is_static (&TYPE_FIELD (type
, i
))
255 && TYPE_FIELD_PACKED (type
, i
))
259 /* Bitfields require special handling, especially due to byte
261 if (TYPE_FIELD_IGNORE (type
, i
))
263 fputs_filtered ("<optimized out or zero length>", stream
);
267 struct value_print_options opts
= *options
;
269 v
= value_from_longest
270 (TYPE_FIELD_TYPE (type
, i
),
271 unpack_field_as_long (type
, valaddr
+ offset
, i
));
273 common_val_print (v
, stream
, recurse
+ 1, &opts
,
279 if (TYPE_FIELD_IGNORE (type
, i
))
281 fputs_filtered ("<optimized out or zero length>", stream
);
283 else if (field_is_static (&TYPE_FIELD (type
, i
)))
285 struct value
*v
= value_static_field (type
, i
);
287 fputs_filtered ("<optimized out>", stream
);
289 cp_print_static_field (TYPE_FIELD_TYPE (type
, i
), v
,
290 stream
, recurse
+ 1, options
);
294 struct value_print_options opts
= *options
;
296 val_print (TYPE_FIELD_TYPE (type
, i
),
297 valaddr
, offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
299 stream
, recurse
+ 1, &opts
,
303 annotate_field_end ();
306 if (dont_print_statmem
== 0)
308 /* Free the space used to deal with the printing
309 of the members from top level. */
310 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
311 dont_print_statmem_obstack
= tmp_obstack
;
316 fprintf_filtered (stream
, "\n");
317 print_spaces_filtered (2 * recurse
, stream
);
319 } /* if there are data fields */
321 fprintf_filtered (stream
, "}");
324 /* Like cp_print_value_fields, but find the runtime type of the object
325 and pass it as the `real_type' argument to cp_print_value_fields.
326 This function is a hack to work around the fact that
327 common_val_print passes the embedded offset to val_print, but not
328 the enclosing type. */
331 cp_print_value_fields_rtti (struct type
*type
,
332 const gdb_byte
*valaddr
, int offset
,
334 struct ui_file
*stream
, int recurse
,
335 const struct value_print_options
*options
,
336 struct type
**dont_print_vb
, int dont_print_statmem
)
339 int full
, top
, using_enc
;
340 struct type
*real_type
;
342 /* Ugh, we have to convert back to a value here. */
343 value
= value_from_contents_and_address (type
, valaddr
+ offset
,
345 /* We don't actually care about most of the result here -- just the
346 type. We already have the correct offset, due to how val_print
347 was initially called. */
348 real_type
= value_rtti_type (value
, &full
, &top
, &using_enc
);
352 cp_print_value_fields (type
, real_type
, valaddr
, offset
,
353 address
, stream
, recurse
, options
,
354 dont_print_vb
, dont_print_statmem
);
357 /* Special val_print routine to avoid printing multiple copies of virtual
361 cp_print_value (struct type
*type
, struct type
*real_type
,
362 const gdb_byte
*valaddr
, int offset
, CORE_ADDR address
,
363 struct ui_file
*stream
, int recurse
,
364 const struct value_print_options
*options
,
365 struct type
**dont_print_vb
)
367 struct type
**last_dont_print
368 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
369 struct obstack tmp_obstack
= dont_print_vb_obstack
;
370 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
372 struct type
*thistype
;
374 if (dont_print_vb
== 0)
376 /* If we're at top level, carve out a completely fresh
377 chunk of the obstack and use that until this particular
378 invocation returns. */
379 /* Bump up the high-water mark. Now alpha is omega. */
380 obstack_finish (&dont_print_vb_obstack
);
383 for (i
= 0; i
< n_baseclasses
; i
++)
387 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
388 char *basename
= TYPE_NAME (baseclass
);
389 const gdb_byte
*base_valaddr
;
391 if (BASETYPE_VIA_VIRTUAL (type
, i
))
393 struct type
**first_dont_print
394 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
396 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
400 if (baseclass
== first_dont_print
[j
])
403 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
407 thistype
= real_type
;
409 boffset
= baseclass_offset (type
, i
, valaddr
+ offset
, address
+ offset
);
410 skip
= ((boffset
== -1) || (boffset
+ offset
) < 0) ? 1 : -1;
412 if (BASETYPE_VIA_VIRTUAL (type
, i
))
414 /* The virtual base class pointer might have been
415 clobbered by the user program. Make sure that it
416 still points to a valid memory location. */
419 && ((boffset
+ offset
) < 0
420 || (boffset
+ offset
) >= TYPE_LENGTH (real_type
)))
422 /* FIXME (alloca): unsafe if baseclass is really really large. */
423 gdb_byte
*buf
= alloca (TYPE_LENGTH (baseclass
));
425 if (target_read_memory (address
+ boffset
, buf
,
426 TYPE_LENGTH (baseclass
)) != 0)
428 address
= address
+ boffset
;
431 thistype
= baseclass
;
434 base_valaddr
= valaddr
;
437 base_valaddr
= valaddr
;
439 /* now do the printing */
442 fprintf_filtered (stream
, "\n");
443 print_spaces_filtered (2 * recurse
, stream
);
445 fputs_filtered ("<", stream
);
446 /* Not sure what the best notation is in the case where there is no
448 fputs_filtered (basename
? basename
: "", stream
);
449 fputs_filtered ("> = ", stream
);
453 fprintf_filtered (stream
, "<invalid address>");
458 /* Attempt to run the Python pretty-printers on the
459 baseclass if possible. */
461 result
= apply_val_pretty_printer (baseclass
, base_valaddr
,
462 thisoffset
+ boffset
,
469 cp_print_value_fields (baseclass
, thistype
, base_valaddr
,
470 thisoffset
+ boffset
, address
,
471 stream
, recurse
, options
,
473 obstack_base (&dont_print_vb_obstack
)),
476 fputs_filtered (", ", stream
);
482 if (dont_print_vb
== 0)
484 /* Free the space used to deal with the printing
485 of this type from top level. */
486 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
487 /* Reset watermark so that we can continue protecting
488 ourselves from whatever we were protecting ourselves. */
489 dont_print_vb_obstack
= tmp_obstack
;
493 /* Print value of a static member.
494 To avoid infinite recursion when printing a class that contains
495 a static instance of the class, we keep the addresses of all printed
496 static member classes in an obstack and refuse to print them more
499 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
500 have the same meanings as in c_val_print. */
503 cp_print_static_field (struct type
*type
,
505 struct ui_file
*stream
,
507 const struct value_print_options
*options
)
509 struct value_print_options opts
;
510 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
512 CORE_ADDR
*first_dont_print
;
517 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
518 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
523 if (value_address (val
) == first_dont_print
[i
])
525 fputs_filtered ("<same as static member of an already"
532 addr
= value_address (val
);
533 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
536 CHECK_TYPEDEF (type
);
537 cp_print_value_fields (type
, value_enclosing_type (val
),
538 value_contents_all (val
),
539 value_embedded_offset (val
), addr
,
540 stream
, recurse
, options
, NULL
, 1);
546 val_print (type
, value_contents_all (val
),
547 value_embedded_offset (val
), value_address (val
),
548 stream
, recurse
, &opts
, current_language
);
552 /* Find the field in *DOMAIN, or its non-virtual base classes, with bit offset
553 OFFSET. Set *DOMAIN to the containing type and *FIELDNO to the containing
554 field number. If OFFSET is not exactly at the start of some field, set
558 cp_find_class_member (struct type
**domain_p
, int *fieldno
,
565 *domain_p
= check_typedef (*domain_p
);
567 len
= TYPE_NFIELDS (domain
);
569 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
571 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
574 if (offset
== bitpos
)
581 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
583 LONGEST bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
584 LONGEST bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain
, i
));
586 if (offset
>= bitpos
&& offset
< bitpos
+ bitsize
)
588 *domain_p
= TYPE_FIELD_TYPE (domain
, i
);
589 cp_find_class_member (domain_p
, fieldno
, offset
- bitpos
);
598 cp_print_class_member (const gdb_byte
*valaddr
, struct type
*type
,
599 struct ui_file
*stream
, char *prefix
)
601 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
603 /* VAL is a byte offset into the structure type DOMAIN.
604 Find the name of the field for that offset and
606 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
608 unsigned int fieldno
;
610 val
= extract_signed_integer (valaddr
, TYPE_LENGTH (type
), byte_order
);
612 /* Pointers to data members are usually byte offsets into an object.
613 Because a data member can have offset zero, and a NULL pointer to
614 member must be distinct from any valid non-NULL pointer to
615 member, either the value is biased or the NULL value has a
616 special representation; both are permitted by ISO C++. HP aCC
617 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
618 and other compilers which use the Itanium ABI use -1 as the NULL
619 value. GDB only supports that last form; to add support for
620 another form, make this into a cp-abi hook. */
624 fprintf_filtered (stream
, "NULL");
628 cp_find_class_member (&domain
, &fieldno
, val
<< 3);
633 fputs_filtered (prefix
, stream
);
634 name
= type_name_no_tag (domain
);
636 fputs_filtered (name
, stream
);
638 c_type_print_base (domain
, stream
, 0, 0);
639 fprintf_filtered (stream
, "::");
640 fputs_filtered (TYPE_FIELD_NAME (domain
, fieldno
), stream
);
643 fprintf_filtered (stream
, "%ld", (long) val
);
648 _initialize_cp_valprint (void)
650 add_setshow_boolean_cmd ("static-members", class_support
,
651 &user_print_options
.static_field_print
, _("\
652 Set printing of C++ static members."), _("\
653 Show printing of C++ static members."), NULL
,
655 show_static_field_print
,
656 &setprintlist
, &showprintlist
);
658 add_setshow_boolean_cmd ("vtbl", class_support
,
659 &user_print_options
.vtblprint
, _("\
660 Set printing of C++ virtual function tables."), _("\
661 Show printing of C++ virtual function tables."), NULL
,
664 &setprintlist
, &showprintlist
);
666 add_setshow_boolean_cmd ("object", class_support
,
667 &user_print_options
.objectprint
, _("\
668 Set printing of object's derived type based on vtable info."), _("\
669 Show printing of object's derived type based on vtable info."), NULL
,
672 &setprintlist
, &showprintlist
);
674 obstack_begin (&dont_print_vb_obstack
, 32 * sizeof (struct type
*));
675 obstack_specify_allocation (&dont_print_statmem_obstack
,
676 32 * sizeof (CORE_ADDR
), sizeof (CORE_ADDR
),