* c-lang.h, cp-valprint.c (static_field_print): Make non-static.
[platform/upstream/binutils.git] / gdb / cp-valprint.c
1 /* Support for printing C++ values for GDB, the GNU debugger.
2    Copyright 1986, 1988, 1989, 1991, 1994, 1995, 1996
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, Boston, MA 02111-1307, USA.  */
20
21 #include "defs.h"
22 #include "obstack.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "expression.h"
26 #include "value.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "demangle.h"
30 #include "annotate.h"
31 #include "gdb_string.h"
32 #include "c-lang.h"
33 #include "target.h"
34
35 int vtblprint;                  /* Controls printing of vtbl's */
36 int objectprint;                /* Controls looking up an object's derived type
37                                    using what we find in its vtables.  */
38 int static_field_print; /* Controls printing of static fields. */
39
40 static struct obstack dont_print_vb_obstack;
41 static struct obstack dont_print_statmem_obstack;
42
43 static void
44 cp_print_static_field PARAMS ((struct type *, value_ptr, GDB_FILE *, int, int,
45                                enum val_prettyprint));
46
47 static void
48 cp_print_value PARAMS ((struct type *, char *, CORE_ADDR, GDB_FILE *,
49                         int, int, enum val_prettyprint, struct type **));
50
51 void
52 cp_print_class_method (valaddr, type, stream)
53      char *valaddr;
54      struct type *type;
55      GDB_FILE *stream;
56 {
57   struct type *domain;
58   struct fn_field *f = NULL;
59   int j = 0;
60   int len2;
61   int offset;
62   char *kind = "";
63   CORE_ADDR addr;
64   struct symbol *sym;
65   unsigned len;
66   unsigned int i;
67   struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
68
69   domain = TYPE_DOMAIN_TYPE (target_type);
70   if (domain == (struct type *)NULL)
71     {
72       fprintf_filtered (stream, "<unknown>");
73       return;
74     }
75   addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
76   if (METHOD_PTR_IS_VIRTUAL (addr))
77     {
78       offset = METHOD_PTR_TO_VOFFSET (addr);
79       len = TYPE_NFN_FIELDS (domain);
80       for (i = 0; i < len; i++)
81         {
82           f = TYPE_FN_FIELDLIST1 (domain, i);
83           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
84           
85           for (j = 0; j < len2; j++)
86             {
87               QUIT;
88               if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
89                 {
90                   if (TYPE_FN_FIELD_STUB (f, j))
91                     check_stub_method (domain, i, j);
92                   kind = "virtual ";
93                   goto common;
94                 }
95             }
96         }
97     }
98   else
99     {
100       sym = find_pc_function (addr);
101       if (sym == 0)
102         {
103           error ("invalid pointer to member function");
104         }
105       len = TYPE_NFN_FIELDS (domain);
106       for (i = 0; i < len; i++)
107         {
108           f = TYPE_FN_FIELDLIST1 (domain, i);
109           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
110           
111           for (j = 0; j < len2; j++)
112             {
113               QUIT;
114               if (TYPE_FN_FIELD_STUB (f, j))
115                 check_stub_method (domain, i, j);
116               if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
117                 {
118                   goto common;
119                 }
120             }
121         }
122     }
123   common:
124   if (i < len)
125     {
126       char *demangled_name;
127
128       fprintf_filtered (stream, "&");
129       fprintf_filtered (stream, kind);
130       demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
131                                        DMGL_ANSI | DMGL_PARAMS);
132       if (demangled_name == NULL)
133         fprintf_filtered (stream, "<badly mangled name %s>",
134                           TYPE_FN_FIELD_PHYSNAME (f, j));
135       else
136         {
137           fputs_filtered (demangled_name, stream);
138           free (demangled_name);
139         }
140     }
141   else
142     {
143       fprintf_filtered (stream, "(");
144       type_print (type, "", stream, -1);
145       fprintf_filtered (stream, ") %d", (int) addr >> 3);
146     }
147 }
148
149 /* This was what it was for gcc 2.4.5 and earlier.  */
150 static const char vtbl_ptr_name_old[] =
151   { CPLUS_MARKER,'v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
152 /* It was changed to this after 2.4.5.  */
153 const char vtbl_ptr_name[] =
154   { '_','_','v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
155
156 /* Return truth value for assertion that TYPE is of the type
157    "pointer to virtual function".  */
158
159 int
160 cp_is_vtbl_ptr_type(type)
161      struct type *type;
162 {
163   char *typename = type_name_no_tag (type);
164
165   return (typename != NULL
166           && (STREQ (typename, vtbl_ptr_name)
167               || STREQ (typename, vtbl_ptr_name_old)));
168 }
169
170 /* Return truth value for the assertion that TYPE is of the type
171    "pointer to virtual function table".  */
172
173 int
174 cp_is_vtbl_member(type)
175      struct type *type;
176 {
177   if (TYPE_CODE (type) == TYPE_CODE_PTR)
178     {
179       type = TYPE_TARGET_TYPE (type);
180       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
181         {
182           type = TYPE_TARGET_TYPE (type);
183           if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
184               || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
185             {
186               /* Virtual functions tables are full of pointers
187                  to virtual functions. */
188               return cp_is_vtbl_ptr_type (type);
189             }
190         }
191     }
192   return 0;
193 }
194
195 /* Mutually recursive subroutines of cp_print_value and c_val_print to
196    print out a structure's fields: cp_print_value_fields and cp_print_value.
197   
198    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
199    same meanings as in cp_print_value and c_val_print.
200
201    DONT_PRINT is an array of baseclass types that we
202    should not print, or zero if called from top level.  */
203
204 void
205 cp_print_value_fields (type, valaddr, address, stream, format, recurse, pretty,
206                        dont_print_vb, dont_print_statmem)
207      struct type *type;
208      char *valaddr;
209      CORE_ADDR address;
210      GDB_FILE *stream;
211      int format;
212      int recurse;
213      enum val_prettyprint pretty;
214      struct type **dont_print_vb;
215      int dont_print_statmem;
216 {
217   int i, len, n_baseclasses;
218   struct obstack tmp_obstack;
219   char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
220
221   CHECK_TYPEDEF (type);
222
223   fprintf_filtered (stream, "{");
224   len = TYPE_NFIELDS (type);
225   n_baseclasses = TYPE_N_BASECLASSES (type);
226
227   /* Print out baseclasses such that we don't print
228      duplicates of virtual baseclasses.  */
229   if (n_baseclasses > 0)
230     cp_print_value (type, valaddr, address, stream,
231                     format, recurse+1, pretty, dont_print_vb);
232
233   if (!len && n_baseclasses == 1)
234     fprintf_filtered (stream, "<No data fields>");
235   else
236     {
237       extern int inspect_it;
238       int fields_seen = 0;
239
240       if (dont_print_statmem == 0)
241         {
242           /* If we're at top level, carve out a completely fresh
243              chunk of the obstack and use that until this particular
244              invocation returns.  */
245           tmp_obstack = dont_print_statmem_obstack;
246           obstack_finish (&dont_print_statmem_obstack);
247         }
248
249       for (i = n_baseclasses; i < len; i++)
250         {
251           /* If requested, skip printing of static fields.  */
252           if (!static_field_print && TYPE_FIELD_STATIC (type, i))
253             continue;
254           if (fields_seen)
255             fprintf_filtered (stream, ", ");
256           else if (n_baseclasses > 0)
257             {
258               if (pretty)
259                 {
260                   fprintf_filtered (stream, "\n");
261                   print_spaces_filtered (2 + 2 * recurse, stream);
262                   fputs_filtered ("members of ", stream);
263                   fputs_filtered (type_name_no_tag (type), stream);
264                   fputs_filtered (": ", stream);
265                 }
266             }
267           fields_seen = 1;
268
269           if (pretty)
270             {
271               fprintf_filtered (stream, "\n");
272               print_spaces_filtered (2 + 2 * recurse, stream);
273             }
274           else 
275             {
276               wrap_here (n_spaces (2 + 2 * recurse));
277             }
278           if (inspect_it)
279             {
280               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
281                 fputs_filtered ("\"( ptr \"", stream);
282               else
283                 fputs_filtered ("\"( nodef \"", stream);
284               if (TYPE_FIELD_STATIC (type, i))
285                 fputs_filtered ("static ", stream);
286               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
287                                        language_cplus,
288                                        DMGL_PARAMS | DMGL_ANSI);
289               fputs_filtered ("\" \"", stream);
290               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
291                                        language_cplus,
292                                        DMGL_PARAMS | DMGL_ANSI);
293               fputs_filtered ("\") \"", stream);
294             }
295           else
296             {
297               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
298
299               if (TYPE_FIELD_STATIC (type, i))
300                 fputs_filtered ("static ", stream);
301               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
302                                        language_cplus,
303                                        DMGL_PARAMS | DMGL_ANSI);
304               annotate_field_name_end ();
305               fputs_filtered (" = ", stream);
306               annotate_field_value ();
307             }
308
309           if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
310             {
311               value_ptr v;
312
313               /* Bitfields require special handling, especially due to byte
314                  order problems.  */
315               if (TYPE_FIELD_IGNORE (type, i))
316                 {
317                    fputs_filtered ("<optimized out or zero length>", stream);
318                 }
319               else
320                 {
321                    v = value_from_longest (TYPE_FIELD_TYPE (type, i),
322                                    unpack_field_as_long (type, valaddr, i));
323
324                    val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0,
325                               stream, format, 0, recurse + 1, pretty);
326                 }
327             }
328           else
329             {
330               if (TYPE_FIELD_IGNORE (type, i))
331                 {
332                    fputs_filtered ("<optimized out or zero length>", stream);
333                 }
334               else if (TYPE_FIELD_STATIC (type, i))
335                 {
336                   value_ptr v = value_static_field (type, i);
337                   if (v == NULL)
338                     fputs_filtered ("<optimized out>", stream);
339                   else
340                     cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
341                                            stream, format, recurse + 1,
342                                            pretty);
343                 }
344               else
345                 {
346                    val_print (TYPE_FIELD_TYPE (type, i), 
347                               valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
348                               address + TYPE_FIELD_BITPOS (type, i) / 8,
349                               stream, format, 0, recurse + 1, pretty);
350                 }
351             }
352           annotate_field_end ();
353         }
354
355       if (dont_print_statmem == 0)
356         {
357           /* Free the space used to deal with the printing
358              of the members from top level.  */
359           obstack_free (&dont_print_statmem_obstack, last_dont_print);
360           dont_print_statmem_obstack = tmp_obstack;
361         }
362
363       if (pretty)
364         {
365           fprintf_filtered (stream, "\n");
366           print_spaces_filtered (2 * recurse, stream);
367         }
368     }
369   fprintf_filtered (stream, "}");
370 }
371
372 /* Special val_print routine to avoid printing multiple copies of virtual
373    baseclasses.  */
374
375 static void
376 cp_print_value (type, valaddr, address, stream, format, recurse, pretty,
377                 dont_print_vb)
378      struct type *type;
379      char *valaddr;
380      CORE_ADDR address;
381      GDB_FILE *stream;
382      int format;
383      int recurse;
384      enum val_prettyprint pretty;
385      struct type **dont_print_vb;
386 {
387   struct obstack tmp_obstack;
388   struct type **last_dont_print
389     = (struct type **)obstack_next_free (&dont_print_vb_obstack);
390   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
391
392   if (dont_print_vb == 0)
393     {
394       /* If we're at top level, carve out a completely fresh
395          chunk of the obstack and use that until this particular
396          invocation returns.  */
397       tmp_obstack = dont_print_vb_obstack;
398       /* Bump up the high-water mark.  Now alpha is omega.  */
399       obstack_finish (&dont_print_vb_obstack);
400     }
401
402   for (i = 0; i < n_baseclasses; i++)
403     {
404       int boffset;
405       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
406       char *basename = TYPE_NAME (baseclass);
407       char *base_valaddr;
408
409       if (BASETYPE_VIA_VIRTUAL (type, i))
410         {
411           struct type **first_dont_print
412             = (struct type **)obstack_base (&dont_print_vb_obstack);
413
414           int j = (struct type **)obstack_next_free (&dont_print_vb_obstack)
415             - first_dont_print;
416
417           while (--j >= 0)
418             if (baseclass == first_dont_print[j])
419               goto flush_it;
420
421           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
422         }
423
424       boffset = baseclass_offset (type, i , valaddr, address);
425
426       if (pretty)
427         {
428           fprintf_filtered (stream, "\n");
429           print_spaces_filtered (2 * recurse, stream);
430         }
431       fputs_filtered ("<", stream);
432       /* Not sure what the best notation is in the case where there is no
433          baseclass name.  */
434       fputs_filtered (basename ? basename : "", stream);
435       fputs_filtered ("> = ", stream);
436
437       /* The virtual base class pointer might have been clobbered by the
438          user program. Make sure that it still points to a valid memory
439          location.  */
440
441       if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type)))
442         {
443           base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
444           if (target_read_memory (address + boffset, base_valaddr,
445                                   TYPE_LENGTH (baseclass)) != 0)
446             boffset = -1;
447         }
448       else
449         base_valaddr = valaddr + boffset;
450
451       if (boffset == -1)
452         fprintf_filtered (stream, "<invalid address>");
453       else
454         cp_print_value_fields (baseclass, base_valaddr, address + boffset,
455                                stream, format, recurse, pretty,
456                                (struct type **) obstack_base (&dont_print_vb_obstack),
457                                0);
458       fputs_filtered (", ", stream);
459
460     flush_it:
461       ;
462     }
463
464   if (dont_print_vb == 0)
465     {
466       /* Free the space used to deal with the printing
467          of this type from top level.  */
468       obstack_free (&dont_print_vb_obstack, last_dont_print);
469       /* Reset watermark so that we can continue protecting
470          ourselves from whatever we were protecting ourselves.  */
471       dont_print_vb_obstack = tmp_obstack;
472     }
473 }
474
475 /* Print value of a static member.
476    To avoid infinite recursion when printing a class that contains
477    a static instance of the class, we keep the addresses of all printed
478    static member classes in an obstack and refuse to print them more
479    than once.
480
481    VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
482    have the same meanings as in c_val_print.  */
483
484 static void
485 cp_print_static_field (type, val, stream, format, recurse, pretty)
486      struct type *type;
487      value_ptr val;
488      GDB_FILE *stream;
489      int format;
490      int recurse;
491      enum val_prettyprint pretty;
492 {
493   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
494     {
495       CORE_ADDR *first_dont_print;
496       int i;
497
498       first_dont_print
499         = (CORE_ADDR *)obstack_base (&dont_print_statmem_obstack);
500       i = (CORE_ADDR *)obstack_next_free (&dont_print_statmem_obstack)
501         - first_dont_print;
502
503       while (--i >= 0)
504         {
505           if (VALUE_ADDRESS (val) == first_dont_print[i])
506             {
507               fputs_filtered ("<same as static member of an already seen type>",
508                               stream);
509               return;
510             }
511         }
512
513       obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
514                     sizeof (CORE_ADDR));
515
516       CHECK_TYPEDEF (type);
517       cp_print_value_fields (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
518                              stream, format, recurse, pretty, NULL, 1);
519       return;
520     }
521   val_print (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
522              stream, format, 0, recurse, pretty);
523 }
524
525 void
526 cp_print_class_member (valaddr, domain, stream, prefix)
527      char *valaddr;
528      struct type *domain;
529      GDB_FILE *stream;
530      char *prefix;
531 {
532   
533   /* VAL is a byte offset into the structure type DOMAIN.
534      Find the name of the field for that offset and
535      print it.  */
536   int extra = 0;
537   int bits = 0;
538   register unsigned int i;
539   unsigned len = TYPE_NFIELDS (domain);
540   /* @@ Make VAL into bit offset */
541   LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
542   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
543     {
544       int bitpos = TYPE_FIELD_BITPOS (domain, i);
545       QUIT;
546       if (val == bitpos)
547         break;
548       if (val < bitpos && i != 0)
549         {
550           /* Somehow pointing into a field.  */
551           i -= 1;
552           extra = (val - TYPE_FIELD_BITPOS (domain, i));
553           if (extra & 0x7)
554             bits = 1;
555           else
556             extra >>= 3;
557           break;
558         }
559     }
560   if (i < len)
561     {
562       char *name;
563       fprintf_filtered (stream, prefix);
564       name = type_name_no_tag (domain);
565       if (name)
566         fputs_filtered (name, stream);
567       else
568         c_type_print_base (domain, stream, 0, 0);
569       fprintf_filtered (stream, "::");
570       fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
571       if (extra)
572         fprintf_filtered (stream, " + %d bytes", extra);
573       if (bits)
574         fprintf_filtered (stream, " (offset in bits)");
575     }
576   else
577     fprintf_filtered (stream, "%d", val >> 3);
578 }
579
580 void
581 _initialize_cp_valprint ()
582 {
583   add_show_from_set
584     (add_set_cmd ("static-members", class_support, var_boolean,
585                   (char *)&static_field_print,
586                   "Set printing of C++ static members.",
587                   &setprintlist),
588      &showprintlist);
589   /* Turn on printing of static fields.  */
590   static_field_print = 1;
591
592   add_show_from_set
593     (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
594                   "Set printing of C++ virtual function tables.",
595                   &setprintlist),
596      &showprintlist);
597
598   add_show_from_set
599     (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
600           "Set printing of object's derived type based on vtable info.",
601                   &setprintlist),
602      &showprintlist);
603
604   /* Give people the defaults which they are used to.  */
605   objectprint = 0;
606   vtblprint = 0;
607   obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
608   obstack_specify_allocation (&dont_print_statmem_obstack,
609                               32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),
610                               xmalloc, free);
611 }