Automatic date update in version.in
[external/binutils.git] / gdb / cp-valprint.c
1 /* Support for printing C++ values for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2019 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 "common/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 (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 (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               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   struct type *real_type = check_typedef (type);
637   if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
638     {
639       CORE_ADDR *first_dont_print;
640       CORE_ADDR addr;
641       int i;
642
643       first_dont_print
644         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
645       i = obstack_object_size (&dont_print_statmem_obstack)
646         / sizeof (CORE_ADDR);
647
648       while (--i >= 0)
649         {
650           if (value_address (val) == first_dont_print[i])
651             {
652               fputs_filtered ("<same as static member of an already"
653                               " seen type>",
654                               stream);
655               return;
656             }
657         }
658
659       addr = value_address (val);
660       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
661                     sizeof (CORE_ADDR));
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 (real_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 (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 }