Add mingw I64 support for printing long and long long values
[external/binutils.git] / binutils / prdbg.c
1 /* prdbg.c -- Print out generic debugging information.
2    Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2006, 2007, 2008
3    Free Software Foundation, Inc.
4    Written by Ian Lance Taylor <ian@cygnus.com>.
5    Tags style generation written by Salvador E. Tropea <set@computer.org>.
6
7    This file is part of GNU Binutils.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22    02110-1301, USA.  */
23
24 /* This file prints out the generic debugging information, by
25    supplying a set of routines to debug_write.  */
26
27 #include "sysdep.h"
28 #include <assert.h>
29 #include "bfd.h"
30 #include "libiberty.h"
31 #include "demangle.h"
32 #include "debug.h"
33 #include "budbg.h"
34
35 /* This is the structure we use as a handle for these routines.  */
36
37 struct pr_handle
38 {
39   /* File to print information to.  */
40   FILE *f;
41   /* Current indentation level.  */
42   unsigned int indent;
43   /* Type stack.  */
44   struct pr_stack *stack;
45   /* Parameter number we are about to output.  */
46   int parameter;
47   /* The following are used only by the tags code (tg_).  */
48   /* Name of the file we are using.  */
49   char *filename;
50   /* The BFD.  */
51   bfd *abfd;
52   /* The symbols table for this BFD.  */
53   asymbol **syms;
54   /* Pointer to a function to demangle symbols.  */
55   char *(*demangler) (bfd *, const char *, int);
56 };
57
58 /* The type stack.  */
59
60 struct pr_stack
61 {
62   /* Next element on the stack.  */
63   struct pr_stack *next;
64   /* This element.  */
65   char *type;
66   /* Current visibility of fields if this is a class.  */
67   enum debug_visibility visibility;
68   /* Name of the current method we are handling.  */
69   const char *method;
70   /* The following are used only by the tags code (tg_).  */
71   /* Type for the container (struct, union, class, union class).  */
72   const char *flavor;
73   /* A comma separated list of parent classes.  */
74   char *parents;
75   /* How many parents contains parents.  */
76   int num_parents;
77 };
78
79 static void indent (struct pr_handle *);
80 static bfd_boolean push_type (struct pr_handle *, const char *);
81 static bfd_boolean prepend_type (struct pr_handle *, const char *);
82 static bfd_boolean append_type (struct pr_handle *, const char *);
83 static bfd_boolean substitute_type (struct pr_handle *, const char *);
84 static bfd_boolean indent_type (struct pr_handle *);
85 static char *pop_type (struct pr_handle *);
86 static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
87 static bfd_boolean pr_fix_visibility
88   (struct pr_handle *, enum debug_visibility);
89 static bfd_boolean pr_start_compilation_unit (void *, const char *);
90 static bfd_boolean pr_start_source (void *, const char *);
91 static bfd_boolean pr_empty_type (void *);
92 static bfd_boolean pr_void_type (void *);
93 static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
94 static bfd_boolean pr_float_type (void *, unsigned int);
95 static bfd_boolean pr_complex_type (void *, unsigned int);
96 static bfd_boolean pr_bool_type (void *, unsigned int);
97 static bfd_boolean pr_enum_type
98   (void *, const char *, const char **, bfd_signed_vma *);
99 static bfd_boolean pr_pointer_type (void *);
100 static bfd_boolean pr_function_type (void *, int, bfd_boolean);
101 static bfd_boolean pr_reference_type (void *);
102 static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
103 static bfd_boolean pr_array_type
104   (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
105 static bfd_boolean pr_set_type (void *, bfd_boolean);
106 static bfd_boolean pr_offset_type (void *);
107 static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
108 static bfd_boolean pr_const_type (void *);
109 static bfd_boolean pr_volatile_type (void *);
110 static bfd_boolean pr_start_struct_type
111   (void *, const char *, unsigned int, bfd_boolean, unsigned int);
112 static bfd_boolean pr_struct_field
113   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
114 static bfd_boolean pr_end_struct_type (void *);
115 static bfd_boolean pr_start_class_type
116   (void *, const char *, unsigned int, bfd_boolean, unsigned int,
117    bfd_boolean, bfd_boolean);
118 static bfd_boolean pr_class_static_member
119   (void *, const char *, const char *, enum debug_visibility);
120 static bfd_boolean pr_class_baseclass
121   (void *, bfd_vma, bfd_boolean, enum debug_visibility);
122 static bfd_boolean pr_class_start_method (void *, const char *);
123 static bfd_boolean pr_class_method_variant
124   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
125    bfd_vma, bfd_boolean);
126 static bfd_boolean pr_class_static_method_variant
127   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
128 static bfd_boolean pr_class_end_method (void *);
129 static bfd_boolean pr_end_class_type (void *);
130 static bfd_boolean pr_typedef_type (void *, const char *);
131 static bfd_boolean pr_tag_type
132   (void *, const char *, unsigned int, enum debug_type_kind);
133 static bfd_boolean pr_typdef (void *, const char *);
134 static bfd_boolean pr_tag (void *, const char *);
135 static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
136 static bfd_boolean pr_float_constant (void *, const char *, double);
137 static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
138 static bfd_boolean pr_variable
139   (void *, const char *, enum debug_var_kind, bfd_vma);
140 static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
141 static bfd_boolean pr_function_parameter
142   (void *, const char *, enum debug_parm_kind, bfd_vma);
143 static bfd_boolean pr_start_block (void *, bfd_vma);
144 static bfd_boolean pr_end_block (void *, bfd_vma);
145 static bfd_boolean pr_end_function (void *);
146 static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
147 static bfd_boolean append_parent (struct pr_handle *, const char *);
148 /* Only used by tg_ code.  */
149 static bfd_boolean tg_fix_visibility
150   (struct pr_handle *, enum debug_visibility);
151 static void find_address_in_section (bfd *, asection *, void *);
152 static void translate_addresses (bfd *, char *, FILE *, asymbol **);
153 static const char *visibility_name (enum debug_visibility);
154 /* Tags style replacements.  */
155 static bfd_boolean tg_start_compilation_unit (void *, const char *);
156 static bfd_boolean tg_start_source (void *, const char *);
157 static bfd_boolean tg_enum_type
158   (void *, const char *, const char **, bfd_signed_vma *);
159 static bfd_boolean tg_start_struct_type
160   (void *, const char *, unsigned int, bfd_boolean, unsigned int);
161 static bfd_boolean pr_struct_field
162   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
163 static bfd_boolean tg_struct_field
164   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
165 static bfd_boolean tg_struct_field
166   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
167 static bfd_boolean tg_end_struct_type (void *);
168 static bfd_boolean tg_start_class_type
169   (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
170 static bfd_boolean tg_class_static_member
171   (void *, const char *, const char *, enum debug_visibility);
172 static bfd_boolean tg_class_baseclass
173   (void *, bfd_vma, bfd_boolean, enum debug_visibility);
174 static bfd_boolean tg_class_method_variant
175   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
176 static bfd_boolean tg_class_static_method_variant
177   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
178 static bfd_boolean tg_end_class_type (void *);
179 static bfd_boolean tg_tag_type
180   (void *, const char *, unsigned int, enum debug_type_kind);
181 static bfd_boolean tg_typdef (void *, const char *);
182 static bfd_boolean tg_tag (void *, const char *);
183 static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
184 static bfd_boolean tg_float_constant (void *, const char *, double);
185 static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
186 static bfd_boolean tg_variable
187   (void *, const char *, enum debug_var_kind, bfd_vma);
188 static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
189 static bfd_boolean tg_function_parameter
190   (void *, const char *, enum debug_parm_kind, bfd_vma);
191 static bfd_boolean tg_start_block (void *, bfd_vma);
192 static bfd_boolean tg_end_block (void *, bfd_vma);
193 static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
194 \f
195 static const struct debug_write_fns pr_fns =
196 {
197   pr_start_compilation_unit,
198   pr_start_source,
199   pr_empty_type,
200   pr_void_type,
201   pr_int_type,
202   pr_float_type,
203   pr_complex_type,
204   pr_bool_type,
205   pr_enum_type,
206   pr_pointer_type,
207   pr_function_type,
208   pr_reference_type,
209   pr_range_type,
210   pr_array_type,
211   pr_set_type,
212   pr_offset_type,
213   pr_method_type,
214   pr_const_type,
215   pr_volatile_type,
216   pr_start_struct_type,
217   pr_struct_field,
218   pr_end_struct_type,
219   pr_start_class_type,
220   pr_class_static_member,
221   pr_class_baseclass,
222   pr_class_start_method,
223   pr_class_method_variant,
224   pr_class_static_method_variant,
225   pr_class_end_method,
226   pr_end_class_type,
227   pr_typedef_type,
228   pr_tag_type,
229   pr_typdef,
230   pr_tag,
231   pr_int_constant,
232   pr_float_constant,
233   pr_typed_constant,
234   pr_variable,
235   pr_start_function,
236   pr_function_parameter,
237   pr_start_block,
238   pr_end_block,
239   pr_end_function,
240   pr_lineno
241 };
242 \f
243 static const struct debug_write_fns tg_fns =
244 {
245   tg_start_compilation_unit,
246   tg_start_source,
247   pr_empty_type,                /* Same, push_type.  */
248   pr_void_type,                 /* Same, push_type.  */
249   pr_int_type,                  /* Same, push_type.  */
250   pr_float_type,                /* Same, push_type.  */
251   pr_complex_type,              /* Same, push_type.  */
252   pr_bool_type,                 /* Same, push_type.  */
253   tg_enum_type,
254   pr_pointer_type,              /* Same, changes to pointer.  */
255   pr_function_type,             /* Same, push_type.  */
256   pr_reference_type,            /* Same, changes to reference.  */
257   pr_range_type,                /* FIXME: What's that?.  */
258   pr_array_type,                /* Same, push_type.  */
259   pr_set_type,                  /* FIXME: What's that?.  */
260   pr_offset_type,               /* FIXME: What's that?.  */
261   pr_method_type,               /* Same.  */
262   pr_const_type,                /* Same, changes to const.  */
263   pr_volatile_type,             /* Same, changes to volatile.  */
264   tg_start_struct_type,
265   tg_struct_field,
266   tg_end_struct_type,
267   tg_start_class_type,
268   tg_class_static_member,
269   tg_class_baseclass,
270   pr_class_start_method,        /* Same, remembers that's a method.  */
271   tg_class_method_variant,
272   tg_class_static_method_variant,
273   pr_class_end_method,          /* Same, forgets that's a method.  */
274   tg_end_class_type,
275   pr_typedef_type,              /* Same, just push type.  */
276   tg_tag_type,
277   tg_typdef,
278   tg_tag,
279   tg_int_constant,              /* Untested.  */
280   tg_float_constant,            /* Untested.  */
281   tg_typed_constant,            /* Untested.  */
282   tg_variable,
283   tg_start_function,
284   tg_function_parameter,
285   tg_start_block,
286   tg_end_block,
287   pr_end_function,              /* Same, does nothing.  */
288   tg_lineno
289 };
290 \f
291 /* Print out the generic debugging information recorded in dhandle.  */
292
293 bfd_boolean
294 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
295                       void *demangler, bfd_boolean as_tags)
296 {
297   struct pr_handle info;
298
299   info.f = f;
300   info.indent = 0;
301   info.stack = NULL;
302   info.parameter = 0;
303   info.filename = NULL;
304   info.abfd = abfd;
305   info.syms = syms;
306   info.demangler = demangler;
307
308   if (as_tags)
309     {
310       fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);
311       fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);
312       fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);
313       fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);
314     }
315
316   return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
317     : debug_write (dhandle, &pr_fns, (void *) & info);
318 }
319 \f
320 /* Indent to the current indentation level.  */
321
322 static void
323 indent (struct pr_handle *info)
324 {
325   unsigned int i;
326
327   for (i = 0; i < info->indent; i++)
328     putc (' ', info->f);
329 }
330
331 /* Push a type on the type stack.  */
332
333 static bfd_boolean
334 push_type (struct pr_handle *info, const char *type)
335 {
336   struct pr_stack *n;
337
338   if (type == NULL)
339     return FALSE;
340
341   n = (struct pr_stack *) xmalloc (sizeof *n);
342   memset (n, 0, sizeof *n);
343
344   n->type = xstrdup (type);
345   n->visibility = DEBUG_VISIBILITY_IGNORE;
346   n->method = NULL;
347   n->next = info->stack;
348   info->stack = n;
349
350   return TRUE;
351 }
352
353 /* Prepend a string onto the type on the top of the type stack.  */
354
355 static bfd_boolean
356 prepend_type (struct pr_handle *info, const char *s)
357 {
358   char *n;
359
360   assert (info->stack != NULL);
361
362   n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
363   sprintf (n, "%s%s", s, info->stack->type);
364   free (info->stack->type);
365   info->stack->type = n;
366
367   return TRUE;
368 }
369
370 /* Append a string to the type on the top of the type stack.  */
371
372 static bfd_boolean
373 append_type (struct pr_handle *info, const char *s)
374 {
375   unsigned int len;
376
377   if (s == NULL)
378     return FALSE;
379
380   assert (info->stack != NULL);
381
382   len = strlen (info->stack->type);
383   info->stack->type = (char *) xrealloc (info->stack->type,
384                                          len + strlen (s) + 1);
385   strcpy (info->stack->type + len, s);
386
387   return TRUE;
388 }
389
390 /* Append a string to the parents on the top of the type stack.  */
391
392 static bfd_boolean
393 append_parent (struct pr_handle *info, const char *s)
394 {
395   unsigned int len;
396
397   if (s == NULL)
398     return FALSE;
399
400   assert (info->stack != NULL);
401
402   len = info->stack->parents ? strlen (info->stack->parents) : 0;
403   info->stack->parents = (char *) xrealloc (info->stack->parents,
404                                             len + strlen (s) + 1);
405   strcpy (info->stack->parents + len, s);
406
407   return TRUE;
408 }
409
410 /* We use an underscore to indicate where the name should go in a type
411    string.  This function substitutes a string for the underscore.  If
412    there is no underscore, the name follows the type.  */
413
414 static bfd_boolean
415 substitute_type (struct pr_handle *info, const char *s)
416 {
417   char *u;
418
419   assert (info->stack != NULL);
420
421   u = strchr (info->stack->type, '|');
422   if (u != NULL)
423     {
424       char *n;
425
426       n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
427
428       memcpy (n, info->stack->type, u - info->stack->type);
429       strcpy (n + (u - info->stack->type), s);
430       strcat (n, u + 1);
431
432       free (info->stack->type);
433       info->stack->type = n;
434
435       return TRUE;
436     }
437
438   if (strchr (s, '|') != NULL
439       && (strchr (info->stack->type, '{') != NULL
440           || strchr (info->stack->type, '(') != NULL))
441     {
442       if (! prepend_type (info, "(")
443           || ! append_type (info, ")"))
444         return FALSE;
445     }
446
447   if (*s == '\0')
448     return TRUE;
449
450   return (append_type (info, " ")
451           && append_type (info, s));
452 }
453
454 /* Indent the type at the top of the stack by appending spaces.  */
455
456 static bfd_boolean
457 indent_type (struct pr_handle *info)
458 {
459   unsigned int i;
460
461   for (i = 0; i < info->indent; i++)
462     {
463       if (! append_type (info, " "))
464         return FALSE;
465     }
466
467   return TRUE;
468 }
469
470 /* Pop a type from the type stack.  */
471
472 static char *
473 pop_type (struct pr_handle *info)
474 {
475   struct pr_stack *o;
476   char *ret;
477
478   assert (info->stack != NULL);
479
480   o = info->stack;
481   info->stack = o->next;
482   ret = o->type;
483   free (o);
484
485   return ret;
486 }
487
488 /* Print a VMA value into a string.  */
489
490 static void
491 print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
492 {
493   if (sizeof (vma) <= sizeof (unsigned long))
494     {
495       if (hexp)
496         sprintf (buf, "0x%lx", (unsigned long) vma);
497       else if (unsignedp)
498         sprintf (buf, "%lu", (unsigned long) vma);
499       else
500         sprintf (buf, "%ld", (long) vma);
501     }
502 #if BFD_HOST_64BIT_LONG_LONG
503   else if (sizeof (vma) <= sizeof (unsigned long long))
504     {
505 #ifndef __MSVCRT__
506       if (hexp)
507         sprintf (buf, "0x%llx", (unsigned long long) vma);
508       else if (unsignedp)
509         sprintf (buf, "%llu", (unsigned long long) vma);
510       else
511         sprintf (buf, "%lld", (long long) vma);
512 #else
513       if (hexp)
514         sprintf (buf, "0x%I64x", (unsigned long long) vma);
515       else if (unsignedp)
516         sprintf (buf, "%I64u", (unsigned long long) vma);
517       else
518         sprintf (buf, "%I64d", (long long) vma);
519 #endif
520     }
521 #endif
522   else
523     {
524       buf[0] = '0';
525       buf[1] = 'x';
526       sprintf_vma (buf + 2, vma);
527     }
528 }
529 \f
530 /* Start a new compilation unit.  */
531
532 static bfd_boolean
533 pr_start_compilation_unit (void *p, const char *filename)
534 {
535   struct pr_handle *info = (struct pr_handle *) p;
536
537   assert (info->indent == 0);
538
539   fprintf (info->f, "%s:\n", filename);
540
541   return TRUE;
542 }
543
544 /* Start a source file within a compilation unit.  */
545
546 static bfd_boolean
547 pr_start_source (void *p, const char *filename)
548 {
549   struct pr_handle *info = (struct pr_handle *) p;
550
551   assert (info->indent == 0);
552
553   fprintf (info->f, " %s:\n", filename);
554
555   return TRUE;
556 }
557
558 /* Push an empty type onto the type stack.  */
559
560 static bfd_boolean
561 pr_empty_type (void *p)
562 {
563   struct pr_handle *info = (struct pr_handle *) p;
564
565   return push_type (info, "<undefined>");
566 }
567
568 /* Push a void type onto the type stack.  */
569
570 static bfd_boolean
571 pr_void_type (void *p)
572 {
573   struct pr_handle *info = (struct pr_handle *) p;
574
575   return push_type (info, "void");
576 }
577
578 /* Push an integer type onto the type stack.  */
579
580 static bfd_boolean
581 pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
582 {
583   struct pr_handle *info = (struct pr_handle *) p;
584   char ab[10];
585
586   sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
587   return push_type (info, ab);
588 }
589
590 /* Push a floating type onto the type stack.  */
591
592 static bfd_boolean
593 pr_float_type (void *p, unsigned int size)
594 {
595   struct pr_handle *info = (struct pr_handle *) p;
596   char ab[10];
597
598   if (size == 4)
599     return push_type (info, "float");
600   else if (size == 8)
601     return push_type (info, "double");
602
603   sprintf (ab, "float%d", size * 8);
604   return push_type (info, ab);
605 }
606
607 /* Push a complex type onto the type stack.  */
608
609 static bfd_boolean
610 pr_complex_type (void *p, unsigned int size)
611 {
612   struct pr_handle *info = (struct pr_handle *) p;
613
614   if (! pr_float_type (p, size))
615     return FALSE;
616
617   return prepend_type (info, "complex ");
618 }
619
620 /* Push a bfd_boolean type onto the type stack.  */
621
622 static bfd_boolean
623 pr_bool_type (void *p, unsigned int size)
624 {
625   struct pr_handle *info = (struct pr_handle *) p;
626   char ab[10];
627
628   sprintf (ab, "bool%d", size * 8);
629
630   return push_type (info, ab);
631 }
632
633 /* Push an enum type onto the type stack.  */
634
635 static bfd_boolean
636 pr_enum_type (void *p, const char *tag, const char **names,
637               bfd_signed_vma *values)
638 {
639   struct pr_handle *info = (struct pr_handle *) p;
640   unsigned int i;
641   bfd_signed_vma val;
642
643   if (! push_type (info, "enum "))
644     return FALSE;
645   if (tag != NULL)
646     {
647       if (! append_type (info, tag)
648           || ! append_type (info, " "))
649         return FALSE;
650     }
651   if (! append_type (info, "{ "))
652     return FALSE;
653
654   if (names == NULL)
655     {
656       if (! append_type (info, "/* undefined */"))
657         return FALSE;
658     }
659   else
660     {
661       val = 0;
662       for (i = 0; names[i] != NULL; i++)
663         {
664           if (i > 0)
665             {
666               if (! append_type (info, ", "))
667                 return FALSE;
668             }
669
670           if (! append_type (info, names[i]))
671             return FALSE;
672
673           if (values[i] != val)
674             {
675               char ab[20];
676
677               print_vma (values[i], ab, FALSE, FALSE);
678               if (! append_type (info, " = ")
679                   || ! append_type (info, ab))
680                 return FALSE;
681               val = values[i];
682             }
683
684           ++val;
685         }
686     }
687
688   return append_type (info, " }");
689 }
690
691 /* Turn the top type on the stack into a pointer.  */
692
693 static bfd_boolean
694 pr_pointer_type (void *p)
695 {
696   struct pr_handle *info = (struct pr_handle *) p;
697   char *s;
698
699   assert (info->stack != NULL);
700
701   s = strchr (info->stack->type, '|');
702   if (s != NULL && s[1] == '[')
703     return substitute_type (info, "(*|)");
704   return substitute_type (info, "*|");
705 }
706
707 /* Turn the top type on the stack into a function returning that type.  */
708
709 static bfd_boolean
710 pr_function_type (void *p, int argcount, bfd_boolean varargs)
711 {
712   struct pr_handle *info = (struct pr_handle *) p;
713   char **arg_types;
714   unsigned int len;
715   char *s;
716
717   assert (info->stack != NULL);
718
719   len = 10;
720
721   if (argcount <= 0)
722     {
723       arg_types = NULL;
724       len += 15;
725     }
726   else
727     {
728       int i;
729
730       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
731       for (i = argcount - 1; i >= 0; i--)
732         {
733           if (! substitute_type (info, ""))
734             return FALSE;
735           arg_types[i] = pop_type (info);
736           if (arg_types[i] == NULL)
737             return FALSE;
738           len += strlen (arg_types[i]) + 2;
739         }
740       if (varargs)
741         len += 5;
742     }
743
744   /* Now the return type is on the top of the stack.  */
745
746   s = xmalloc (len);
747   LITSTRCPY (s, "(|) (");
748
749   if (argcount < 0)
750     strcat (s, "/* unknown */");
751   else
752     {
753       int i;
754
755       for (i = 0; i < argcount; i++)
756         {
757           if (i > 0)
758             strcat (s, ", ");
759           strcat (s, arg_types[i]);
760         }
761       if (varargs)
762         {
763           if (i > 0)
764             strcat (s, ", ");
765           strcat (s, "...");
766         }
767       if (argcount > 0)
768         free (arg_types);
769     }
770
771   strcat (s, ")");
772
773   if (! substitute_type (info, s))
774     return FALSE;
775
776   free (s);
777
778   return TRUE;
779 }
780
781 /* Turn the top type on the stack into a reference to that type.  */
782
783 static bfd_boolean
784 pr_reference_type (void *p)
785 {
786   struct pr_handle *info = (struct pr_handle *) p;
787
788   assert (info->stack != NULL);
789
790   return substitute_type (info, "&|");
791 }
792
793 /* Make a range type.  */
794
795 static bfd_boolean
796 pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
797 {
798   struct pr_handle *info = (struct pr_handle *) p;
799   char abl[20], abu[20];
800
801   assert (info->stack != NULL);
802
803   if (! substitute_type (info, ""))
804     return FALSE;
805
806   print_vma (lower, abl, FALSE, FALSE);
807   print_vma (upper, abu, FALSE, FALSE);
808
809   return (prepend_type (info, "range (")
810           && append_type (info, "):")
811           && append_type (info, abl)
812           && append_type (info, ":")
813           && append_type (info, abu));
814 }
815
816 /* Make an array type.  */
817
818 static bfd_boolean
819 pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
820                bfd_boolean stringp)
821 {
822   struct pr_handle *info = (struct pr_handle *) p;
823   char *range_type;
824   char abl[20], abu[20], ab[50];
825
826   range_type = pop_type (info);
827   if (range_type == NULL)
828     return FALSE;
829
830   if (lower == 0)
831     {
832       if (upper == -1)
833         sprintf (ab, "|[]");
834       else
835         {
836           print_vma (upper + 1, abu, FALSE, FALSE);
837           sprintf (ab, "|[%s]", abu);
838         }
839     }
840   else
841     {
842       print_vma (lower, abl, FALSE, FALSE);
843       print_vma (upper, abu, FALSE, FALSE);
844       sprintf (ab, "|[%s:%s]", abl, abu);
845     }
846
847   if (! substitute_type (info, ab))
848     return FALSE;
849
850   if (strcmp (range_type, "int") != 0)
851     {
852       if (! append_type (info, ":")
853           || ! append_type (info, range_type))
854         return FALSE;
855     }
856
857   if (stringp)
858     {
859       if (! append_type (info, " /* string */"))
860         return FALSE;
861     }
862
863   return TRUE;
864 }
865
866 /* Make a set type.  */
867
868 static bfd_boolean
869 pr_set_type (void *p, bfd_boolean bitstringp)
870 {
871   struct pr_handle *info = (struct pr_handle *) p;
872
873   if (! substitute_type (info, ""))
874     return FALSE;
875
876   if (! prepend_type (info, "set { ")
877       || ! append_type (info, " }"))
878     return FALSE;
879
880   if (bitstringp)
881     {
882       if (! append_type (info, "/* bitstring */"))
883         return FALSE;
884     }
885
886   return TRUE;
887 }
888
889 /* Make an offset type.  */
890
891 static bfd_boolean
892 pr_offset_type (void *p)
893 {
894   struct pr_handle *info = (struct pr_handle *) p;
895   char *t;
896
897   if (! substitute_type (info, ""))
898     return FALSE;
899
900   t = pop_type (info);
901   if (t == NULL)
902     return FALSE;
903
904   return (substitute_type (info, "")
905           && prepend_type (info, " ")
906           && prepend_type (info, t)
907           && append_type (info, "::|"));
908 }
909
910 /* Make a method type.  */
911
912 static bfd_boolean
913 pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
914 {
915   struct pr_handle *info = (struct pr_handle *) p;
916   unsigned int len;
917   char *domain_type;
918   char **arg_types;
919   char *s;
920
921   len = 10;
922
923   if (! domain)
924     domain_type = NULL;
925   else
926     {
927       if (! substitute_type (info, ""))
928         return FALSE;
929       domain_type = pop_type (info);
930       if (domain_type == NULL)
931         return FALSE;
932       if (CONST_STRNEQ (domain_type, "class ")
933           && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
934         domain_type += sizeof "class " - 1;
935       else if (CONST_STRNEQ (domain_type, "union class ")
936                && (strchr (domain_type + sizeof "union class " - 1, ' ')
937                    == NULL))
938         domain_type += sizeof "union class " - 1;
939       len += strlen (domain_type);
940     }
941
942   if (argcount <= 0)
943     {
944       arg_types = NULL;
945       len += 15;
946     }
947   else
948     {
949       int i;
950
951       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
952       for (i = argcount - 1; i >= 0; i--)
953         {
954           if (! substitute_type (info, ""))
955             return FALSE;
956           arg_types[i] = pop_type (info);
957           if (arg_types[i] == NULL)
958             return FALSE;
959           len += strlen (arg_types[i]) + 2;
960         }
961       if (varargs)
962         len += 5;
963     }
964
965   /* Now the return type is on the top of the stack.  */
966
967   s = (char *) xmalloc (len);
968   if (! domain)
969     *s = '\0';
970   else
971     strcpy (s, domain_type);
972   strcat (s, "::| (");
973
974   if (argcount < 0)
975     strcat (s, "/* unknown */");
976   else
977     {
978       int i;
979
980       for (i = 0; i < argcount; i++)
981         {
982           if (i > 0)
983             strcat (s, ", ");
984           strcat (s, arg_types[i]);
985         }
986       if (varargs)
987         {
988           if (i > 0)
989             strcat (s, ", ");
990           strcat (s, "...");
991         }
992       if (argcount > 0)
993         free (arg_types);
994     }
995
996   strcat (s, ")");
997
998   if (! substitute_type (info, s))
999     return FALSE;
1000
1001   free (s);
1002
1003   return TRUE;
1004 }
1005
1006 /* Make a const qualified type.  */
1007
1008 static bfd_boolean
1009 pr_const_type (void *p)
1010 {
1011   struct pr_handle *info = (struct pr_handle *) p;
1012
1013   return substitute_type (info, "const |");
1014 }
1015
1016 /* Make a volatile qualified type.  */
1017
1018 static bfd_boolean
1019 pr_volatile_type (void *p)
1020 {
1021   struct pr_handle *info = (struct pr_handle *) p;
1022
1023   return substitute_type (info, "volatile |");
1024 }
1025
1026 /* Start accumulating a struct type.  */
1027
1028 static bfd_boolean
1029 pr_start_struct_type (void *p, const char *tag, unsigned int id,
1030                       bfd_boolean structp, unsigned int size)
1031 {
1032   struct pr_handle *info = (struct pr_handle *) p;
1033
1034   info->indent += 2;
1035
1036   if (! push_type (info, structp ? "struct " : "union "))
1037     return FALSE;
1038   if (tag != NULL)
1039     {
1040       if (! append_type (info, tag))
1041         return FALSE;
1042     }
1043   else
1044     {
1045       char idbuf[20];
1046
1047       sprintf (idbuf, "%%anon%u", id);
1048       if (! append_type (info, idbuf))
1049         return FALSE;
1050     }
1051
1052   if (! append_type (info, " {"))
1053     return FALSE;
1054   if (size != 0 || tag != NULL)
1055     {
1056       char ab[30];
1057
1058       if (! append_type (info, " /*"))
1059         return FALSE;
1060
1061       if (size != 0)
1062         {
1063           sprintf (ab, " size %u", size);
1064           if (! append_type (info, ab))
1065             return FALSE;
1066         }
1067       if (tag != NULL)
1068         {
1069           sprintf (ab, " id %u", id);
1070           if (! append_type (info, ab))
1071             return FALSE;
1072         }
1073       if (! append_type (info, " */"))
1074         return FALSE;
1075     }
1076   if (! append_type (info, "\n"))
1077     return FALSE;
1078
1079   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
1080
1081   return indent_type (info);
1082 }
1083
1084 /* Output the visibility of a field in a struct.  */
1085
1086 static bfd_boolean
1087 pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1088 {
1089   const char *s = NULL;
1090   char *t;
1091   unsigned int len;
1092
1093   assert (info->stack != NULL);
1094
1095   if (info->stack->visibility == visibility)
1096     return TRUE;
1097
1098   switch (visibility)
1099     {
1100     case DEBUG_VISIBILITY_PUBLIC:
1101       s = "public";
1102       break;
1103     case DEBUG_VISIBILITY_PRIVATE:
1104       s = "private";
1105       break;
1106     case DEBUG_VISIBILITY_PROTECTED:
1107       s = "protected";
1108       break;
1109     case DEBUG_VISIBILITY_IGNORE:
1110       s = "/* ignore */";
1111       break;
1112     default:
1113       abort ();
1114       return FALSE;
1115     }
1116
1117   /* Trim off a trailing space in the struct string, to make the
1118      output look a bit better, then stick on the visibility string.  */
1119
1120   t = info->stack->type;
1121   len = strlen (t);
1122   assert (t[len - 1] == ' ');
1123   t[len - 1] = '\0';
1124
1125   if (! append_type (info, s)
1126       || ! append_type (info, ":\n")
1127       || ! indent_type (info))
1128     return FALSE;
1129
1130   info->stack->visibility = visibility;
1131
1132   return TRUE;
1133 }
1134
1135 /* Add a field to a struct type.  */
1136
1137 static bfd_boolean
1138 pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
1139                  enum debug_visibility visibility)
1140 {
1141   struct pr_handle *info = (struct pr_handle *) p;
1142   char ab[20];
1143   char *t;
1144
1145   if (! substitute_type (info, name))
1146     return FALSE;
1147
1148   if (! append_type (info, "; /* "))
1149     return FALSE;
1150
1151   if (bitsize != 0)
1152     {
1153       print_vma (bitsize, ab, TRUE, FALSE);
1154       if (! append_type (info, "bitsize ")
1155           || ! append_type (info, ab)
1156           || ! append_type (info, ", "))
1157         return FALSE;
1158     }
1159
1160   print_vma (bitpos, ab, TRUE, FALSE);
1161   if (! append_type (info, "bitpos ")
1162       || ! append_type (info, ab)
1163       || ! append_type (info, " */\n")
1164       || ! indent_type (info))
1165     return FALSE;
1166
1167   t = pop_type (info);
1168   if (t == NULL)
1169     return FALSE;
1170
1171   if (! pr_fix_visibility (info, visibility))
1172     return FALSE;
1173
1174   return append_type (info, t);
1175 }
1176
1177 /* Finish a struct type.  */
1178
1179 static bfd_boolean
1180 pr_end_struct_type (void *p)
1181 {
1182   struct pr_handle *info = (struct pr_handle *) p;
1183   char *s;
1184
1185   assert (info->stack != NULL);
1186   assert (info->indent >= 2);
1187
1188   info->indent -= 2;
1189
1190   /* Change the trailing indentation to have a close brace.  */
1191   s = info->stack->type + strlen (info->stack->type) - 2;
1192   assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1193
1194   *s++ = '}';
1195   *s = '\0';
1196
1197   return TRUE;
1198 }
1199
1200 /* Start a class type.  */
1201
1202 static bfd_boolean
1203 pr_start_class_type (void *p, const char *tag, unsigned int id,
1204                      bfd_boolean structp, unsigned int size,
1205                      bfd_boolean vptr, bfd_boolean ownvptr)
1206 {
1207   struct pr_handle *info = (struct pr_handle *) p;
1208   char *tv = NULL;
1209
1210   info->indent += 2;
1211
1212   if (vptr && ! ownvptr)
1213     {
1214       tv = pop_type (info);
1215       if (tv == NULL)
1216         return FALSE;
1217     }
1218
1219   if (! push_type (info, structp ? "class " : "union class "))
1220     return FALSE;
1221   if (tag != NULL)
1222     {
1223       if (! append_type (info, tag))
1224         return FALSE;
1225     }
1226   else
1227     {
1228       char idbuf[20];
1229
1230       sprintf (idbuf, "%%anon%u", id);
1231       if (! append_type (info, idbuf))
1232         return FALSE;
1233     }
1234
1235   if (! append_type (info, " {"))
1236     return FALSE;
1237   if (size != 0 || vptr || ownvptr || tag != NULL)
1238     {
1239       if (! append_type (info, " /*"))
1240         return FALSE;
1241
1242       if (size != 0)
1243         {
1244           char ab[20];
1245
1246           sprintf (ab, "%u", size);
1247           if (! append_type (info, " size ")
1248               || ! append_type (info, ab))
1249             return FALSE;
1250         }
1251
1252       if (vptr)
1253         {
1254           if (! append_type (info, " vtable "))
1255             return FALSE;
1256           if (ownvptr)
1257             {
1258               if (! append_type (info, "self "))
1259                 return FALSE;
1260             }
1261           else
1262             {
1263               if (! append_type (info, tv)
1264                   || ! append_type (info, " "))
1265                 return FALSE;
1266             }
1267         }
1268
1269       if (tag != NULL)
1270         {
1271           char ab[30];
1272
1273           sprintf (ab, " id %u", id);
1274           if (! append_type (info, ab))
1275             return FALSE;
1276         }
1277
1278       if (! append_type (info, " */"))
1279         return FALSE;
1280     }
1281
1282   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1283
1284   return (append_type (info, "\n")
1285           && indent_type (info));
1286 }
1287
1288 /* Add a static member to a class.  */
1289
1290 static bfd_boolean
1291 pr_class_static_member (void *p, const char *name, const char *physname,
1292                         enum debug_visibility visibility)
1293 {
1294   struct pr_handle *info = (struct pr_handle *) p;
1295   char *t;
1296
1297   if (! substitute_type (info, name))
1298     return FALSE;
1299
1300   if (! prepend_type (info, "static ")
1301       || ! append_type (info, "; /* ")
1302       || ! append_type (info, physname)
1303       || ! append_type (info, " */\n")
1304       || ! indent_type (info))
1305     return FALSE;
1306
1307   t = pop_type (info);
1308   if (t == NULL)
1309     return FALSE;
1310
1311   if (! pr_fix_visibility (info, visibility))
1312     return FALSE;
1313
1314   return append_type (info, t);
1315 }
1316
1317 /* Add a base class to a class.  */
1318
1319 static bfd_boolean
1320 pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
1321                     enum debug_visibility visibility)
1322 {
1323   struct pr_handle *info = (struct pr_handle *) p;
1324   char *t;
1325   const char *prefix;
1326   char ab[20];
1327   char *s, *l, *n;
1328
1329   assert (info->stack != NULL && info->stack->next != NULL);
1330
1331   if (! substitute_type (info, ""))
1332     return FALSE;
1333
1334   t = pop_type (info);
1335   if (t == NULL)
1336     return FALSE;
1337
1338   if (CONST_STRNEQ (t, "class "))
1339     t += sizeof "class " - 1;
1340
1341   /* Push it back on to take advantage of the prepend_type and
1342      append_type routines.  */
1343   if (! push_type (info, t))
1344     return FALSE;
1345
1346   if (virtual)
1347     {
1348       if (! prepend_type (info, "virtual "))
1349         return FALSE;
1350     }
1351
1352   switch (visibility)
1353     {
1354     case DEBUG_VISIBILITY_PUBLIC:
1355       prefix = "public ";
1356       break;
1357     case DEBUG_VISIBILITY_PROTECTED:
1358       prefix = "protected ";
1359       break;
1360     case DEBUG_VISIBILITY_PRIVATE:
1361       prefix = "private ";
1362       break;
1363     default:
1364       prefix = "/* unknown visibility */ ";
1365       break;
1366     }
1367
1368   if (! prepend_type (info, prefix))
1369     return FALSE;
1370
1371   if (bitpos != 0)
1372     {
1373       print_vma (bitpos, ab, TRUE, FALSE);
1374       if (! append_type (info, " /* bitpos ")
1375           || ! append_type (info, ab)
1376           || ! append_type (info, " */"))
1377         return FALSE;
1378     }
1379
1380   /* Now the top of the stack is something like "public A / * bitpos
1381      10 * /".  The next element on the stack is something like "class
1382      xx { / * size 8 * /\n...".  We want to substitute the top of the
1383      stack in before the {.  */
1384   s = strchr (info->stack->next->type, '{');
1385   assert (s != NULL);
1386   --s;
1387
1388   /* If there is already a ':', then we already have a baseclass, and
1389      we must append this one after a comma.  */
1390   for (l = info->stack->next->type; l != s; l++)
1391     if (*l == ':')
1392       break;
1393   if (! prepend_type (info, l == s ? " : " : ", "))
1394     return FALSE;
1395
1396   t = pop_type (info);
1397   if (t == NULL)
1398     return FALSE;
1399
1400   n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1401   memcpy (n, info->stack->type, s - info->stack->type);
1402   strcpy (n + (s - info->stack->type), t);
1403   strcat (n, s);
1404
1405   free (info->stack->type);
1406   info->stack->type = n;
1407
1408   free (t);
1409
1410   return TRUE;
1411 }
1412
1413 /* Start adding a method to a class.  */
1414
1415 static bfd_boolean
1416 pr_class_start_method (void *p, const char *name)
1417 {
1418   struct pr_handle *info = (struct pr_handle *) p;
1419
1420   assert (info->stack != NULL);
1421   info->stack->method = name;
1422   return TRUE;
1423 }
1424
1425 /* Add a variant to a method.  */
1426
1427 static bfd_boolean
1428 pr_class_method_variant (void *p, const char *physname,
1429                          enum debug_visibility visibility,
1430                          bfd_boolean constp, bfd_boolean volatilep,
1431                          bfd_vma voffset, bfd_boolean context)
1432 {
1433   struct pr_handle *info = (struct pr_handle *) p;
1434   char *method_type;
1435   char *context_type;
1436
1437   assert (info->stack != NULL);
1438   assert (info->stack->next != NULL);
1439
1440   /* Put the const and volatile qualifiers on the type.  */
1441   if (volatilep)
1442     {
1443       if (! append_type (info, " volatile"))
1444         return FALSE;
1445     }
1446   if (constp)
1447     {
1448       if (! append_type (info, " const"))
1449         return FALSE;
1450     }
1451
1452   /* Stick the name of the method into its type.  */
1453   if (! substitute_type (info,
1454                          (context
1455                           ? info->stack->next->next->method
1456                           : info->stack->next->method)))
1457     return FALSE;
1458
1459   /* Get the type.  */
1460   method_type = pop_type (info);
1461   if (method_type == NULL)
1462     return FALSE;
1463
1464   /* Pull off the context type if there is one.  */
1465   if (! context)
1466     context_type = NULL;
1467   else
1468     {
1469       context_type = pop_type (info);
1470       if (context_type == NULL)
1471         return FALSE;
1472     }
1473
1474   /* Now the top of the stack is the class.  */
1475
1476   if (! pr_fix_visibility (info, visibility))
1477     return FALSE;
1478
1479   if (! append_type (info, method_type)
1480       || ! append_type (info, " /* ")
1481       || ! append_type (info, physname)
1482       || ! append_type (info, " "))
1483     return FALSE;
1484   if (context || voffset != 0)
1485     {
1486       char ab[20];
1487
1488       if (context)
1489         {
1490           if (! append_type (info, "context ")
1491               || ! append_type (info, context_type)
1492               || ! append_type (info, " "))
1493             return FALSE;
1494         }
1495       print_vma (voffset, ab, TRUE, FALSE);
1496       if (! append_type (info, "voffset ")
1497           || ! append_type (info, ab))
1498         return FALSE;
1499     }
1500
1501   return (append_type (info, " */;\n")
1502           && indent_type (info));
1503 }
1504
1505 /* Add a static variant to a method.  */
1506
1507 static bfd_boolean
1508 pr_class_static_method_variant (void *p, const char *physname,
1509                                 enum debug_visibility visibility,
1510                                 bfd_boolean constp, bfd_boolean volatilep)
1511 {
1512   struct pr_handle *info = (struct pr_handle *) p;
1513   char *method_type;
1514
1515   assert (info->stack != NULL);
1516   assert (info->stack->next != NULL);
1517   assert (info->stack->next->method != NULL);
1518
1519   /* Put the const and volatile qualifiers on the type.  */
1520   if (volatilep)
1521     {
1522       if (! append_type (info, " volatile"))
1523         return FALSE;
1524     }
1525   if (constp)
1526     {
1527       if (! append_type (info, " const"))
1528         return FALSE;
1529     }
1530
1531   /* Mark it as static.  */
1532   if (! prepend_type (info, "static "))
1533     return FALSE;
1534
1535   /* Stick the name of the method into its type.  */
1536   if (! substitute_type (info, info->stack->next->method))
1537     return FALSE;
1538
1539   /* Get the type.  */
1540   method_type = pop_type (info);
1541   if (method_type == NULL)
1542     return FALSE;
1543
1544   /* Now the top of the stack is the class.  */
1545
1546   if (! pr_fix_visibility (info, visibility))
1547     return FALSE;
1548
1549   return (append_type (info, method_type)
1550           && append_type (info, " /* ")
1551           && append_type (info, physname)
1552           && append_type (info, " */;\n")
1553           && indent_type (info));
1554 }
1555
1556 /* Finish up a method.  */
1557
1558 static bfd_boolean
1559 pr_class_end_method (void *p)
1560 {
1561   struct pr_handle *info = (struct pr_handle *) p;
1562
1563   info->stack->method = NULL;
1564   return TRUE;
1565 }
1566
1567 /* Finish up a class.  */
1568
1569 static bfd_boolean
1570 pr_end_class_type (void *p)
1571 {
1572   return pr_end_struct_type (p);
1573 }
1574
1575 /* Push a type on the stack using a typedef name.  */
1576
1577 static bfd_boolean
1578 pr_typedef_type (void *p, const char *name)
1579 {
1580   struct pr_handle *info = (struct pr_handle *) p;
1581
1582   return push_type (info, name);
1583 }
1584
1585 /* Push a type on the stack using a tag name.  */
1586
1587 static bfd_boolean
1588 pr_tag_type (void *p, const char *name, unsigned int id,
1589              enum debug_type_kind kind)
1590 {
1591   struct pr_handle *info = (struct pr_handle *) p;
1592   const char *t, *tag;
1593   char idbuf[20];
1594
1595   switch (kind)
1596     {
1597     case DEBUG_KIND_STRUCT:
1598       t = "struct ";
1599       break;
1600     case DEBUG_KIND_UNION:
1601       t = "union ";
1602       break;
1603     case DEBUG_KIND_ENUM:
1604       t = "enum ";
1605       break;
1606     case DEBUG_KIND_CLASS:
1607       t = "class ";
1608       break;
1609     case DEBUG_KIND_UNION_CLASS:
1610       t = "union class ";
1611       break;
1612     default:
1613       abort ();
1614       return FALSE;
1615     }
1616
1617   if (! push_type (info, t))
1618     return FALSE;
1619   if (name != NULL)
1620     tag = name;
1621   else
1622     {
1623       sprintf (idbuf, "%%anon%u", id);
1624       tag = idbuf;
1625     }
1626
1627   if (! append_type (info, tag))
1628     return FALSE;
1629   if (name != NULL && kind != DEBUG_KIND_ENUM)
1630     {
1631       sprintf (idbuf, " /* id %u */", id);
1632       if (! append_type (info, idbuf))
1633         return FALSE;
1634     }
1635
1636   return TRUE;
1637 }
1638
1639 /* Output a typedef.  */
1640
1641 static bfd_boolean
1642 pr_typdef (void *p, const char *name)
1643 {
1644   struct pr_handle *info = (struct pr_handle *) p;
1645   char *s;
1646
1647   if (! substitute_type (info, name))
1648     return FALSE;
1649
1650   s = pop_type (info);
1651   if (s == NULL)
1652     return FALSE;
1653
1654   indent (info);
1655   fprintf (info->f, "typedef %s;\n", s);
1656
1657   free (s);
1658
1659   return TRUE;
1660 }
1661
1662 /* Output a tag.  The tag should already be in the string on the
1663    stack, so all we have to do here is print it out.  */
1664
1665 static bfd_boolean
1666 pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
1667 {
1668   struct pr_handle *info = (struct pr_handle *) p;
1669   char *t;
1670
1671   t = pop_type (info);
1672   if (t == NULL)
1673     return FALSE;
1674
1675   indent (info);
1676   fprintf (info->f, "%s;\n", t);
1677
1678   free (t);
1679
1680   return TRUE;
1681 }
1682
1683 /* Output an integer constant.  */
1684
1685 static bfd_boolean
1686 pr_int_constant (void *p, const char *name, bfd_vma val)
1687 {
1688   struct pr_handle *info = (struct pr_handle *) p;
1689   char ab[20];
1690
1691   indent (info);
1692   print_vma (val, ab, FALSE, FALSE);
1693   fprintf (info->f, "const int %s = %s;\n", name, ab);
1694   return TRUE;
1695 }
1696
1697 /* Output a floating point constant.  */
1698
1699 static bfd_boolean
1700 pr_float_constant (void *p, const char *name, double val)
1701 {
1702   struct pr_handle *info = (struct pr_handle *) p;
1703
1704   indent (info);
1705   fprintf (info->f, "const double %s = %g;\n", name, val);
1706   return TRUE;
1707 }
1708
1709 /* Output a typed constant.  */
1710
1711 static bfd_boolean
1712 pr_typed_constant (void *p, const char *name, bfd_vma val)
1713 {
1714   struct pr_handle *info = (struct pr_handle *) p;
1715   char *t;
1716   char ab[20];
1717
1718   t = pop_type (info);
1719   if (t == NULL)
1720     return FALSE;
1721
1722   indent (info);
1723   print_vma (val, ab, FALSE, FALSE);
1724   fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1725
1726   free (t);
1727
1728   return TRUE;
1729 }
1730
1731 /* Output a variable.  */
1732
1733 static bfd_boolean
1734 pr_variable (void *p, const char *name, enum debug_var_kind kind,
1735              bfd_vma val)
1736 {
1737   struct pr_handle *info = (struct pr_handle *) p;
1738   char *t;
1739   char ab[20];
1740
1741   if (! substitute_type (info, name))
1742     return FALSE;
1743
1744   t = pop_type (info);
1745   if (t == NULL)
1746     return FALSE;
1747
1748   indent (info);
1749   switch (kind)
1750     {
1751     case DEBUG_STATIC:
1752     case DEBUG_LOCAL_STATIC:
1753       fprintf (info->f, "static ");
1754       break;
1755     case DEBUG_REGISTER:
1756       fprintf (info->f, "register ");
1757       break;
1758     default:
1759       break;
1760     }
1761   print_vma (val, ab, TRUE, TRUE);
1762   fprintf (info->f, "%s /* %s */;\n", t, ab);
1763
1764   free (t);
1765
1766   return TRUE;
1767 }
1768
1769 /* Start outputting a function.  */
1770
1771 static bfd_boolean
1772 pr_start_function (void *p, const char *name, bfd_boolean global)
1773 {
1774   struct pr_handle *info = (struct pr_handle *) p;
1775   char *t;
1776
1777   if (! substitute_type (info, name))
1778     return FALSE;
1779
1780   t = pop_type (info);
1781   if (t == NULL)
1782     return FALSE;
1783
1784   indent (info);
1785   if (! global)
1786     fprintf (info->f, "static ");
1787   fprintf (info->f, "%s (", t);
1788
1789   info->parameter = 1;
1790
1791   return TRUE;
1792 }
1793
1794 /* Output a function parameter.  */
1795
1796 static bfd_boolean
1797 pr_function_parameter (void *p, const char *name,
1798                        enum debug_parm_kind kind, bfd_vma val)
1799 {
1800   struct pr_handle *info = (struct pr_handle *) p;
1801   char *t;
1802   char ab[20];
1803
1804   if (kind == DEBUG_PARM_REFERENCE
1805       || kind == DEBUG_PARM_REF_REG)
1806     {
1807       if (! pr_reference_type (p))
1808         return FALSE;
1809     }
1810
1811   if (! substitute_type (info, name))
1812     return FALSE;
1813
1814   t = pop_type (info);
1815   if (t == NULL)
1816     return FALSE;
1817
1818   if (info->parameter != 1)
1819     fprintf (info->f, ", ");
1820
1821   if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1822     fprintf (info->f, "register ");
1823
1824   print_vma (val, ab, TRUE, TRUE);
1825   fprintf (info->f, "%s /* %s */", t, ab);
1826
1827   free (t);
1828
1829   ++info->parameter;
1830
1831   return TRUE;
1832 }
1833
1834 /* Start writing out a block.  */
1835
1836 static bfd_boolean
1837 pr_start_block (void *p, bfd_vma addr)
1838 {
1839   struct pr_handle *info = (struct pr_handle *) p;
1840   char ab[20];
1841
1842   if (info->parameter > 0)
1843     {
1844       fprintf (info->f, ")\n");
1845       info->parameter = 0;
1846     }
1847
1848   indent (info);
1849   print_vma (addr, ab, TRUE, TRUE);
1850   fprintf (info->f, "{ /* %s */\n", ab);
1851
1852   info->indent += 2;
1853
1854   return TRUE;
1855 }
1856
1857 /* Write out line number information.  */
1858
1859 static bfd_boolean
1860 pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1861 {
1862   struct pr_handle *info = (struct pr_handle *) p;
1863   char ab[20];
1864
1865   indent (info);
1866   print_vma (addr, ab, TRUE, TRUE);
1867   fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1868
1869   return TRUE;
1870 }
1871
1872 /* Finish writing out a block.  */
1873
1874 static bfd_boolean
1875 pr_end_block (void *p, bfd_vma addr)
1876 {
1877   struct pr_handle *info = (struct pr_handle *) p;
1878   char ab[20];
1879
1880   info->indent -= 2;
1881
1882   indent (info);
1883   print_vma (addr, ab, TRUE, TRUE);
1884   fprintf (info->f, "} /* %s */\n", ab);
1885
1886   return TRUE;
1887 }
1888
1889 /* Finish writing out a function.  */
1890
1891 static bfd_boolean
1892 pr_end_function (void *p ATTRIBUTE_UNUSED)
1893 {
1894   return TRUE;
1895 }
1896 \f
1897 /* Tags style generation functions start here.  */
1898
1899 /* Variables for address to line translation.  */
1900 static bfd_vma pc;
1901 static const char *filename;
1902 static const char *functionname;
1903 static unsigned int line;
1904 static bfd_boolean found;
1905
1906 /* Look for an address in a section.  This is called via
1907    bfd_map_over_sections.  */
1908
1909 static void
1910 find_address_in_section (bfd *abfd, asection *section, void *data)
1911 {
1912   bfd_vma vma;
1913   bfd_size_type size;
1914   asymbol **syms = (asymbol **) data;
1915
1916   if (found)
1917     return;
1918
1919   if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
1920     return;
1921
1922   vma = bfd_get_section_vma (abfd, section);
1923   if (pc < vma)
1924     return;
1925
1926   size = bfd_get_section_size (section);
1927   if (pc >= vma + size)
1928     return;
1929
1930   found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
1931                                  &filename, &functionname, &line);
1932 }
1933
1934 static void
1935 translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1936 {
1937   pc = bfd_scan_vma (addr_hex, NULL, 16);
1938   found = FALSE;
1939   bfd_map_over_sections (abfd, find_address_in_section, syms);
1940
1941   if (! found)
1942     fprintf (f, "??");
1943   else
1944     fprintf (f, "%u", line);
1945 }
1946
1947 /* Start a new compilation unit.  */
1948
1949 static bfd_boolean
1950 tg_start_compilation_unit (void * p, const char *filename ATTRIBUTE_UNUSED)
1951 {
1952   struct pr_handle *info = (struct pr_handle *) p;
1953
1954   free (info->filename);
1955   /* Should it be relative? best way to do it here?.  */
1956   info->filename = strdup (filename);
1957
1958   return TRUE;
1959 }
1960
1961 /* Start a source file within a compilation unit.  */
1962
1963 static bfd_boolean
1964 tg_start_source (void *p, const char *filename)
1965 {
1966   struct pr_handle *info = (struct pr_handle *) p;
1967
1968   free (info->filename);
1969   /* Should it be relative? best way to do it here?.  */
1970   info->filename = strdup (filename);
1971
1972   return TRUE;
1973 }
1974
1975 /* Push an enum type onto the type stack.  */
1976
1977 static bfd_boolean
1978 tg_enum_type (void *p, const char *tag, const char **names,
1979               bfd_signed_vma *values)
1980 {
1981   struct pr_handle *info = (struct pr_handle *) p;
1982   unsigned int i;
1983   const char *name;
1984   char ab[20];
1985
1986   if (! pr_enum_type (p, tag, names, values))
1987     return FALSE;
1988
1989   name = tag ? tag : "unknown";
1990   /* Generate an entry for the enum.  */
1991   if (tag)
1992     fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
1993              info->filename, info->stack->type);
1994
1995   /* Generate entries for the values.  */
1996   if (names != NULL)
1997     {
1998       for (i = 0; names[i] != NULL; i++)
1999         {
2000           print_vma (values[i], ab, FALSE, FALSE);
2001           fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
2002                    names[i], info->filename, name, ab);
2003         }
2004     }
2005
2006   return TRUE;
2007 }
2008
2009 /* Start accumulating a struct type.  */
2010
2011 static bfd_boolean
2012 tg_start_struct_type (void *p, const char *tag, unsigned int id,
2013                       bfd_boolean structp,
2014                       unsigned int size ATTRIBUTE_UNUSED)
2015 {
2016   struct pr_handle *info = (struct pr_handle *) p;
2017   const char *name;
2018   char idbuf[20];
2019
2020   if (tag != NULL)
2021     name = tag;
2022   else
2023     {
2024       name = idbuf;
2025       sprintf (idbuf, "%%anon%u", id);
2026     }
2027
2028   if (! push_type (info, name))
2029     return FALSE;
2030
2031   info->stack->flavor = structp ? "struct" : "union";
2032
2033   fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
2034            info->stack->flavor[0]);
2035
2036   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
2037
2038   return indent_type (info);
2039 }
2040
2041 /* Output the visibility of a field in a struct.  */
2042
2043 static bfd_boolean
2044 tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2045 {
2046   assert (info->stack != NULL);
2047
2048   if (info->stack->visibility == visibility)
2049     return TRUE;
2050
2051   assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
2052
2053   info->stack->visibility = visibility;
2054
2055   return TRUE;
2056 }
2057
2058 /* Add a field to a struct type.  */
2059
2060 static bfd_boolean
2061 tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
2062                  bfd_vma bitsize ATTRIBUTE_UNUSED,
2063                  enum debug_visibility visibility)
2064 {
2065   struct pr_handle *info = (struct pr_handle *) p;
2066   char *t;
2067
2068   t = pop_type (info);
2069   if (t == NULL)
2070     return FALSE;
2071
2072   if (! tg_fix_visibility (info, visibility))
2073     return FALSE;
2074
2075   /* It happens, a bug? */
2076   if (! name[0])
2077     return TRUE;
2078
2079   fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
2080            name, info->filename, t, info->stack->flavor, info->stack->type,
2081            visibility_name (visibility));
2082
2083   return TRUE;
2084 }
2085
2086 /* Finish a struct type.  */
2087
2088 static bfd_boolean
2089 tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
2090 {
2091   struct pr_handle *info = (struct pr_handle *) p;
2092   assert (info->stack != NULL);
2093
2094   return TRUE;
2095 }
2096
2097 /* Start a class type.  */
2098
2099 static bfd_boolean
2100 tg_start_class_type (void *p, const char *tag, unsigned int id,
2101                      bfd_boolean structp, unsigned int size,
2102                      bfd_boolean vptr, bfd_boolean ownvptr)
2103 {
2104   struct pr_handle *info = (struct pr_handle *) p;
2105   char *tv = NULL;
2106   const char *name;
2107
2108   info->indent += 2;
2109
2110   if (vptr && ! ownvptr)
2111     {
2112       tv = pop_type (info);
2113       if (tv == NULL)
2114         return FALSE;
2115     }
2116
2117   if (tag != NULL)
2118     name = tag;
2119   else
2120     {
2121       char idbuf[20];
2122
2123       sprintf (idbuf, "%%anon%u", id);
2124       name = idbuf;
2125     }
2126
2127   if (! push_type (info, name))
2128     return FALSE;
2129
2130   info->stack->flavor = structp ? "class" : "union class";
2131   info->stack->parents = NULL;
2132   info->stack->num_parents = 0;
2133
2134   if (size != 0 || vptr || ownvptr || tag != NULL)
2135     {
2136       if (vptr)
2137         {
2138           if (! append_type (info, " vtable "))
2139             return FALSE;
2140           if (ownvptr)
2141             {
2142               if (! append_type (info, "self "))
2143                 return FALSE;
2144             }
2145           else
2146             {
2147               if (! append_type (info, tv)
2148                   || ! append_type (info, " "))
2149                 return FALSE;
2150             }
2151         }
2152     }
2153
2154   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2155
2156   return TRUE;
2157 }
2158
2159 /* Add a static member to a class.  */
2160
2161 static bfd_boolean
2162 tg_class_static_member (void *p, const char *name,
2163                         const char *physname ATTRIBUTE_UNUSED,
2164                         enum debug_visibility visibility)
2165 {
2166   struct pr_handle *info = (struct pr_handle *) p;
2167   char *t;
2168   int len_var, len_class;
2169   char *full_name;
2170
2171   len_var = strlen (name);
2172   len_class = strlen (info->stack->next->type);
2173   full_name = xmalloc (len_var + len_class + 3);
2174   if (! full_name)
2175     return FALSE;
2176   sprintf (full_name, "%s::%s", info->stack->next->type, name);
2177
2178   if (! substitute_type (info, full_name))
2179     return FALSE;
2180
2181   if (! prepend_type (info, "static "))
2182     return FALSE;
2183
2184   t = pop_type (info);
2185   if (t == NULL)
2186     return FALSE;
2187
2188   if (! tg_fix_visibility (info, visibility))
2189     return FALSE;
2190
2191   fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2192            name, info->filename, t, info->stack->type,
2193            visibility_name (visibility));
2194   free (t);
2195   free (full_name);
2196
2197   return TRUE;
2198 }
2199
2200 /* Add a base class to a class.  */
2201
2202 static bfd_boolean
2203 tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2204                     bfd_boolean virtual, enum debug_visibility visibility)
2205 {
2206   struct pr_handle *info = (struct pr_handle *) p;
2207   char *t;
2208   const char *prefix;
2209
2210   assert (info->stack != NULL && info->stack->next != NULL);
2211
2212   t = pop_type (info);
2213   if (t == NULL)
2214     return FALSE;
2215
2216   if (CONST_STRNEQ (t, "class "))
2217     t += sizeof "class " - 1;
2218
2219   /* Push it back on to take advantage of the prepend_type and
2220      append_type routines.  */
2221   if (! push_type (info, t))
2222     return FALSE;
2223
2224   if (virtual)
2225     {
2226       if (! prepend_type (info, "virtual "))
2227         return FALSE;
2228     }
2229
2230   switch (visibility)
2231     {
2232     case DEBUG_VISIBILITY_PUBLIC:
2233       prefix = "public ";
2234       break;
2235     case DEBUG_VISIBILITY_PROTECTED:
2236       prefix = "protected ";
2237       break;
2238     case DEBUG_VISIBILITY_PRIVATE:
2239       prefix = "private ";
2240       break;
2241     default:
2242       prefix = "/* unknown visibility */ ";
2243       break;
2244     }
2245
2246   if (! prepend_type (info, prefix))
2247     return FALSE;
2248
2249   t = pop_type (info);
2250   if (t == NULL)
2251     return FALSE;
2252
2253   if (info->stack->num_parents && ! append_parent (info, ", "))
2254     return FALSE;
2255
2256   if (! append_parent (info, t))
2257     return FALSE;
2258   info->stack->num_parents++;
2259
2260   free (t);
2261
2262   return TRUE;
2263 }
2264
2265 /* Add a variant to a method.  */
2266
2267 static bfd_boolean
2268 tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2269                          enum debug_visibility visibility,
2270                          bfd_boolean constp, bfd_boolean volatilep,
2271                          bfd_vma voffset ATTRIBUTE_UNUSED,
2272                          bfd_boolean context)
2273 {
2274   struct pr_handle *info = (struct pr_handle *) p;
2275   char *method_type;
2276   char *context_type;
2277   char *method_name;
2278
2279   assert (info->stack != NULL);
2280   assert (info->stack->next != NULL);
2281
2282   /* Put the const and volatile qualifiers on the type.  */
2283   if (volatilep)
2284     {
2285       if (! append_type (info, " volatile"))
2286         return FALSE;
2287     }
2288   if (constp)
2289     {
2290       if (! append_type (info, " const"))
2291         return FALSE;
2292     }
2293
2294   method_name = strdup (context ? info->stack->next->next->method
2295                         : info->stack->next->method);
2296
2297   /* Stick the name of the method into its type.  */
2298   if (! substitute_type (info, method_name))
2299     return FALSE;
2300
2301   /* Get the type.  */
2302   method_type = pop_type (info);
2303   if (method_type == NULL)
2304     return FALSE;
2305
2306   /* Pull off the context type if there is one.  */
2307   if (! context)
2308     context_type = NULL;
2309   else
2310     {
2311       context_type = pop_type (info);
2312       if (context_type == NULL)
2313         return FALSE;
2314     }
2315
2316   /* Now the top of the stack is the class.  */
2317   if (! tg_fix_visibility (info, visibility))
2318     return FALSE;
2319
2320   fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2321            method_name, info->filename, method_type, info->stack->type);
2322   free (method_type);
2323   free (method_name);
2324   free (context_type);
2325
2326   return TRUE;
2327 }
2328
2329 /* Add a static variant to a method.  */
2330
2331 static bfd_boolean
2332 tg_class_static_method_variant (void *p,
2333                                 const char *physname ATTRIBUTE_UNUSED,
2334                                 enum debug_visibility visibility,
2335                                 bfd_boolean constp, bfd_boolean volatilep)
2336 {
2337   struct pr_handle *info = (struct pr_handle *) p;
2338   char *method_type;
2339   char *method_name;
2340
2341   assert (info->stack != NULL);
2342   assert (info->stack->next != NULL);
2343   assert (info->stack->next->method != NULL);
2344
2345   /* Put the const and volatile qualifiers on the type.  */
2346   if (volatilep)
2347     {
2348       if (! append_type (info, " volatile"))
2349         return FALSE;
2350     }
2351   if (constp)
2352     {
2353       if (! append_type (info, " const"))
2354         return FALSE;
2355     }
2356
2357   /* Mark it as static.  */
2358   if (! prepend_type (info, "static "))
2359     return FALSE;
2360
2361   method_name = strdup (info->stack->next->method);
2362   /* Stick the name of the method into its type.  */
2363   if (! substitute_type (info, info->stack->next->method))
2364     return FALSE;
2365
2366   /* Get the type.  */
2367   method_type = pop_type (info);
2368   if (method_type == NULL)
2369     return FALSE;
2370
2371   /* Now the top of the stack is the class.  */
2372   if (! tg_fix_visibility (info, visibility))
2373     return FALSE;
2374
2375   fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2376            method_name, info->filename, method_type, info->stack->type,
2377            visibility_name (visibility));
2378   free (method_type);
2379   free (method_name);
2380
2381   return TRUE;
2382 }
2383
2384 /* Finish up a class.  */
2385
2386 static bfd_boolean
2387 tg_end_class_type (void *p)
2388 {
2389   struct pr_handle *info = (struct pr_handle *) p;
2390
2391   fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2392            info->filename, info->stack->flavor);
2393   if (info->stack->num_parents)
2394     {
2395       fprintf  (info->f, "\tinherits:%s", info->stack->parents);
2396       free (info->stack->parents);
2397     }
2398   fputc ('\n', info->f);
2399
2400   return tg_end_struct_type (p);
2401 }
2402
2403 /* Push a type on the stack using a tag name.  */
2404
2405 static bfd_boolean
2406 tg_tag_type (void *p, const char *name, unsigned int id,
2407              enum debug_type_kind kind)
2408 {
2409   struct pr_handle *info = (struct pr_handle *) p;
2410   const char *t, *tag;
2411   char idbuf[20];
2412
2413   switch (kind)
2414     {
2415     case DEBUG_KIND_STRUCT:
2416       t = "struct ";
2417       break;
2418     case DEBUG_KIND_UNION:
2419       t = "union ";
2420       break;
2421     case DEBUG_KIND_ENUM:
2422       t = "enum ";
2423       break;
2424     case DEBUG_KIND_CLASS:
2425       t = "class ";
2426       break;
2427     case DEBUG_KIND_UNION_CLASS:
2428       t = "union class ";
2429       break;
2430     default:
2431       abort ();
2432       return FALSE;
2433     }
2434
2435   if (! push_type (info, t))
2436     return FALSE;
2437   if (name != NULL)
2438     tag = name;
2439   else
2440     {
2441       sprintf (idbuf, "%%anon%u", id);
2442       tag = idbuf;
2443     }
2444
2445   if (! append_type (info, tag))
2446     return FALSE;
2447
2448   return TRUE;
2449 }
2450
2451 /* Output a typedef.  */
2452
2453 static bfd_boolean
2454 tg_typdef (void *p, const char *name)
2455 {
2456   struct pr_handle *info = (struct pr_handle *) p;
2457   char *s;
2458
2459   s = pop_type (info);
2460   if (s == NULL)
2461     return FALSE;
2462
2463   fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2464            info->filename, s);
2465
2466   free (s);
2467
2468   return TRUE;
2469 }
2470
2471 /* Output a tag.  The tag should already be in the string on the
2472    stack, so all we have to do here is print it out.  */
2473
2474 static bfd_boolean
2475 tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2476 {
2477   struct pr_handle *info = (struct pr_handle *) p;
2478   char *t;
2479
2480   t = pop_type (info);
2481   if (t == NULL)
2482     return FALSE;
2483   free (t);
2484
2485   return TRUE;
2486 }
2487
2488 /* Output an integer constant.  */
2489
2490 static bfd_boolean
2491 tg_int_constant (void *p, const char *name, bfd_vma val)
2492 {
2493   struct pr_handle *info = (struct pr_handle *) p;
2494   char ab[20];
2495
2496   indent (info);
2497   print_vma (val, ab, FALSE, FALSE);
2498   fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2499            name, info->filename, ab);
2500   return TRUE;
2501 }
2502
2503 /* Output a floating point constant.  */
2504
2505 static bfd_boolean
2506 tg_float_constant (void *p, const char *name, double val)
2507 {
2508   struct pr_handle *info = (struct pr_handle *) p;
2509
2510   indent (info);
2511   fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2512            name, info->filename, val);
2513   return TRUE;
2514 }
2515
2516 /* Output a typed constant.  */
2517
2518 static bfd_boolean
2519 tg_typed_constant (void *p, const char *name, bfd_vma val)
2520 {
2521   struct pr_handle *info = (struct pr_handle *) p;
2522   char *t;
2523   char ab[20];
2524
2525   t = pop_type (info);
2526   if (t == NULL)
2527     return FALSE;
2528
2529   indent (info);
2530   print_vma (val, ab, FALSE, FALSE);
2531   fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2532            name, info->filename, t, ab);
2533
2534   free (t);
2535
2536   return TRUE;
2537 }
2538
2539 /* Output a variable.  */
2540
2541 static bfd_boolean
2542 tg_variable (void *p, const char *name, enum debug_var_kind kind,
2543              bfd_vma val ATTRIBUTE_UNUSED)
2544 {
2545   struct pr_handle *info = (struct pr_handle *) p;
2546   char *t, *dname, *from_class;
2547
2548   t = pop_type (info);
2549   if (t == NULL)
2550     return FALSE;
2551
2552   dname = NULL;
2553   if (info->demangler)
2554     dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2555
2556   from_class = NULL;
2557   if (dname != NULL)
2558     {
2559       char *sep;
2560       sep = strstr (dname, "::");
2561       if (sep)
2562         {
2563           *sep = 0;
2564           name = sep + 2;
2565           from_class = dname;
2566         }
2567       else
2568         /* Obscure types as vts and type_info nodes.  */
2569         name = dname;
2570     }
2571
2572   fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2573
2574   switch (kind)
2575     {
2576     case DEBUG_STATIC:
2577     case DEBUG_LOCAL_STATIC:
2578       fprintf (info->f, "\tfile:");
2579       break;
2580     case DEBUG_REGISTER:
2581       fprintf (info->f, "\tregister:");
2582       break;
2583     default:
2584       break;
2585     }
2586
2587   if (from_class)
2588     fprintf (info->f, "\tclass:%s", from_class);
2589
2590   if (dname)
2591     free (dname);
2592
2593   fprintf (info->f, "\n");
2594
2595   free (t);
2596
2597   return TRUE;
2598 }
2599
2600 /* Start outputting a function.  */
2601
2602 static bfd_boolean
2603 tg_start_function (void *p, const char *name, bfd_boolean global)
2604 {
2605   struct pr_handle *info = (struct pr_handle *) p;
2606   char *dname;
2607
2608   if (! global)
2609     info->stack->flavor = "static";
2610   else
2611     info->stack->flavor = NULL;
2612
2613   dname = NULL;
2614   if (info->demangler)
2615     dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2616
2617   if (! substitute_type (info, dname ? dname : name))
2618     return FALSE;
2619
2620   info->stack->method = NULL;
2621   if (dname != NULL)
2622     {
2623       char *sep;
2624       sep = strstr (dname, "::");
2625       if (sep)
2626         {
2627           info->stack->method = dname;
2628           *sep = 0;
2629           name = sep + 2;
2630         }
2631       else
2632         {
2633           info->stack->method = "";
2634           name = dname;
2635         }
2636       sep = strchr (name, '(');
2637       if (sep)
2638         *sep = 0;
2639       /* Obscure functions as type_info function.  */
2640     }
2641
2642   info->stack->parents = strdup (name);
2643
2644   if (! info->stack->method && ! append_type (info, "("))
2645     return FALSE;
2646
2647   info->parameter = 1;
2648
2649   return TRUE;
2650 }
2651
2652 /* Output a function parameter.  */
2653
2654 static bfd_boolean
2655 tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2656                        bfd_vma val ATTRIBUTE_UNUSED)
2657 {
2658   struct pr_handle *info = (struct pr_handle *) p;
2659   char *t;
2660
2661   if (kind == DEBUG_PARM_REFERENCE
2662       || kind == DEBUG_PARM_REF_REG)
2663     {
2664       if (! pr_reference_type (p))
2665         return FALSE;
2666     }
2667
2668   if (! substitute_type (info, name))
2669     return FALSE;
2670
2671   t = pop_type (info);
2672   if (t == NULL)
2673     return FALSE;
2674
2675   if (! info->stack->method)
2676     {
2677       if (info->parameter != 1 && ! append_type (info, ", "))
2678         return FALSE;
2679
2680       if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2681         if (! append_type (info, "register "))
2682           return FALSE;
2683
2684       if (! append_type (info, t))
2685         return FALSE;
2686     }
2687
2688   free (t);
2689
2690   ++info->parameter;
2691
2692   return TRUE;
2693 }
2694
2695 /* Start writing out a block.  */
2696
2697 static bfd_boolean
2698 tg_start_block (void *p, bfd_vma addr)
2699 {
2700   struct pr_handle *info = (struct pr_handle *) p;
2701   char ab[20], kind, *partof;
2702   char *t;
2703   bfd_boolean local;
2704
2705   if (info->parameter > 0)
2706     {
2707       info->parameter = 0;
2708
2709       /* Delayed name.  */
2710       fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2711       free (info->stack->parents);
2712
2713       print_vma (addr, ab, TRUE, TRUE);
2714       translate_addresses (info->abfd, ab, info->f, info->syms);
2715       local = info->stack->flavor != NULL;
2716       if (info->stack->method && *info->stack->method)
2717         {
2718           kind = 'm';
2719           partof = (char *) info->stack->method;
2720         }
2721       else
2722         {
2723           kind = 'f';
2724           partof = NULL;
2725           if (! info->stack->method && ! append_type (info, ")"))
2726             return FALSE;
2727         }
2728       t = pop_type (info);
2729       if (t == NULL)
2730         return FALSE;
2731       fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2732       if (local)
2733         fputs ("\tfile:", info->f);
2734       if (partof)
2735         {
2736           fprintf (info->f, "\tclass:%s", partof);
2737           free (partof);
2738         }
2739       fputc ('\n', info->f);
2740     }
2741
2742   return TRUE;
2743 }
2744
2745 /* Write out line number information.  */
2746
2747 static bfd_boolean
2748 tg_lineno (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED,
2749            unsigned long lineno ATTRIBUTE_UNUSED,
2750            bfd_vma addr ATTRIBUTE_UNUSED)
2751 {
2752   return TRUE;
2753 }
2754
2755 /* Finish writing out a block.  */
2756
2757 static bfd_boolean
2758 tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2759 {
2760   return TRUE;
2761 }
2762
2763 /* Convert the visibility value into a human readable name.  */
2764
2765 static const char *
2766 visibility_name (enum debug_visibility visibility)
2767 {
2768   const char *s;
2769
2770   switch (visibility)
2771     {
2772     case DEBUG_VISIBILITY_PUBLIC:
2773       s = "public";
2774       break;
2775     case DEBUG_VISIBILITY_PRIVATE:
2776       s = "private";
2777       break;
2778     case DEBUG_VISIBILITY_PROTECTED:
2779       s = "protected";
2780       break;
2781     case DEBUG_VISIBILITY_IGNORE:
2782       s = "/* ignore */";
2783       break;
2784     default:
2785       abort ();
2786       return FALSE;
2787     }
2788   return s;
2789 }