This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / gdb / cp-valprint.c
1 /* Support for printing C++ values for GDB, the GNU debugger.
2    Copyright 1986, 1988, 1989, 1991, 1994-1996, 2000
3    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 2 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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #include "defs.h"
23 #include "obstack.h"
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "value.h"
28 #include "command.h"
29 #include "gdbcmd.h"
30 #include "demangle.h"
31 #include "annotate.h"
32 #include "gdb_string.h"
33 #include "c-lang.h"
34 #include "target.h"
35
36 /* Indication of presence of HP-compiled object files */
37 extern int hp_som_som_object_present;   /* defined in symtab.c */
38
39
40 int vtblprint;                  /* Controls printing of vtbl's */
41 int objectprint;                /* Controls looking up an object's derived type
42                                    using what we find in its vtables.  */
43 int static_field_print;         /* Controls printing of static fields. */
44
45 static struct obstack dont_print_vb_obstack;
46 static struct obstack dont_print_statmem_obstack;
47
48 extern void _initialize_cp_valprint PARAMS ((void));
49
50 static void cp_print_static_field (struct type *, value_ptr,
51                                    struct ui_file *, int, int,
52                                    enum val_prettyprint);
53
54 static void cp_print_value (struct type *, struct type *, char *, int,
55                             CORE_ADDR, struct ui_file *, int, int,
56                             enum val_prettyprint, struct type **);
57
58 static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
59                                                   value_ptr,
60                                                   struct ui_file *, int,
61                                                   int,
62                                                   enum val_prettyprint);
63
64
65 void
66 cp_print_class_method (valaddr, type, stream)
67      char *valaddr;
68      struct type *type;
69      struct ui_file *stream;
70 {
71   struct type *domain;
72   struct fn_field *f = NULL;
73   int j = 0;
74   int len2;
75   int offset;
76   char *kind = "";
77   CORE_ADDR addr;
78   struct symbol *sym;
79   unsigned len;
80   unsigned int i;
81   struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
82
83   domain = TYPE_DOMAIN_TYPE (target_type);
84   if (domain == (struct type *) NULL)
85     {
86       fprintf_filtered (stream, "<unknown>");
87       return;
88     }
89   addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
90   if (METHOD_PTR_IS_VIRTUAL (addr))
91     {
92       offset = METHOD_PTR_TO_VOFFSET (addr);
93       len = TYPE_NFN_FIELDS (domain);
94       for (i = 0; i < len; i++)
95         {
96           f = TYPE_FN_FIELDLIST1 (domain, i);
97           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
98
99           for (j = 0; j < len2; j++)
100             {
101               QUIT;
102               if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
103                 {
104                   if (TYPE_FN_FIELD_STUB (f, j))
105                     check_stub_method (domain, i, j);
106                   kind = "virtual ";
107                   goto common;
108                 }
109             }
110         }
111     }
112   else
113     {
114       sym = find_pc_function (addr);
115       if (sym == 0)
116         {
117           /* 1997-08-01 Currently unsupported with HP aCC */
118           if (hp_som_som_object_present)
119             {
120               fputs_filtered ("?? <not supported with HP aCC>", stream);
121               return;
122             }
123           error ("invalid pointer to member function");
124         }
125       len = TYPE_NFN_FIELDS (domain);
126       for (i = 0; i < len; i++)
127         {
128           f = TYPE_FN_FIELDLIST1 (domain, i);
129           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
130
131           for (j = 0; j < len2; j++)
132             {
133               QUIT;
134               if (TYPE_FN_FIELD_STUB (f, j))
135                 check_stub_method (domain, i, j);
136               if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
137                 {
138                   goto common;
139                 }
140             }
141         }
142     }
143 common:
144   if (i < len)
145     {
146       char *demangled_name;
147
148       fprintf_filtered (stream, "&");
149       fprintf_filtered (stream, kind);
150       demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
151                                        DMGL_ANSI | DMGL_PARAMS);
152       if (demangled_name == NULL)
153         fprintf_filtered (stream, "<badly mangled name %s>",
154                           TYPE_FN_FIELD_PHYSNAME (f, j));
155       else
156         {
157           fputs_filtered (demangled_name, stream);
158           free (demangled_name);
159         }
160     }
161   else
162     {
163       fprintf_filtered (stream, "(");
164       type_print (type, "", stream, -1);
165       fprintf_filtered (stream, ") %d", (int) addr >> 3);
166     }
167 }
168
169 /* This was what it was for gcc 2.4.5 and earlier.  */
170 static const char vtbl_ptr_name_old[] =
171 {CPLUS_MARKER, 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
172 /* It was changed to this after 2.4.5.  */
173 const char vtbl_ptr_name[] =
174 {'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
175
176 /* HP aCC uses different names */
177 const char hpacc_vtbl_ptr_name[] =
178 {'_', '_', 'v', 'f', 'p', 0};
179 const char hpacc_vtbl_ptr_type_name[] =
180 {'_', '_', 'v', 'f', 't', 'y', 'p', 0};
181
182
183 /* Return truth value for assertion that TYPE is of the type
184    "pointer to virtual function".  */
185
186 int
187 cp_is_vtbl_ptr_type (type)
188      struct type *type;
189 {
190   char *typename = type_name_no_tag (type);
191
192   return (typename != NULL
193           && (STREQ (typename, vtbl_ptr_name)
194               || STREQ (typename, vtbl_ptr_name_old)));
195 }
196
197 /* Return truth value for the assertion that TYPE is of the type
198    "pointer to virtual function table".  */
199
200 int
201 cp_is_vtbl_member (type)
202      struct type *type;
203 {
204   if (TYPE_CODE (type) == TYPE_CODE_PTR)
205     {
206       type = TYPE_TARGET_TYPE (type);
207       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
208         {
209           type = TYPE_TARGET_TYPE (type);
210           if (TYPE_CODE (type) == TYPE_CODE_STRUCT      /* if not using thunks */
211               || TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
212             {
213               /* Virtual functions tables are full of pointers
214                  to virtual functions. */
215               return cp_is_vtbl_ptr_type (type);
216             }
217         }
218     }
219   return 0;
220 }
221
222 /* Mutually recursive subroutines of cp_print_value and c_val_print to
223    print out a structure's fields: cp_print_value_fields and cp_print_value.
224
225    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
226    same meanings as in cp_print_value and c_val_print.
227
228    2nd argument REAL_TYPE is used to carry over the type of the derived
229    class across the recursion to base classes. 
230
231    DONT_PRINT is an array of baseclass types that we
232    should not print, or zero if called from top level.  */
233
234 void
235 cp_print_value_fields (type, real_type, valaddr, offset, address, stream, format, recurse, pretty,
236                        dont_print_vb, dont_print_statmem)
237      struct type *type;
238      struct type *real_type;
239      char *valaddr;
240      int offset;
241      CORE_ADDR address;
242      struct ui_file *stream;
243      int format;
244      int recurse;
245      enum val_prettyprint pretty;
246      struct type **dont_print_vb;
247      int dont_print_statmem;
248 {
249   int i, len, n_baseclasses;
250   struct obstack tmp_obstack;
251   char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
252   int fields_seen = 0;
253
254   CHECK_TYPEDEF (type);
255
256   fprintf_filtered (stream, "{");
257   len = TYPE_NFIELDS (type);
258   n_baseclasses = TYPE_N_BASECLASSES (type);
259
260   /* First, print out baseclasses such that we don't print
261      duplicates of virtual baseclasses.  */
262
263   if (n_baseclasses > 0)
264     cp_print_value (type, real_type, valaddr, offset, address, stream,
265                     format, recurse + 1, pretty, dont_print_vb);
266
267   /* Second, print out data fields */
268
269   /* If there are no data fields, or if the only field is the
270    * vtbl pointer, skip this part */
271   if ((len == n_baseclasses) ||
272       ((len - n_baseclasses == 1) &&
273        TYPE_HAS_VTABLE (type) &&
274   STREQN (TYPE_FIELD_NAME (type, n_baseclasses), hpacc_vtbl_ptr_name, 5)) ||
275       !len)
276     fprintf_filtered (stream, "<No data fields>");
277   else
278     {
279       extern int inspect_it;
280
281       if (dont_print_statmem == 0)
282         {
283           /* If we're at top level, carve out a completely fresh
284              chunk of the obstack and use that until this particular
285              invocation returns.  */
286           tmp_obstack = dont_print_statmem_obstack;
287           obstack_finish (&dont_print_statmem_obstack);
288         }
289
290       for (i = n_baseclasses; i < len; i++)
291         {
292           /* If requested, skip printing of static fields.  */
293           if (!static_field_print && TYPE_FIELD_STATIC (type, i))
294             continue;
295
296           /* If a vtable pointer appears, we'll print it out later */
297           if (TYPE_HAS_VTABLE (type) && STREQN (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name, 5))
298             continue;
299
300           if (fields_seen)
301             fprintf_filtered (stream, ", ");
302           else if (n_baseclasses > 0)
303             {
304               if (pretty)
305                 {
306                   fprintf_filtered (stream, "\n");
307                   print_spaces_filtered (2 + 2 * recurse, stream);
308                   fputs_filtered ("members of ", stream);
309                   fputs_filtered (type_name_no_tag (type), stream);
310                   fputs_filtered (": ", stream);
311                 }
312             }
313           fields_seen = 1;
314
315           if (pretty)
316             {
317               fprintf_filtered (stream, "\n");
318               print_spaces_filtered (2 + 2 * recurse, stream);
319             }
320           else
321             {
322               wrap_here (n_spaces (2 + 2 * recurse));
323             }
324           if (inspect_it)
325             {
326               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
327                 fputs_filtered ("\"( ptr \"", stream);
328               else
329                 fputs_filtered ("\"( nodef \"", stream);
330               if (TYPE_FIELD_STATIC (type, i))
331                 fputs_filtered ("static ", stream);
332               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
333                                        language_cplus,
334                                        DMGL_PARAMS | DMGL_ANSI);
335               fputs_filtered ("\" \"", stream);
336               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
337                                        language_cplus,
338                                        DMGL_PARAMS | DMGL_ANSI);
339               fputs_filtered ("\") \"", stream);
340             }
341           else
342             {
343               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
344
345               if (TYPE_FIELD_STATIC (type, i))
346                 fputs_filtered ("static ", stream);
347               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
348                                        language_cplus,
349                                        DMGL_PARAMS | DMGL_ANSI);
350               annotate_field_name_end ();
351               /* do not print leading '=' in case of anonymous unions */
352               if (strcmp (TYPE_FIELD_NAME (type, i), ""))
353                 fputs_filtered (" = ", stream);
354               annotate_field_value ();
355             }
356
357           if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
358             {
359               value_ptr v;
360
361               /* Bitfields require special handling, especially due to byte
362                  order problems.  */
363               if (TYPE_FIELD_IGNORE (type, i))
364                 {
365                   fputs_filtered ("<optimized out or zero length>", stream);
366                 }
367               else
368                 {
369                   v = value_from_longest (TYPE_FIELD_TYPE (type, i),
370                           unpack_field_as_long (type, valaddr + offset, i));
371
372                   val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
373                              stream, format, 0, recurse + 1, pretty);
374                 }
375             }
376           else
377             {
378               if (TYPE_FIELD_IGNORE (type, i))
379                 {
380                   fputs_filtered ("<optimized out or zero length>", stream);
381                 }
382               else if (TYPE_FIELD_STATIC (type, i))
383                 {
384                   value_ptr v = value_static_field (type, i);
385                   if (v == NULL)
386                     fputs_filtered ("<optimized out>", stream);
387                   else
388                     cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
389                                            stream, format, recurse + 1,
390                                            pretty);
391                 }
392               else
393                 {
394                   val_print (TYPE_FIELD_TYPE (type, i),
395                           valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
396                              address + TYPE_FIELD_BITPOS (type, i) / 8,
397                              stream, format, 0, recurse + 1, pretty);
398                 }
399             }
400           annotate_field_end ();
401         }
402
403       if (dont_print_statmem == 0)
404         {
405           /* Free the space used to deal with the printing
406              of the members from top level.  */
407           obstack_free (&dont_print_statmem_obstack, last_dont_print);
408           dont_print_statmem_obstack = tmp_obstack;
409         }
410
411       if (pretty)
412         {
413           fprintf_filtered (stream, "\n");
414           print_spaces_filtered (2 * recurse, stream);
415         }
416     }                           /* if there are data fields */
417   /* Now print out the virtual table pointer if there is one */
418   if (TYPE_HAS_VTABLE (type) && STREQN (TYPE_FIELD_NAME (type, n_baseclasses), hpacc_vtbl_ptr_name, 5))
419     {
420       value_ptr v;
421       /* First get the virtual table pointer and print it out */
422
423 #if 0
424       fputs_filtered ("__vfp = ", stream);
425 #endif
426
427       fputs_filtered (", Virtual table at ", stream);
428
429       /* pai: FIXME 32x64 problem? */
430       /* Not sure what the best notation is in the case where there is no
431          baseclass name.  */
432       v = value_from_longest (lookup_pointer_type (builtin_type_unsigned_long),
433                               *(unsigned long *) (valaddr + offset));
434
435       val_print (VALUE_TYPE (v), VALUE_CONTENTS (v), 0, 0,
436                  stream, format, 0, recurse + 1, pretty);
437       fields_seen = 1;
438
439       if (vtblprint)
440         {
441           /* Print out function pointers in vtable. */
442
443           /* FIXME: then-clause is for non-RRBC layout of virtual
444            * table.  The RRBC case in the else-clause is yet to be
445            * implemented.  The if (1) below should be changed to a
446            * test for whether the executable we have was compiled
447            * with a version of HP aCC that doesn't have RRBC
448            * support. */
449
450           if (1)
451             {
452               /* no RRBC support; function pointers embedded directly in vtable */
453
454               int vfuncs = count_virtual_fns (real_type);
455
456               fputs_filtered (" {", stream);
457
458               /* FIXME : doesn't work at present */
459 #if 0
460               fprintf_filtered (stream, "%d entr%s: ", vfuncs, vfuncs == 1 ? "y" : "ies");
461 #else
462               fputs_filtered ("not implemented", stream);
463
464
465 #endif
466
467               /* recursive function that prints all virtual function entries */
468 #if 0
469               cp_print_hpacc_virtual_table_entries (real_type, &vfuncs, v, stream, format, recurse, pretty);
470 #endif
471               fputs_filtered ("}", stream);
472             }                   /* non-RRBC case */
473           else
474             {
475               /* FIXME -- seem comments above */
476               /* RRBC support present; function pointers are found
477                * by indirection through the class segment entries. */
478
479
480             }                   /* RRBC case */
481         }                       /* if vtblprint */
482
483       if (pretty)
484         {
485           fprintf_filtered (stream, "\n");
486           print_spaces_filtered (2 * recurse, stream);
487         }
488
489     }                           /* if vtable exists */
490
491   fprintf_filtered (stream, "}");
492 }
493
494 /* Special val_print routine to avoid printing multiple copies of virtual
495    baseclasses.  */
496
497 static void
498 cp_print_value (type, real_type, valaddr, offset, address, stream, format, recurse, pretty,
499                 dont_print_vb)
500      struct type *type;
501      struct type *real_type;
502      char *valaddr;
503      int offset;
504      CORE_ADDR address;
505      struct ui_file *stream;
506      int format;
507      int recurse;
508      enum val_prettyprint pretty;
509      struct type **dont_print_vb;
510 {
511   struct obstack tmp_obstack;
512   struct type **last_dont_print
513   = (struct type **) obstack_next_free (&dont_print_vb_obstack);
514   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
515
516   if (dont_print_vb == 0)
517     {
518       /* If we're at top level, carve out a completely fresh
519          chunk of the obstack and use that until this particular
520          invocation returns.  */
521       tmp_obstack = dont_print_vb_obstack;
522       /* Bump up the high-water mark.  Now alpha is omega.  */
523       obstack_finish (&dont_print_vb_obstack);
524     }
525
526   for (i = 0; i < n_baseclasses; i++)
527     {
528       int boffset;
529       int skip;
530       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
531       char *basename = TYPE_NAME (baseclass);
532       char *base_valaddr;
533
534       if (BASETYPE_VIA_VIRTUAL (type, i))
535         {
536           struct type **first_dont_print
537           = (struct type **) obstack_base (&dont_print_vb_obstack);
538
539           int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
540           - first_dont_print;
541
542           while (--j >= 0)
543             if (baseclass == first_dont_print[j])
544               goto flush_it;
545
546           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
547         }
548
549       if (TYPE_HAS_VTABLE (type) && BASETYPE_VIA_VIRTUAL (type, i))
550         {
551           /* Assume HP/Taligent runtime convention */
552           find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
553                                 valaddr, offset, &boffset, &skip);
554           if (skip >= 0)
555             error ("Virtual base class offset not found from vtable while printing");
556           base_valaddr = valaddr;
557         }
558       else
559         {
560           boffset = baseclass_offset (type, i, valaddr + offset, address + offset);
561           skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
562
563           if (BASETYPE_VIA_VIRTUAL (type, i))
564             {
565               /* The virtual base class pointer might have been clobbered by the
566                  user program. Make sure that it still points to a valid memory
567                  location.  */
568
569               if (boffset != -1 && ((boffset + offset) < 0 || (boffset + offset) >= TYPE_LENGTH (type)))
570                 {
571                   base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
572                   if (target_read_memory (address + boffset, base_valaddr,
573                                           TYPE_LENGTH (baseclass)) != 0)
574                     skip = 1;
575                 }
576               else
577                 base_valaddr = valaddr;
578             }
579           else
580             base_valaddr = valaddr;
581         }
582
583       /* now do the printing */
584       if (pretty)
585         {
586           fprintf_filtered (stream, "\n");
587           print_spaces_filtered (2 * recurse, stream);
588         }
589       fputs_filtered ("<", stream);
590       /* Not sure what the best notation is in the case where there is no
591          baseclass name.  */
592       fputs_filtered (basename ? basename : "", stream);
593       fputs_filtered ("> = ", stream);
594
595
596       if (skip >= 1)
597         fprintf_filtered (stream, "<invalid address>");
598       else
599         cp_print_value_fields (baseclass, real_type, base_valaddr, offset + boffset, address,
600                                stream, format, recurse, pretty,
601                      (struct type **) obstack_base (&dont_print_vb_obstack),
602                                0);
603       fputs_filtered (", ", stream);
604
605     flush_it:
606       ;
607     }
608
609   if (dont_print_vb == 0)
610     {
611       /* Free the space used to deal with the printing
612          of this type from top level.  */
613       obstack_free (&dont_print_vb_obstack, last_dont_print);
614       /* Reset watermark so that we can continue protecting
615          ourselves from whatever we were protecting ourselves.  */
616       dont_print_vb_obstack = tmp_obstack;
617     }
618 }
619
620 /* Print value of a static member.
621    To avoid infinite recursion when printing a class that contains
622    a static instance of the class, we keep the addresses of all printed
623    static member classes in an obstack and refuse to print them more
624    than once.
625
626    VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
627    have the same meanings as in c_val_print.  */
628
629 static void
630 cp_print_static_field (type, val, stream, format, recurse, pretty)
631      struct type *type;
632      value_ptr val;
633      struct ui_file *stream;
634      int format;
635      int recurse;
636      enum val_prettyprint pretty;
637 {
638   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
639     {
640       CORE_ADDR *first_dont_print;
641       int i;
642
643       first_dont_print
644         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
645       i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
646         - first_dont_print;
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 seen type>",
653                               stream);
654               return;
655             }
656         }
657
658       obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
659                     sizeof (CORE_ADDR));
660
661       CHECK_TYPEDEF (type);
662       cp_print_value_fields (type, type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
663                              stream, format, recurse, pretty, NULL, 1);
664       return;
665     }
666   val_print (type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
667              stream, format, 0, recurse, pretty);
668 }
669
670 void
671 cp_print_class_member (valaddr, domain, stream, prefix)
672      char *valaddr;
673      struct type *domain;
674      struct ui_file *stream;
675      char *prefix;
676 {
677
678   /* VAL is a byte offset into the structure type DOMAIN.
679      Find the name of the field for that offset and
680      print it.  */
681   int extra = 0;
682   int bits = 0;
683   register unsigned int i;
684   unsigned len = TYPE_NFIELDS (domain);
685
686   /* @@ Make VAL into bit offset */
687
688   /* Note: HP aCC generates offsets that are the real byte offsets added
689      to a constant bias 0x20000000 (1 << 29).  This constant bias gets
690      shifted out in the code below -- joyous happenstance! */
691
692   /* Note: HP cfront uses a constant bias of 1; if we support this
693      compiler ever, we will have to adjust the computation below */
694
695   LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
696   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
697     {
698       int bitpos = TYPE_FIELD_BITPOS (domain, i);
699       QUIT;
700       if (val == bitpos)
701         break;
702       if (val < bitpos && i != 0)
703         {
704           /* Somehow pointing into a field.  */
705           i -= 1;
706           extra = (val - TYPE_FIELD_BITPOS (domain, i));
707           if (extra & 0x7)
708             bits = 1;
709           else
710             extra >>= 3;
711           break;
712         }
713     }
714   if (i < len)
715     {
716       char *name;
717       fprintf_filtered (stream, prefix);
718       name = type_name_no_tag (domain);
719       if (name)
720         fputs_filtered (name, stream);
721       else
722         c_type_print_base (domain, stream, 0, 0);
723       fprintf_filtered (stream, "::");
724       fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
725       if (extra)
726         fprintf_filtered (stream, " + %d bytes", extra);
727       if (bits)
728         fprintf_filtered (stream, " (offset in bits)");
729     }
730   else
731     fprintf_filtered (stream, "%ld", (long) (val >> 3));
732 }
733
734
735 /* This function prints out virtual table entries for a class; it
736  * recurses on the base classes to find all virtual functions
737  * available in a class.
738  *
739  * pai/1997-05-21 Note: As the name suggests, it's currently
740  * implemented for HP aCC runtime only. g++ objects are handled
741  * differently and I have made no attempt to fold that logic in
742  * here. The runtime layout is different for the two cases.  Also,
743  * this currently has only the code for non-RRBC layouts generated by
744  * the HP aCC compiler; RRBC code is stubbed out and will have to be
745  * added later. */
746
747
748 static void
749 cp_print_hpacc_virtual_table_entries (type, vfuncs, v, stream, format, recurse, pretty)
750      struct type *type;
751      int *vfuncs;
752      value_ptr v;
753      struct ui_file *stream;
754      int format;
755      int recurse;
756      enum val_prettyprint pretty;
757 {
758   int fn, oi;
759
760   /* pai: FIXME this function doesn't work. It should handle a given
761    * virtual function only once (latest redefinition in class hierarchy)
762    */
763
764   /* Recursion on other classes that can share the same vtable */
765   struct type *pbc = primary_base_class (type);
766   if (pbc)
767     cp_print_hpacc_virtual_table_entries (pbc, vfuncs, v, stream, format, recurse, pretty);
768
769   /* Now deal with vfuncs declared in this class */
770   for (fn = 0; fn < TYPE_NFN_FIELDS (type); fn++)
771     for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (type, fn); oi++)
772       if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type, fn), oi))
773         {
774           char *vf_name;
775
776           /* virtual function offset */
777           int vx = TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type, fn), oi) - 1;
778
779           /* Get the address of the vfunction entry */
780           value_ptr vf = value_copy (v);
781           if (VALUE_LAZY (vf))
782             (void) value_fetch_lazy (vf);
783           vf->aligner.contents[0] += 4 * (HP_ACC_VFUNC_START + vx);     /* adjust by offset */
784           vf = value_ind (vf);  /* get the entry */
785           VALUE_TYPE (vf) = VALUE_TYPE (v);     /* make it a pointer */
786
787           /* print out the entry */
788           val_print (VALUE_TYPE (vf), VALUE_CONTENTS (vf), 0, 0,
789                      stream, format, 0, recurse + 1, pretty);
790           vf_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi),
791                                     DMGL_ARM);  /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
792           fprintf_filtered (stream, " %s", vf_name);
793           if (--(*vfuncs) > 0)
794             fputs_filtered (", ", stream);
795         }
796 }
797
798
799
800 void
801 _initialize_cp_valprint ()
802 {
803   add_show_from_set
804     (add_set_cmd ("static-members", class_support, var_boolean,
805                   (char *) &static_field_print,
806                   "Set printing of C++ static members.",
807                   &setprintlist),
808      &showprintlist);
809   /* Turn on printing of static fields.  */
810   static_field_print = 1;
811
812   add_show_from_set
813     (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
814                   "Set printing of C++ virtual function tables.",
815                   &setprintlist),
816      &showprintlist);
817
818   add_show_from_set
819     (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
820               "Set printing of object's derived type based on vtable info.",
821                   &setprintlist),
822      &showprintlist);
823
824   /* Give people the defaults which they are used to.  */
825   objectprint = 0;
826   vtblprint = 0;
827   obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
828   obstack_specify_allocation (&dont_print_statmem_obstack,
829                               32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),
830                               xmalloc, free);
831 }