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