GDB (xrefs)

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