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