Make stap-probe.c:stap_parse_register_operand's "regname" an std::string
[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                   TRY
318                     {
319                       struct value *v = value_static_field (type, i);
320
321                       cp_print_static_field (TYPE_FIELD_TYPE (type, i),
322                                              v, stream, recurse + 1,
323                                              options);
324                     }
325                   CATCH (ex, RETURN_MASK_ERROR)
326                     {
327                       fprintf_filtered (stream,
328                                         _("<error reading variable: %s>"),
329                                         ex.message);
330                     }
331                   END_CATCH
332                 }
333               else if (i == vptr_fieldno && type == vptr_basetype)
334                 {
335                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
336                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
337
338                   if (valprint_check_validity (stream, i_type, i_offset, val))
339                     {
340                       CORE_ADDR addr;
341                       
342                       addr = extract_typed_address (valaddr + i_offset, i_type);
343                       print_function_pointer_address (options,
344                                                       get_type_arch (type),
345                                                       addr, stream);
346                     }
347                 }
348               else
349                 {
350                   struct value_print_options opts = *options;
351
352                   opts.deref_ref = 0;
353                   val_print (TYPE_FIELD_TYPE (type, i),
354                              offset + TYPE_FIELD_BITPOS (type, i) / 8,
355                              address,
356                              stream, recurse + 1, val, &opts,
357                              current_language);
358                 }
359             }
360           annotate_field_end ();
361         }
362
363       if (dont_print_statmem == 0)
364         {
365           size_t obstack_final_size =
366            obstack_object_size (&dont_print_statmem_obstack);
367
368           if (obstack_final_size > statmem_obstack_initial_size)
369             {
370               /* In effect, a pop of the printed-statics stack.  */
371               size_t shrink_bytes
372                 = statmem_obstack_initial_size - obstack_final_size;
373               obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
374             }
375
376           if (last_set_recurse != recurse)
377             {
378               obstack_final_size =
379                 obstack_object_size (&dont_print_stat_array_obstack);
380               
381               if (obstack_final_size > stat_array_obstack_initial_size)
382                 {
383                   void *free_to_ptr =
384                     (char *) obstack_next_free (&dont_print_stat_array_obstack)
385                     - (obstack_final_size
386                        - stat_array_obstack_initial_size);
387
388                   obstack_free (&dont_print_stat_array_obstack,
389                                 free_to_ptr);
390                 }
391               last_set_recurse = -1;
392             }
393         }
394
395       if (options->prettyformat)
396         {
397           fprintf_filtered (stream, "\n");
398           print_spaces_filtered (2 * recurse, stream);
399         }
400     }                           /* if there are data fields */
401
402   fprintf_filtered (stream, "}");
403 }
404
405 /* Like cp_print_value_fields, but find the runtime type of the object
406    and pass it as the `real_type' argument to cp_print_value_fields.
407    This function is a hack to work around the fact that
408    common_val_print passes the embedded offset to val_print, but not
409    the enclosing type.  */
410
411 void
412 cp_print_value_fields_rtti (struct type *type,
413                             const gdb_byte *valaddr, LONGEST offset,
414                             CORE_ADDR address,
415                             struct ui_file *stream, int recurse,
416                             struct value *val,
417                             const struct value_print_options *options,
418                             struct type **dont_print_vb, 
419                             int dont_print_statmem)
420 {
421   struct type *real_type = NULL;
422
423   /* We require all bits to be valid in order to attempt a
424      conversion.  */
425   if (!value_bits_any_optimized_out (val,
426                                      TARGET_CHAR_BIT * offset,
427                                      TARGET_CHAR_BIT * TYPE_LENGTH (type)))
428     {
429       struct value *value;
430       int full, using_enc;
431       LONGEST top;
432
433       /* Ugh, we have to convert back to a value here.  */
434       value = value_from_contents_and_address (type, valaddr + offset,
435                                                address + offset);
436       type = value_type (value);
437       /* We don't actually care about most of the result here -- just
438          the type.  We already have the correct offset, due to how
439          val_print was initially called.  */
440       real_type = value_rtti_type (value, &full, &top, &using_enc);
441     }
442
443   if (!real_type)
444     real_type = type;
445
446   cp_print_value_fields (type, real_type, offset,
447                          address, stream, recurse, val, options,
448                          dont_print_vb, dont_print_statmem);
449 }
450
451 /* Special val_print routine to avoid printing multiple copies of
452    virtual baseclasses.  */
453
454 static void
455 cp_print_value (struct type *type, struct type *real_type,
456                 LONGEST offset,
457                 CORE_ADDR address, struct ui_file *stream,
458                 int recurse, struct value *val,
459                 const struct value_print_options *options,
460                 struct type **dont_print_vb)
461 {
462   struct type **last_dont_print
463     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
464   struct obstack tmp_obstack = dont_print_vb_obstack;
465   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
466   LONGEST thisoffset;
467   struct type *thistype;
468   const gdb_byte *valaddr = value_contents_for_printing (val);
469
470   if (dont_print_vb == 0)
471     {
472       /* If we're at top level, carve out a completely fresh chunk of
473          the obstack and use that until this particular invocation
474          returns.  */
475       /* Bump up the high-water mark.  Now alpha is omega.  */
476       obstack_finish (&dont_print_vb_obstack);
477     }
478
479   for (i = 0; i < n_baseclasses; i++)
480     {
481       LONGEST boffset = 0;
482       int skip = 0;
483       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
484       const char *basename = TYPE_NAME (baseclass);
485       struct value *base_val = NULL;
486
487       if (BASETYPE_VIA_VIRTUAL (type, i))
488         {
489           struct type **first_dont_print
490             = (struct type **) obstack_base (&dont_print_vb_obstack);
491
492           int j = (struct type **)
493             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
494
495           while (--j >= 0)
496             if (baseclass == first_dont_print[j])
497               goto flush_it;
498
499           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
500         }
501
502       thisoffset = offset;
503       thistype = real_type;
504
505       TRY
506         {
507           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
508         }
509       CATCH (ex, RETURN_MASK_ERROR)
510         {
511           if (ex.error == NOT_AVAILABLE_ERROR)
512             skip = -1;
513           else
514             skip = 1;
515         }
516       END_CATCH
517
518       if (skip == 0)
519         {
520           if (BASETYPE_VIA_VIRTUAL (type, i))
521             {
522               /* The virtual base class pointer might have been
523                  clobbered by the user program. Make sure that it
524                  still points to a valid memory location.  */
525
526               if ((boffset + offset) < 0
527                   || (boffset + offset) >= TYPE_LENGTH (real_type))
528                 {
529                   gdb::byte_vector buf (TYPE_LENGTH (baseclass));
530
531                   if (target_read_memory (address + boffset, buf.data (),
532                                           TYPE_LENGTH (baseclass)) != 0)
533                     skip = 1;
534                   base_val = value_from_contents_and_address (baseclass,
535                                                               buf.data (),
536                                                               address + boffset);
537                   baseclass = value_type (base_val);
538                   thisoffset = 0;
539                   boffset = 0;
540                   thistype = baseclass;
541                 }
542               else
543                 {
544                   base_val = val;
545                 }
546             }
547           else
548             {
549               base_val = val;
550             }
551         }
552
553       /* Now do the printing.  */
554       if (options->prettyformat)
555         {
556           fprintf_filtered (stream, "\n");
557           print_spaces_filtered (2 * recurse, stream);
558         }
559       fputs_filtered ("<", stream);
560       /* Not sure what the best notation is in the case where there is
561          no baseclass name.  */
562       fputs_filtered (basename ? basename : "", stream);
563       fputs_filtered ("> = ", stream);
564
565       if (skip < 0)
566         val_print_unavailable (stream);
567       else if (skip > 0)
568         val_print_invalid_address (stream);
569       else
570         {
571           int result = 0;
572
573           /* Attempt to run an extension language pretty-printer on the
574              baseclass if possible.  */
575           if (!options->raw)
576             result
577               = apply_ext_lang_val_pretty_printer (baseclass,
578                                                    thisoffset + boffset,
579                                                    value_address (base_val),
580                                                    stream, recurse,
581                                                    base_val, options,
582                                                    current_language);
583
584           if (!result)
585             cp_print_value_fields (baseclass, thistype,
586                                    thisoffset + boffset,
587                                    value_address (base_val),
588                                    stream, recurse, base_val, options,
589                                    ((struct type **)
590                                     obstack_base (&dont_print_vb_obstack)),
591                                    0);
592         }
593       fputs_filtered (", ", stream);
594
595     flush_it:
596       ;
597     }
598
599   if (dont_print_vb == 0)
600     {
601       /* Free the space used to deal with the printing
602          of this type from top level.  */
603       obstack_free (&dont_print_vb_obstack, last_dont_print);
604       /* Reset watermark so that we can continue protecting
605          ourselves from whatever we were protecting ourselves.  */
606       dont_print_vb_obstack = tmp_obstack;
607     }
608 }
609
610 /* Print value of a static member.  To avoid infinite recursion when
611    printing a class that contains a static instance of the class, we
612    keep the addresses of all printed static member classes in an
613    obstack and refuse to print them more than once.
614
615    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
616    have the same meanings as in c_val_print.  */
617
618 static void
619 cp_print_static_field (struct type *type,
620                        struct value *val,
621                        struct ui_file *stream,
622                        int recurse,
623                        const struct value_print_options *options)
624 {
625   struct value_print_options opts;
626
627   if (value_entirely_optimized_out (val))
628     {
629       val_print_optimized_out (val, stream);
630       return;
631     }
632
633   struct type *real_type = check_typedef (type);
634   if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
635     {
636       CORE_ADDR *first_dont_print;
637       CORE_ADDR addr;
638       int i;
639
640       first_dont_print
641         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
642       i = obstack_object_size (&dont_print_statmem_obstack)
643         / sizeof (CORE_ADDR);
644
645       while (--i >= 0)
646         {
647           if (value_address (val) == first_dont_print[i])
648             {
649               fputs_filtered ("<same as static member of an already"
650                               " seen type>",
651                               stream);
652               return;
653             }
654         }
655
656       addr = value_address (val);
657       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
658                     sizeof (CORE_ADDR));
659       cp_print_value_fields (type, value_enclosing_type (val),
660                              value_embedded_offset (val), addr,
661                              stream, recurse, val,
662                              options, NULL, 1);
663       return;
664     }
665
666   if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
667     {
668       struct type **first_dont_print;
669       int i;
670       struct type *target_type = TYPE_TARGET_TYPE (type);
671
672       first_dont_print
673         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
674       i = obstack_object_size (&dont_print_stat_array_obstack)
675         / sizeof (struct type *);
676
677       while (--i >= 0)
678         {
679           if (target_type == first_dont_print[i])
680             {
681               fputs_filtered ("<same as static member of an already"
682                               " seen type>",
683                               stream);
684               return;
685             }
686         }
687
688       obstack_grow (&dont_print_stat_array_obstack,
689                     (char *) &target_type,
690                     sizeof (struct type *));
691     }
692
693   opts = *options;
694   opts.deref_ref = 0;
695   val_print (type,
696              value_embedded_offset (val),
697              value_address (val),
698              stream, recurse, val,
699              &opts, current_language);
700 }
701
702 /* Find the field in *SELF, or its non-virtual base classes, with
703    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
704    to the containing field number.  If OFFSET is not exactly at the
705    start of some field, set *SELF to NULL.  */
706
707 static void
708 cp_find_class_member (struct type **self_p, int *fieldno,
709                       LONGEST offset)
710 {
711   struct type *self;
712   unsigned int i;
713   unsigned len;
714
715   *self_p = check_typedef (*self_p);
716   self = *self_p;
717   len = TYPE_NFIELDS (self);
718
719   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
720     {
721       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
722
723       QUIT;
724       if (offset == bitpos)
725         {
726           *fieldno = i;
727           return;
728         }
729     }
730
731   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
732     {
733       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
734       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
735
736       if (offset >= bitpos && offset < bitpos + bitsize)
737         {
738           *self_p = TYPE_FIELD_TYPE (self, i);
739           cp_find_class_member (self_p, fieldno, offset - bitpos);
740           return;
741         }
742     }
743
744   *self_p = NULL;
745 }
746
747 void
748 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
749                        struct ui_file *stream, const char *prefix)
750 {
751   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
752
753   /* VAL is a byte offset into the structure type SELF_TYPE.
754      Find the name of the field for that offset and
755      print it.  */
756   struct type *self_type = TYPE_SELF_TYPE (type);
757   LONGEST val;
758   int fieldno;
759
760   val = extract_signed_integer (valaddr,
761                                 TYPE_LENGTH (type),
762                                 byte_order);
763
764   /* Pointers to data members are usually byte offsets into an object.
765      Because a data member can have offset zero, and a NULL pointer to
766      member must be distinct from any valid non-NULL pointer to
767      member, either the value is biased or the NULL value has a
768      special representation; both are permitted by ISO C++.  HP aCC
769      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
770      and other compilers which use the Itanium ABI use -1 as the NULL
771      value.  GDB only supports that last form; to add support for
772      another form, make this into a cp-abi hook.  */
773
774   if (val == -1)
775     {
776       fprintf_filtered (stream, "NULL");
777       return;
778     }
779
780   cp_find_class_member (&self_type, &fieldno, val << 3);
781
782   if (self_type != NULL)
783     {
784       const char *name;
785
786       fputs_filtered (prefix, stream);
787       name = TYPE_NAME (self_type);
788       if (name)
789         fputs_filtered (name, stream);
790       else
791         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
792       fprintf_filtered (stream, "::");
793       fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
794     }
795   else
796     fprintf_filtered (stream, "%ld", (long) val);
797 }
798
799
800 void
801 _initialize_cp_valprint (void)
802 {
803   add_setshow_boolean_cmd ("static-members", class_support,
804                            &user_print_options.static_field_print, _("\
805 Set printing of C++ static members."), _("\
806 Show printing of C++ static members."), NULL,
807                            NULL,
808                            show_static_field_print,
809                            &setprintlist, &showprintlist);
810
811   add_setshow_boolean_cmd ("vtbl", class_support,
812                            &user_print_options.vtblprint, _("\
813 Set printing of C++ virtual function tables."), _("\
814 Show printing of C++ virtual function tables."), NULL,
815                            NULL,
816                            show_vtblprint,
817                            &setprintlist, &showprintlist);
818
819   add_setshow_boolean_cmd ("object", class_support,
820                            &user_print_options.objectprint, _("\
821 Set printing of object's derived type based on vtable info."), _("\
822 Show printing of object's derived type based on vtable info."), NULL,
823                            NULL,
824                            show_objectprint,
825                            &setprintlist, &showprintlist);
826
827   obstack_begin (&dont_print_stat_array_obstack,
828                  32 * sizeof (struct type *));
829   obstack_begin (&dont_print_statmem_obstack,
830                  32 * sizeof (CORE_ADDR));
831   obstack_begin (&dont_print_vb_obstack,
832                  32 * sizeof (struct type *));
833 }