Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / cp-valprint.c
CommitLineData
5796c8dc
SS
1/* Support for printing C++ values for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "gdb_obstack.h"
22#include "symtab.h"
23#include "gdbtypes.h"
24#include "expression.h"
25#include "value.h"
26#include "command.h"
27#include "gdbcmd.h"
28#include "demangle.h"
29#include "annotate.h"
30#include "gdb_string.h"
31#include "c-lang.h"
32#include "target.h"
33#include "cp-abi.h"
34#include "valprint.h"
35#include "cp-support.h"
36#include "language.h"
37#include "python/python.h"
c50c785c 38#include "exceptions.h"
ef5ccd6c 39#include "typeprint.h"
5796c8dc 40
c50c785c 41/* Controls printing of vtbl's. */
5796c8dc
SS
42static void
43show_vtblprint (struct ui_file *file, int from_tty,
44 struct cmd_list_element *c, const char *value)
45{
46 fprintf_filtered (file, _("\
47Printing of C++ virtual function tables is %s.\n"),
48 value);
49}
50
51/* Controls looking up an object's derived type using what we find in
52 its vtables. */
53static void
54show_objectprint (struct ui_file *file, int from_tty,
55 struct cmd_list_element *c,
56 const char *value)
57{
58 fprintf_filtered (file, _("\
59Printing of object's derived type based on vtable info is %s.\n"),
60 value);
61}
62
63static void
64show_static_field_print (struct ui_file *file, int from_tty,
c50c785c
JM
65 struct cmd_list_element *c,
66 const char *value)
5796c8dc 67{
c50c785c
JM
68 fprintf_filtered (file,
69 _("Printing of C++ static members is %s.\n"),
5796c8dc
SS
70 value);
71}
72
73
74static struct obstack dont_print_vb_obstack;
75static struct obstack dont_print_statmem_obstack;
cf7f2e2d 76static struct obstack dont_print_stat_array_obstack;
5796c8dc
SS
77
78extern void _initialize_cp_valprint (void);
79
80static void cp_print_static_field (struct type *, struct value *,
81 struct ui_file *, int,
82 const struct value_print_options *);
83
c50c785c
JM
84static void cp_print_value (struct type *, struct type *,
85 const gdb_byte *, int,
86 CORE_ADDR, struct ui_file *,
87 int, const struct value *,
88 const struct value_print_options *,
89 struct type **);
5796c8dc
SS
90
91
92/* GCC versions after 2.4.5 use this. */
93const char vtbl_ptr_name[] = "__vtbl_ptr_type";
94
95/* Return truth value for assertion that TYPE is of the type
96 "pointer to virtual function". */
97
98int
99cp_is_vtbl_ptr_type (struct type *type)
100{
ef5ccd6c 101 const char *typename = type_name_no_tag (type);
5796c8dc
SS
102
103 return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
104}
105
106/* Return truth value for the assertion that TYPE is of the type
107 "pointer to virtual function table". */
108
109int
110cp_is_vtbl_member (struct type *type)
111{
c50c785c
JM
112 /* With older versions of g++, the vtbl field pointed to an array of
113 structures. Nowadays it points directly to the structure. */
5796c8dc
SS
114 if (TYPE_CODE (type) == TYPE_CODE_PTR)
115 {
116 type = TYPE_TARGET_TYPE (type);
117 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
118 {
119 type = TYPE_TARGET_TYPE (type);
c50c785c
JM
120 if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
121 || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
5796c8dc
SS
122 {
123 /* Virtual functions tables are full of pointers
c50c785c 124 to virtual functions. */
5796c8dc
SS
125 return cp_is_vtbl_ptr_type (type);
126 }
127 }
128 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
129 {
130 return cp_is_vtbl_ptr_type (type);
131 }
132 else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
133 {
c50c785c
JM
134 /* The type name of the thunk pointer is NULL when using
135 dwarf2. We could test for a pointer to a function, but
136 there is no type info for the virtual table either, so it
137 wont help. */
5796c8dc
SS
138 return cp_is_vtbl_ptr_type (type);
139 }
140 }
141 return 0;
142}
143
144/* Mutually recursive subroutines of cp_print_value and c_val_print to
c50c785c
JM
145 print out a structure's fields: cp_print_value_fields and
146 cp_print_value.
5796c8dc 147
c50c785c
JM
148 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
149 meanings as in cp_print_value and c_val_print.
5796c8dc 150
c50c785c
JM
151 2nd argument REAL_TYPE is used to carry over the type of the
152 derived class across the recursion to base classes.
5796c8dc 153
c50c785c
JM
154 DONT_PRINT is an array of baseclass types that we should not print,
155 or zero if called from top level. */
5796c8dc
SS
156
157void
158cp_print_value_fields (struct type *type, struct type *real_type,
c50c785c
JM
159 const gdb_byte *valaddr, int offset,
160 CORE_ADDR address, struct ui_file *stream,
161 int recurse, const struct value *val,
5796c8dc 162 const struct value_print_options *options,
c50c785c
JM
163 struct type **dont_print_vb,
164 int dont_print_statmem)
5796c8dc
SS
165{
166 int i, len, n_baseclasses;
5796c8dc 167 int fields_seen = 0;
cf7f2e2d 168 static int last_set_recurse = -1;
5796c8dc
SS
169
170 CHECK_TYPEDEF (type);
cf7f2e2d
JM
171
172 if (recurse == 0)
173 {
c50c785c
JM
174 /* Any object can be left on obstacks only during an unexpected
175 error. */
cf7f2e2d
JM
176
177 if (obstack_object_size (&dont_print_statmem_obstack) > 0)
178 {
179 obstack_free (&dont_print_statmem_obstack, NULL);
c50c785c
JM
180 obstack_begin (&dont_print_statmem_obstack,
181 32 * sizeof (CORE_ADDR));
cf7f2e2d
JM
182 }
183 if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
184 {
185 obstack_free (&dont_print_stat_array_obstack, NULL);
186 obstack_begin (&dont_print_stat_array_obstack,
187 32 * sizeof (struct type *));
188 }
189 }
5796c8dc
SS
190
191 fprintf_filtered (stream, "{");
192 len = TYPE_NFIELDS (type);
193 n_baseclasses = TYPE_N_BASECLASSES (type);
194
195 /* First, print out baseclasses such that we don't print
196 duplicates of virtual baseclasses. */
197
198 if (n_baseclasses > 0)
c50c785c
JM
199 cp_print_value (type, real_type, valaddr,
200 offset, address, stream,
201 recurse + 1, val, options,
202 dont_print_vb);
5796c8dc
SS
203
204 /* Second, print out data fields */
205
206 /* If there are no data fields, skip this part */
207 if (len == n_baseclasses || !len)
208 fprintf_filtered (stream, "<No data fields>");
209 else
210 {
cf7f2e2d
JM
211 int statmem_obstack_initial_size = 0;
212 int stat_array_obstack_initial_size = 0;
ef5ccd6c
JM
213 struct type *vptr_basetype = NULL;
214 int vptr_fieldno;
215
5796c8dc
SS
216 if (dont_print_statmem == 0)
217 {
cf7f2e2d
JM
218 statmem_obstack_initial_size =
219 obstack_object_size (&dont_print_statmem_obstack);
220
221 if (last_set_recurse != recurse)
222 {
223 stat_array_obstack_initial_size =
224 obstack_object_size (&dont_print_stat_array_obstack);
225
226 last_set_recurse = recurse;
227 }
5796c8dc
SS
228 }
229
ef5ccd6c 230 vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
5796c8dc
SS
231 for (i = n_baseclasses; i < len; i++)
232 {
233 /* If requested, skip printing of static fields. */
234 if (!options->static_field_print
235 && field_is_static (&TYPE_FIELD (type, i)))
236 continue;
237
238 if (fields_seen)
239 fprintf_filtered (stream, ", ");
240 else if (n_baseclasses > 0)
241 {
242 if (options->pretty)
243 {
244 fprintf_filtered (stream, "\n");
245 print_spaces_filtered (2 + 2 * recurse, stream);
246 fputs_filtered ("members of ", stream);
247 fputs_filtered (type_name_no_tag (type), stream);
248 fputs_filtered (": ", stream);
249 }
250 }
251 fields_seen = 1;
252
253 if (options->pretty)
254 {
255 fprintf_filtered (stream, "\n");
256 print_spaces_filtered (2 + 2 * recurse, stream);
257 }
258 else
259 {
260 wrap_here (n_spaces (2 + 2 * recurse));
261 }
ef5ccd6c
JM
262
263 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
264
265 if (field_is_static (&TYPE_FIELD (type, i)))
266 fputs_filtered ("static ", stream);
267 fprintf_symbol_filtered (stream,
268 TYPE_FIELD_NAME (type, i),
269 current_language->la_language,
270 DMGL_PARAMS | DMGL_ANSI);
271 annotate_field_name_end ();
272 /* Do not print leading '=' in case of anonymous
273 unions. */
274 if (strcmp (TYPE_FIELD_NAME (type, i), ""))
275 fputs_filtered (" = ", stream);
276 annotate_field_value ();
5796c8dc
SS
277
278 if (!field_is_static (&TYPE_FIELD (type, i))
279 && TYPE_FIELD_PACKED (type, i))
280 {
281 struct value *v;
282
c50c785c
JM
283 /* Bitfields require special handling, especially due to
284 byte order problems. */
5796c8dc
SS
285 if (TYPE_FIELD_IGNORE (type, i))
286 {
287 fputs_filtered ("<optimized out or zero length>", stream);
288 }
c50c785c
JM
289 else if (value_bits_synthetic_pointer (val,
290 TYPE_FIELD_BITPOS (type,
291 i),
292 TYPE_FIELD_BITSIZE (type,
293 i)))
294 {
295 fputs_filtered (_("<synthetic pointer>"), stream);
296 }
297 else if (!value_bits_valid (val,
298 TYPE_FIELD_BITPOS (type, i),
cf7f2e2d
JM
299 TYPE_FIELD_BITSIZE (type, i)))
300 {
c50c785c 301 val_print_optimized_out (stream);
cf7f2e2d 302 }
5796c8dc
SS
303 else
304 {
305 struct value_print_options opts = *options;
cf7f2e2d 306
5796c8dc 307 opts.deref_ref = 0;
c50c785c
JM
308
309 v = value_field_bitfield (type, i, valaddr, offset, val);
5796c8dc
SS
310
311 common_val_print (v, stream, recurse + 1, &opts,
312 current_language);
313 }
314 }
315 else
316 {
317 if (TYPE_FIELD_IGNORE (type, i))
318 {
c50c785c
JM
319 fputs_filtered ("<optimized out or zero length>",
320 stream);
5796c8dc
SS
321 }
322 else if (field_is_static (&TYPE_FIELD (type, i)))
323 {
a45ae5f8
JM
324 volatile struct gdb_exception ex;
325 struct value *v = NULL;
326
327 TRY_CATCH (ex, RETURN_MASK_ERROR)
328 {
329 v = value_static_field (type, i);
330 }
331
332 if (ex.reason < 0)
333 fprintf_filtered (stream,
334 _("<error reading variable: %s>"),
335 ex.message);
336 else if (v == NULL)
c50c785c 337 val_print_optimized_out (stream);
5796c8dc 338 else
c50c785c
JM
339 cp_print_static_field (TYPE_FIELD_TYPE (type, i),
340 v, stream, recurse + 1,
341 options);
5796c8dc 342 }
ef5ccd6c
JM
343 else if (i == vptr_fieldno && type == vptr_basetype)
344 {
345 int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
346 struct type *i_type = TYPE_FIELD_TYPE (type, i);
347
348 if (valprint_check_validity (stream, i_type, i_offset, val))
349 {
350 CORE_ADDR addr;
351
352 addr = extract_typed_address (valaddr + i_offset, i_type);
353 print_function_pointer_address (options,
354 get_type_arch (type),
355 addr, stream);
356 }
357 }
5796c8dc
SS
358 else
359 {
360 struct value_print_options opts = *options;
cf7f2e2d 361
5796c8dc
SS
362 opts.deref_ref = 0;
363 val_print (TYPE_FIELD_TYPE (type, i),
c50c785c
JM
364 valaddr,
365 offset + TYPE_FIELD_BITPOS (type, i) / 8,
cf7f2e2d
JM
366 address,
367 stream, recurse + 1, val, &opts,
5796c8dc
SS
368 current_language);
369 }
370 }
371 annotate_field_end ();
372 }
373
374 if (dont_print_statmem == 0)
375 {
cf7f2e2d
JM
376 int obstack_final_size =
377 obstack_object_size (&dont_print_statmem_obstack);
378
c50c785c
JM
379 if (obstack_final_size > statmem_obstack_initial_size)
380 {
381 /* In effect, a pop of the printed-statics stack. */
cf7f2e2d 382
c50c785c
JM
383 void *free_to_ptr =
384 obstack_next_free (&dont_print_statmem_obstack) -
385 (obstack_final_size - statmem_obstack_initial_size);
cf7f2e2d 386
c50c785c
JM
387 obstack_free (&dont_print_statmem_obstack,
388 free_to_ptr);
389 }
cf7f2e2d
JM
390
391 if (last_set_recurse != recurse)
392 {
393 int obstack_final_size =
394 obstack_object_size (&dont_print_stat_array_obstack);
395
396 if (obstack_final_size > stat_array_obstack_initial_size)
397 {
398 void *free_to_ptr =
c50c785c
JM
399 obstack_next_free (&dont_print_stat_array_obstack)
400 - (obstack_final_size
401 - stat_array_obstack_initial_size);
cf7f2e2d
JM
402
403 obstack_free (&dont_print_stat_array_obstack,
404 free_to_ptr);
405 }
406 last_set_recurse = -1;
407 }
5796c8dc
SS
408 }
409
410 if (options->pretty)
411 {
412 fprintf_filtered (stream, "\n");
413 print_spaces_filtered (2 * recurse, stream);
414 }
415 } /* if there are data fields */
416
417 fprintf_filtered (stream, "}");
418}
419
cf7f2e2d
JM
420/* Like cp_print_value_fields, but find the runtime type of the object
421 and pass it as the `real_type' argument to cp_print_value_fields.
422 This function is a hack to work around the fact that
423 common_val_print passes the embedded offset to val_print, but not
424 the enclosing type. */
425
426void
427cp_print_value_fields_rtti (struct type *type,
428 const gdb_byte *valaddr, int offset,
429 CORE_ADDR address,
430 struct ui_file *stream, int recurse,
431 const struct value *val,
432 const struct value_print_options *options,
433 struct type **dont_print_vb,
434 int dont_print_statmem)
435{
436 struct type *real_type = NULL;
437
438 /* We require all bits to be valid in order to attempt a
439 conversion. */
440 if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
441 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
442 {
443 struct value *value;
444 int full, top, using_enc;
445
446 /* Ugh, we have to convert back to a value here. */
447 value = value_from_contents_and_address (type, valaddr + offset,
448 address + offset);
c50c785c
JM
449 /* We don't actually care about most of the result here -- just
450 the type. We already have the correct offset, due to how
451 val_print was initially called. */
cf7f2e2d
JM
452 real_type = value_rtti_type (value, &full, &top, &using_enc);
453 }
454
455 if (!real_type)
456 real_type = type;
457
458 cp_print_value_fields (type, real_type, valaddr, offset,
459 address, stream, recurse, val, options,
460 dont_print_vb, dont_print_statmem);
461}
462
c50c785c
JM
463/* Special val_print routine to avoid printing multiple copies of
464 virtual baseclasses. */
5796c8dc
SS
465
466static void
467cp_print_value (struct type *type, struct type *real_type,
c50c785c
JM
468 const gdb_byte *valaddr, int offset,
469 CORE_ADDR address, struct ui_file *stream,
470 int recurse, const struct value *val,
5796c8dc
SS
471 const struct value_print_options *options,
472 struct type **dont_print_vb)
473{
474 struct type **last_dont_print
475 = (struct type **) obstack_next_free (&dont_print_vb_obstack);
476 struct obstack tmp_obstack = dont_print_vb_obstack;
477 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
478 int thisoffset;
479 struct type *thistype;
480
481 if (dont_print_vb == 0)
482 {
c50c785c
JM
483 /* If we're at top level, carve out a completely fresh chunk of
484 the obstack and use that until this particular invocation
485 returns. */
5796c8dc
SS
486 /* Bump up the high-water mark. Now alpha is omega. */
487 obstack_finish (&dont_print_vb_obstack);
488 }
489
490 for (i = 0; i < n_baseclasses; i++)
491 {
c50c785c 492 int boffset = 0;
5796c8dc
SS
493 int skip;
494 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
ef5ccd6c 495 const char *basename = TYPE_NAME (baseclass);
c50c785c
JM
496 const gdb_byte *base_valaddr = NULL;
497 const struct value *base_val = NULL;
498 volatile struct gdb_exception ex;
5796c8dc
SS
499
500 if (BASETYPE_VIA_VIRTUAL (type, i))
501 {
502 struct type **first_dont_print
503 = (struct type **) obstack_base (&dont_print_vb_obstack);
504
c50c785c
JM
505 int j = (struct type **)
506 obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
5796c8dc
SS
507
508 while (--j >= 0)
509 if (baseclass == first_dont_print[j])
510 goto flush_it;
511
512 obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
513 }
514
515 thisoffset = offset;
516 thistype = real_type;
517
c50c785c 518 TRY_CATCH (ex, RETURN_MASK_ERROR)
5796c8dc 519 {
c50c785c
JM
520 boffset = baseclass_offset (type, i, valaddr, offset, address, val);
521 }
522 if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
523 skip = -1;
524 else if (ex.reason < 0)
525 skip = 1;
526 else
527 {
528 skip = 0;
5796c8dc 529
c50c785c 530 if (BASETYPE_VIA_VIRTUAL (type, i))
5796c8dc 531 {
c50c785c
JM
532 /* The virtual base class pointer might have been
533 clobbered by the user program. Make sure that it
534 still points to a valid memory location. */
535
536 if ((boffset + offset) < 0
537 || (boffset + offset) >= TYPE_LENGTH (real_type))
538 {
ef5ccd6c
JM
539 gdb_byte *buf;
540 struct cleanup *back_to;
541
542 buf = xmalloc (TYPE_LENGTH (baseclass));
543 back_to = make_cleanup (xfree, buf);
c50c785c
JM
544
545 if (target_read_memory (address + boffset, buf,
546 TYPE_LENGTH (baseclass)) != 0)
547 skip = 1;
548 base_val = value_from_contents_and_address (baseclass,
549 buf,
550 address + boffset);
551 thisoffset = 0;
552 boffset = 0;
553 thistype = baseclass;
554 base_valaddr = value_contents_for_printing_const (base_val);
ef5ccd6c 555 do_cleanups (back_to);
c50c785c
JM
556 }
557 else
558 {
559 base_valaddr = valaddr;
560 base_val = val;
561 }
5796c8dc
SS
562 }
563 else
c50c785c
JM
564 {
565 base_valaddr = valaddr;
566 base_val = val;
567 }
5796c8dc 568 }
5796c8dc 569
c50c785c 570 /* Now do the printing. */
5796c8dc
SS
571 if (options->pretty)
572 {
573 fprintf_filtered (stream, "\n");
574 print_spaces_filtered (2 * recurse, stream);
575 }
576 fputs_filtered ("<", stream);
c50c785c
JM
577 /* Not sure what the best notation is in the case where there is
578 no baseclass name. */
5796c8dc
SS
579 fputs_filtered (basename ? basename : "", stream);
580 fputs_filtered ("> = ", stream);
581
c50c785c
JM
582 if (skip < 0)
583 val_print_unavailable (stream);
584 else if (skip > 0)
585 val_print_invalid_address (stream);
5796c8dc
SS
586 else
587 {
588 int result = 0;
589
590 /* Attempt to run the Python pretty-printers on the
591 baseclass if possible. */
592 if (!options->raw)
593 result = apply_val_pretty_printer (baseclass, base_valaddr,
594 thisoffset + boffset,
c50c785c
JM
595 value_address (base_val),
596 stream, recurse, base_val,
597 options, current_language);
598
599
5796c8dc
SS
600
601 if (!result)
602 cp_print_value_fields (baseclass, thistype, base_valaddr,
c50c785c
JM
603 thisoffset + boffset,
604 value_address (base_val),
605 stream, recurse, base_val, options,
5796c8dc
SS
606 ((struct type **)
607 obstack_base (&dont_print_vb_obstack)),
608 0);
609 }
610 fputs_filtered (", ", stream);
611
612 flush_it:
613 ;
614 }
615
616 if (dont_print_vb == 0)
617 {
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;
624 }
625}
626
c50c785c
JM
627/* Print value of a static member. To avoid infinite recursion when
628 printing a class that contains a static instance of the class, we
629 keep the addresses of all printed static member classes in an
630 obstack and refuse to print them more than once.
5796c8dc
SS
631
632 VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
633 have the same meanings as in c_val_print. */
634
635static void
636cp_print_static_field (struct type *type,
637 struct value *val,
638 struct ui_file *stream,
639 int recurse,
640 const struct value_print_options *options)
641{
642 struct value_print_options opts;
cf7f2e2d 643
5796c8dc
SS
644 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
645 {
646 CORE_ADDR *first_dont_print;
647 CORE_ADDR addr;
648 int i;
649
650 first_dont_print
651 = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
cf7f2e2d
JM
652 i = obstack_object_size (&dont_print_statmem_obstack)
653 / sizeof (CORE_ADDR);
5796c8dc
SS
654
655 while (--i >= 0)
656 {
657 if (value_address (val) == first_dont_print[i])
658 {
659 fputs_filtered ("<same as static member of an already"
660 " seen type>",
661 stream);
662 return;
663 }
664 }
665
666 addr = value_address (val);
667 obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
668 sizeof (CORE_ADDR));
5796c8dc 669 CHECK_TYPEDEF (type);
cf7f2e2d
JM
670 cp_print_value_fields (type, value_enclosing_type (val),
671 value_contents_for_printing (val),
5796c8dc 672 value_embedded_offset (val), addr,
c50c785c
JM
673 stream, recurse, val,
674 options, NULL, 1);
5796c8dc
SS
675 return;
676 }
677
cf7f2e2d
JM
678 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
679 {
680 struct type **first_dont_print;
681 int i;
682 struct type *target_type = TYPE_TARGET_TYPE (type);
683
684 first_dont_print
685 = (struct type **) obstack_base (&dont_print_stat_array_obstack);
686 i = obstack_object_size (&dont_print_stat_array_obstack)
687 / sizeof (struct type *);
688
689 while (--i >= 0)
690 {
691 if (target_type == first_dont_print[i])
692 {
693 fputs_filtered ("<same as static member of an already"
694 " seen type>",
695 stream);
696 return;
697 }
698 }
699
c50c785c
JM
700 obstack_grow (&dont_print_stat_array_obstack,
701 (char *) &target_type,
cf7f2e2d
JM
702 sizeof (struct type *));
703 }
704
5796c8dc
SS
705 opts = *options;
706 opts.deref_ref = 0;
cf7f2e2d 707 val_print (type, value_contents_for_printing (val),
c50c785c
JM
708 value_embedded_offset (val),
709 value_address (val),
710 stream, recurse, val,
711 &opts, current_language);
5796c8dc
SS
712}
713
714
c50c785c
JM
715/* Find the field in *DOMAIN, or its non-virtual base classes, with
716 bit offset OFFSET. Set *DOMAIN to the containing type and *FIELDNO
717 to the containing field number. If OFFSET is not exactly at the
718 start of some field, set *DOMAIN to NULL. */
5796c8dc
SS
719
720static void
721cp_find_class_member (struct type **domain_p, int *fieldno,
722 LONGEST offset)
723{
724 struct type *domain;
725 unsigned int i;
726 unsigned len;
727
728 *domain_p = check_typedef (*domain_p);
729 domain = *domain_p;
730 len = TYPE_NFIELDS (domain);
731
732 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
733 {
734 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
735
736 QUIT;
737 if (offset == bitpos)
738 {
739 *fieldno = i;
740 return;
741 }
742 }
743
744 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
745 {
746 LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
747 LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
748
749 if (offset >= bitpos && offset < bitpos + bitsize)
750 {
751 *domain_p = TYPE_FIELD_TYPE (domain, i);
752 cp_find_class_member (domain_p, fieldno, offset - bitpos);
753 return;
754 }
755 }
756
757 *domain_p = NULL;
758}
759
760void
761cp_print_class_member (const gdb_byte *valaddr, struct type *type,
762 struct ui_file *stream, char *prefix)
763{
764 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
765
766 /* VAL is a byte offset into the structure type DOMAIN.
767 Find the name of the field for that offset and
768 print it. */
769 struct type *domain = TYPE_DOMAIN_TYPE (type);
770 LONGEST val;
771 unsigned int fieldno;
772
c50c785c
JM
773 val = extract_signed_integer (valaddr,
774 TYPE_LENGTH (type),
775 byte_order);
5796c8dc
SS
776
777 /* Pointers to data members are usually byte offsets into an object.
778 Because a data member can have offset zero, and a NULL pointer to
779 member must be distinct from any valid non-NULL pointer to
780 member, either the value is biased or the NULL value has a
781 special representation; both are permitted by ISO C++. HP aCC
782 used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
783 and other compilers which use the Itanium ABI use -1 as the NULL
784 value. GDB only supports that last form; to add support for
785 another form, make this into a cp-abi hook. */
786
787 if (val == -1)
788 {
789 fprintf_filtered (stream, "NULL");
790 return;
791 }
792
793 cp_find_class_member (&domain, &fieldno, val << 3);
794
795 if (domain != NULL)
796 {
ef5ccd6c 797 const char *name;
cf7f2e2d 798
5796c8dc
SS
799 fputs_filtered (prefix, stream);
800 name = type_name_no_tag (domain);
801 if (name)
802 fputs_filtered (name, stream);
803 else
ef5ccd6c 804 c_type_print_base (domain, stream, 0, 0, &type_print_raw_options);
5796c8dc
SS
805 fprintf_filtered (stream, "::");
806 fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
807 }
808 else
809 fprintf_filtered (stream, "%ld", (long) val);
810}
811
812
813void
814_initialize_cp_valprint (void)
815{
816 add_setshow_boolean_cmd ("static-members", class_support,
817 &user_print_options.static_field_print, _("\
818Set printing of C++ static members."), _("\
819Show printing of C++ static members."), NULL,
820 NULL,
821 show_static_field_print,
822 &setprintlist, &showprintlist);
823
824 add_setshow_boolean_cmd ("vtbl", class_support,
825 &user_print_options.vtblprint, _("\
826Set printing of C++ virtual function tables."), _("\
827Show printing of C++ virtual function tables."), NULL,
828 NULL,
829 show_vtblprint,
830 &setprintlist, &showprintlist);
831
832 add_setshow_boolean_cmd ("object", class_support,
833 &user_print_options.objectprint, _("\
834Set printing of object's derived type based on vtable info."), _("\
835Show printing of object's derived type based on vtable info."), NULL,
836 NULL,
837 show_objectprint,
838 &setprintlist, &showprintlist);
839
c50c785c
JM
840 obstack_begin (&dont_print_stat_array_obstack,
841 32 * sizeof (struct type *));
842 obstack_begin (&dont_print_statmem_obstack,
843 32 * sizeof (CORE_ADDR));
844 obstack_begin (&dont_print_vb_obstack,
845 32 * sizeof (struct type *));
5796c8dc 846}