1 /* prdbg.c -- Print out generic debugging information.
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
4 Tags style generation written by Salvador E. Tropea <set@computer.org>.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This file prints out the generic debugging information, by
24 supplying a set of routines to debug_write. */
29 #include "libiberty.h"
34 /* This is the structure we use as a handle for these routines. */
38 /* File to print information to. */
40 /* Current indentation level. */
43 struct pr_stack *stack;
44 /* Parameter number we are about to output. */
46 /* The following are used only by the tags code (tg_). */
47 /* Name of the file we are using. */
51 /* The symbols table for this BFD. */
53 /* Pointer to a function to demangle symbols. */
54 char *(*demangler) (bfd *, const char *, int);
61 /* Next element on the stack. */
62 struct pr_stack *next;
65 /* Current visibility of fields if this is a class. */
66 enum debug_visibility visibility;
67 /* Name of the current method we are handling. */
69 /* The following are used only by the tags code (tg_). */
70 /* Type for the container (struct, union, class, union class). */
72 /* A comma separated list of parent classes. */
74 /* How many parents contains parents. */
78 static void indent (struct pr_handle *);
79 static bfd_boolean push_type (struct pr_handle *, const char *);
80 static bfd_boolean prepend_type (struct pr_handle *, const char *);
81 static bfd_boolean append_type (struct pr_handle *, const char *);
82 static bfd_boolean substitute_type (struct pr_handle *, const char *);
83 static bfd_boolean indent_type (struct pr_handle *);
84 static char *pop_type (struct pr_handle *);
85 static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
86 static bfd_boolean pr_fix_visibility
87 (struct pr_handle *, enum debug_visibility);
88 static bfd_boolean pr_start_compilation_unit (void *, const char *);
89 static bfd_boolean pr_start_source (void *, const char *);
90 static bfd_boolean pr_empty_type (void *);
91 static bfd_boolean pr_void_type (void *);
92 static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
93 static bfd_boolean pr_float_type (void *, unsigned int);
94 static bfd_boolean pr_complex_type (void *, unsigned int);
95 static bfd_boolean pr_bool_type (void *, unsigned int);
96 static bfd_boolean pr_enum_type
97 (void *, const char *, const char **, bfd_signed_vma *);
98 static bfd_boolean pr_pointer_type (void *);
99 static bfd_boolean pr_function_type (void *, int, bfd_boolean);
100 static bfd_boolean pr_reference_type (void *);
101 static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
102 static bfd_boolean pr_array_type
103 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
104 static bfd_boolean pr_set_type (void *, bfd_boolean);
105 static bfd_boolean pr_offset_type (void *);
106 static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
107 static bfd_boolean pr_const_type (void *);
108 static bfd_boolean pr_volatile_type (void *);
109 static bfd_boolean pr_start_struct_type
110 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
111 static bfd_boolean pr_struct_field
112 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
113 static bfd_boolean pr_end_struct_type (void *);
114 static bfd_boolean pr_start_class_type
115 (void *, const char *, unsigned int, bfd_boolean, unsigned int,
116 bfd_boolean, bfd_boolean);
117 static bfd_boolean pr_class_static_member
118 (void *, const char *, const char *, enum debug_visibility);
119 static bfd_boolean pr_class_baseclass
120 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
121 static bfd_boolean pr_class_start_method (void *, const char *);
122 static bfd_boolean pr_class_method_variant
123 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
124 bfd_vma, bfd_boolean);
125 static bfd_boolean pr_class_static_method_variant
126 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
127 static bfd_boolean pr_class_end_method (void *);
128 static bfd_boolean pr_end_class_type (void *);
129 static bfd_boolean pr_typedef_type (void *, const char *);
130 static bfd_boolean pr_tag_type
131 (void *, const char *, unsigned int, enum debug_type_kind);
132 static bfd_boolean pr_typdef (void *, const char *);
133 static bfd_boolean pr_tag (void *, const char *);
134 static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
135 static bfd_boolean pr_float_constant (void *, const char *, double);
136 static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
137 static bfd_boolean pr_variable
138 (void *, const char *, enum debug_var_kind, bfd_vma);
139 static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
140 static bfd_boolean pr_function_parameter
141 (void *, const char *, enum debug_parm_kind, bfd_vma);
142 static bfd_boolean pr_start_block (void *, bfd_vma);
143 static bfd_boolean pr_end_block (void *, bfd_vma);
144 static bfd_boolean pr_end_function (void *);
145 static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
146 static bfd_boolean append_parent (struct pr_handle *, const char *);
147 /* Only used by tg_ code. */
148 static bfd_boolean tg_fix_visibility
149 (struct pr_handle *, enum debug_visibility);
150 static void find_address_in_section (bfd *, asection *, void *);
151 static void translate_addresses (bfd *, char *, FILE *, asymbol **);
152 static const char *visibility_name (enum debug_visibility);
153 /* Tags style replacements. */
154 static bfd_boolean tg_start_compilation_unit (void *, const char *);
155 static bfd_boolean tg_start_source (void *, const char *);
156 static bfd_boolean tg_enum_type
157 (void *, const char *, const char **, bfd_signed_vma *);
158 static bfd_boolean tg_start_struct_type
159 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
160 static bfd_boolean pr_struct_field
161 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
162 static bfd_boolean tg_struct_field
163 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
164 static bfd_boolean tg_struct_field
165 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
166 static bfd_boolean tg_end_struct_type (void *);
167 static bfd_boolean tg_start_class_type
168 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
169 static bfd_boolean tg_class_static_member
170 (void *, const char *, const char *, enum debug_visibility);
171 static bfd_boolean tg_class_baseclass
172 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
173 static bfd_boolean tg_class_method_variant
174 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
175 static bfd_boolean tg_class_static_method_variant
176 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
177 static bfd_boolean tg_end_class_type (void *);
178 static bfd_boolean tg_tag_type
179 (void *, const char *, unsigned int, enum debug_type_kind);
180 static bfd_boolean tg_typdef (void *, const char *);
181 static bfd_boolean tg_tag (void *, const char *);
182 static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
183 static bfd_boolean tg_float_constant (void *, const char *, double);
184 static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
185 static bfd_boolean tg_variable
186 (void *, const char *, enum debug_var_kind, bfd_vma);
187 static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
188 static bfd_boolean tg_function_parameter
189 (void *, const char *, enum debug_parm_kind, bfd_vma);
190 static bfd_boolean tg_start_block (void *, bfd_vma);
191 static bfd_boolean tg_end_block (void *, bfd_vma);
192 static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
194 static const struct debug_write_fns pr_fns =
196 pr_start_compilation_unit,
215 pr_start_struct_type,
219 pr_class_static_member,
221 pr_class_start_method,
222 pr_class_method_variant,
223 pr_class_static_method_variant,
235 pr_function_parameter,
242 static const struct debug_write_fns tg_fns =
244 tg_start_compilation_unit,
246 pr_empty_type, /* Same, push_type. */
247 pr_void_type, /* Same, push_type. */
248 pr_int_type, /* Same, push_type. */
249 pr_float_type, /* Same, push_type. */
250 pr_complex_type, /* Same, push_type. */
251 pr_bool_type, /* Same, push_type. */
253 pr_pointer_type, /* Same, changes to pointer. */
254 pr_function_type, /* Same, push_type. */
255 pr_reference_type, /* Same, changes to reference. */
256 pr_range_type, /* FIXME: What's that?. */
257 pr_array_type, /* Same, push_type. */
258 pr_set_type, /* FIXME: What's that?. */
259 pr_offset_type, /* FIXME: What's that?. */
260 pr_method_type, /* Same. */
261 pr_const_type, /* Same, changes to const. */
262 pr_volatile_type, /* Same, changes to volatile. */
263 tg_start_struct_type,
267 tg_class_static_member,
269 pr_class_start_method, /* Same, remembers that's a method. */
270 tg_class_method_variant,
271 tg_class_static_method_variant,
272 pr_class_end_method, /* Same, forgets that's a method. */
274 pr_typedef_type, /* Same, just push type. */
278 tg_int_constant, /* Untested. */
279 tg_float_constant, /* Untested. */
280 tg_typed_constant, /* Untested. */
283 tg_function_parameter,
286 pr_end_function, /* Same, does nothing. */
290 /* Print out the generic debugging information recorded in dhandle. */
293 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
294 void *demangler, bfd_boolean as_tags)
296 struct pr_handle info;
302 info.filename = NULL;
305 info.demangler = (char * (*)(struct bfd *, const char *, int)) demangler;
309 fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);
310 fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);
311 fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);
312 fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);
315 return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
316 : debug_write (dhandle, &pr_fns, (void *) & info);
319 /* Indent to the current indentation level. */
322 indent (struct pr_handle *info)
326 for (i = 0; i < info->indent; i++)
330 /* Push a type on the type stack. */
333 push_type (struct pr_handle *info, const char *type)
340 n = (struct pr_stack *) xmalloc (sizeof *n);
341 memset (n, 0, sizeof *n);
343 n->type = xstrdup (type);
344 n->visibility = DEBUG_VISIBILITY_IGNORE;
346 n->next = info->stack;
352 /* Prepend a string onto the type on the top of the type stack. */
355 prepend_type (struct pr_handle *info, const char *s)
359 assert (info->stack != NULL);
361 n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
362 sprintf (n, "%s%s", s, info->stack->type);
363 free (info->stack->type);
364 info->stack->type = n;
369 /* Append a string to the type on the top of the type stack. */
372 append_type (struct pr_handle *info, const char *s)
379 assert (info->stack != NULL);
381 len = strlen (info->stack->type);
382 info->stack->type = (char *) xrealloc (info->stack->type,
383 len + strlen (s) + 1);
384 strcpy (info->stack->type + len, s);
389 /* Append a string to the parents on the top of the type stack. */
392 append_parent (struct pr_handle *info, const char *s)
399 assert (info->stack != NULL);
401 len = info->stack->parents ? strlen (info->stack->parents) : 0;
402 info->stack->parents = (char *) xrealloc (info->stack->parents,
403 len + strlen (s) + 1);
404 strcpy (info->stack->parents + len, s);
409 /* We use an underscore to indicate where the name should go in a type
410 string. This function substitutes a string for the underscore. If
411 there is no underscore, the name follows the type. */
414 substitute_type (struct pr_handle *info, const char *s)
418 assert (info->stack != NULL);
420 u = strchr (info->stack->type, '|');
425 n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
427 memcpy (n, info->stack->type, u - info->stack->type);
428 strcpy (n + (u - info->stack->type), s);
431 free (info->stack->type);
432 info->stack->type = n;
437 if (strchr (s, '|') != NULL
438 && (strchr (info->stack->type, '{') != NULL
439 || strchr (info->stack->type, '(') != NULL))
441 if (! prepend_type (info, "(")
442 || ! append_type (info, ")"))
449 return (append_type (info, " ")
450 && append_type (info, s));
453 /* Indent the type at the top of the stack by appending spaces. */
456 indent_type (struct pr_handle *info)
460 for (i = 0; i < info->indent; i++)
462 if (! append_type (info, " "))
469 /* Pop a type from the type stack. */
472 pop_type (struct pr_handle *info)
477 assert (info->stack != NULL);
480 info->stack = o->next;
487 /* Print a VMA value into a string. */
490 print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
492 if (sizeof (vma) <= sizeof (unsigned long))
495 sprintf (buf, "0x%lx", (unsigned long) vma);
497 sprintf (buf, "%lu", (unsigned long) vma);
499 sprintf (buf, "%ld", (long) vma);
501 #if BFD_HOST_64BIT_LONG_LONG
502 else if (sizeof (vma) <= sizeof (unsigned long long))
506 sprintf (buf, "0x%llx", (unsigned long long) vma);
508 sprintf (buf, "%llu", (unsigned long long) vma);
510 sprintf (buf, "%lld", (long long) vma);
513 sprintf (buf, "0x%I64x", (unsigned long long) vma);
515 sprintf (buf, "%I64u", (unsigned long long) vma);
517 sprintf (buf, "%I64d", (long long) vma);
525 sprintf_vma (buf + 2, vma);
529 /* Start a new compilation unit. */
532 pr_start_compilation_unit (void *p, const char *filename)
534 struct pr_handle *info = (struct pr_handle *) p;
536 assert (info->indent == 0);
538 fprintf (info->f, "%s:\n", filename);
543 /* Start a source file within a compilation unit. */
546 pr_start_source (void *p, const char *filename)
548 struct pr_handle *info = (struct pr_handle *) p;
550 assert (info->indent == 0);
552 fprintf (info->f, " %s:\n", filename);
557 /* Push an empty type onto the type stack. */
560 pr_empty_type (void *p)
562 struct pr_handle *info = (struct pr_handle *) p;
564 return push_type (info, "<undefined>");
567 /* Push a void type onto the type stack. */
570 pr_void_type (void *p)
572 struct pr_handle *info = (struct pr_handle *) p;
574 return push_type (info, "void");
577 /* Push an integer type onto the type stack. */
580 pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
582 struct pr_handle *info = (struct pr_handle *) p;
585 sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
586 return push_type (info, ab);
589 /* Push a floating type onto the type stack. */
592 pr_float_type (void *p, unsigned int size)
594 struct pr_handle *info = (struct pr_handle *) p;
598 return push_type (info, "float");
600 return push_type (info, "double");
602 sprintf (ab, "float%d", size * 8);
603 return push_type (info, ab);
606 /* Push a complex type onto the type stack. */
609 pr_complex_type (void *p, unsigned int size)
611 struct pr_handle *info = (struct pr_handle *) p;
613 if (! pr_float_type (p, size))
616 return prepend_type (info, "complex ");
619 /* Push a bfd_boolean type onto the type stack. */
622 pr_bool_type (void *p, unsigned int size)
624 struct pr_handle *info = (struct pr_handle *) p;
627 sprintf (ab, "bool%d", size * 8);
629 return push_type (info, ab);
632 /* Push an enum type onto the type stack. */
635 pr_enum_type (void *p, const char *tag, const char **names,
636 bfd_signed_vma *values)
638 struct pr_handle *info = (struct pr_handle *) p;
642 if (! push_type (info, "enum "))
646 if (! append_type (info, tag)
647 || ! append_type (info, " "))
650 if (! append_type (info, "{ "))
655 if (! append_type (info, "/* undefined */"))
661 for (i = 0; names[i] != NULL; i++)
665 if (! append_type (info, ", "))
669 if (! append_type (info, names[i]))
672 if (values[i] != val)
676 print_vma (values[i], ab, FALSE, FALSE);
677 if (! append_type (info, " = ")
678 || ! append_type (info, ab))
687 return append_type (info, " }");
690 /* Turn the top type on the stack into a pointer. */
693 pr_pointer_type (void *p)
695 struct pr_handle *info = (struct pr_handle *) p;
698 assert (info->stack != NULL);
700 s = strchr (info->stack->type, '|');
701 if (s != NULL && s[1] == '[')
702 return substitute_type (info, "(*|)");
703 return substitute_type (info, "*|");
706 /* Turn the top type on the stack into a function returning that type. */
709 pr_function_type (void *p, int argcount, bfd_boolean varargs)
711 struct pr_handle *info = (struct pr_handle *) p;
716 assert (info->stack != NULL);
729 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
730 for (i = argcount - 1; i >= 0; i--)
732 if (! substitute_type (info, ""))
737 arg_types[i] = pop_type (info);
738 if (arg_types[i] == NULL)
743 len += strlen (arg_types[i]) + 2;
749 /* Now the return type is on the top of the stack. */
751 s = (char *) xmalloc (len);
752 LITSTRCPY (s, "(|) (");
755 strcat (s, "/* unknown */");
760 for (i = 0; i < argcount; i++)
764 strcat (s, arg_types[i]);
778 if (! substitute_type (info, s))
786 /* Turn the top type on the stack into a reference to that type. */
789 pr_reference_type (void *p)
791 struct pr_handle *info = (struct pr_handle *) p;
793 assert (info->stack != NULL);
795 return substitute_type (info, "&|");
798 /* Make a range type. */
801 pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
803 struct pr_handle *info = (struct pr_handle *) p;
804 char abl[20], abu[20];
806 assert (info->stack != NULL);
808 if (! substitute_type (info, ""))
811 print_vma (lower, abl, FALSE, FALSE);
812 print_vma (upper, abu, FALSE, FALSE);
814 return (prepend_type (info, "range (")
815 && append_type (info, "):")
816 && append_type (info, abl)
817 && append_type (info, ":")
818 && append_type (info, abu));
821 /* Make an array type. */
824 pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
827 struct pr_handle *info = (struct pr_handle *) p;
829 char abl[20], abu[20], ab[50];
831 range_type = pop_type (info);
832 if (range_type == NULL)
841 print_vma (upper + 1, abu, FALSE, FALSE);
842 sprintf (ab, "|[%s]", abu);
847 print_vma (lower, abl, FALSE, FALSE);
848 print_vma (upper, abu, FALSE, FALSE);
849 sprintf (ab, "|[%s:%s]", abl, abu);
852 if (! substitute_type (info, ab))
855 if (strcmp (range_type, "int") != 0)
857 if (! append_type (info, ":")
858 || ! append_type (info, range_type))
864 if (! append_type (info, " /* string */"))
871 /* Make a set type. */
874 pr_set_type (void *p, bfd_boolean bitstringp)
876 struct pr_handle *info = (struct pr_handle *) p;
878 if (! substitute_type (info, ""))
881 if (! prepend_type (info, "set { ")
882 || ! append_type (info, " }"))
887 if (! append_type (info, "/* bitstring */"))
894 /* Make an offset type. */
897 pr_offset_type (void *p)
899 struct pr_handle *info = (struct pr_handle *) p;
902 if (! substitute_type (info, ""))
909 return (substitute_type (info, "")
910 && prepend_type (info, " ")
911 && prepend_type (info, t)
912 && append_type (info, "::|"));
915 /* Make a method type. */
918 pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
920 struct pr_handle *info = (struct pr_handle *) p;
932 if (! substitute_type (info, ""))
934 domain_type = pop_type (info);
935 if (domain_type == NULL)
937 if (CONST_STRNEQ (domain_type, "class ")
938 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
939 domain_type += sizeof "class " - 1;
940 else if (CONST_STRNEQ (domain_type, "union class ")
941 && (strchr (domain_type + sizeof "union class " - 1, ' ')
943 domain_type += sizeof "union class " - 1;
944 len += strlen (domain_type);
956 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
957 for (i = argcount - 1; i >= 0; i--)
959 if (! substitute_type (info, ""))
964 arg_types[i] = pop_type (info);
965 if (arg_types[i] == NULL)
970 len += strlen (arg_types[i]) + 2;
976 /* Now the return type is on the top of the stack. */
978 s = (char *) xmalloc (len);
982 strcpy (s, domain_type);
986 strcat (s, "/* unknown */");
991 for (i = 0; i < argcount; i++)
995 strcat (s, arg_types[i]);
1009 if (! substitute_type (info, s))
1017 /* Make a const qualified type. */
1020 pr_const_type (void *p)
1022 struct pr_handle *info = (struct pr_handle *) p;
1024 return substitute_type (info, "const |");
1027 /* Make a volatile qualified type. */
1030 pr_volatile_type (void *p)
1032 struct pr_handle *info = (struct pr_handle *) p;
1034 return substitute_type (info, "volatile |");
1037 /* Start accumulating a struct type. */
1040 pr_start_struct_type (void *p, const char *tag, unsigned int id,
1041 bfd_boolean structp, unsigned int size)
1043 struct pr_handle *info = (struct pr_handle *) p;
1047 if (! push_type (info, structp ? "struct " : "union "))
1051 if (! append_type (info, tag))
1058 sprintf (idbuf, "%%anon%u", id);
1059 if (! append_type (info, idbuf))
1063 if (! append_type (info, " {"))
1065 if (size != 0 || tag != NULL)
1069 if (! append_type (info, " /*"))
1074 sprintf (ab, " size %u", size);
1075 if (! append_type (info, ab))
1080 sprintf (ab, " id %u", id);
1081 if (! append_type (info, ab))
1084 if (! append_type (info, " */"))
1087 if (! append_type (info, "\n"))
1090 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
1092 return indent_type (info);
1095 /* Output the visibility of a field in a struct. */
1098 pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1100 const char *s = NULL;
1104 assert (info->stack != NULL);
1106 if (info->stack->visibility == visibility)
1111 case DEBUG_VISIBILITY_PUBLIC:
1114 case DEBUG_VISIBILITY_PRIVATE:
1117 case DEBUG_VISIBILITY_PROTECTED:
1120 case DEBUG_VISIBILITY_IGNORE:
1128 /* Trim off a trailing space in the struct string, to make the
1129 output look a bit better, then stick on the visibility string. */
1131 t = info->stack->type;
1133 assert (t[len - 1] == ' ');
1136 if (! append_type (info, s)
1137 || ! append_type (info, ":\n")
1138 || ! indent_type (info))
1141 info->stack->visibility = visibility;
1146 /* Add a field to a struct type. */
1149 pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
1150 enum debug_visibility visibility)
1152 struct pr_handle *info = (struct pr_handle *) p;
1156 if (! substitute_type (info, name))
1159 if (! append_type (info, "; /* "))
1164 print_vma (bitsize, ab, TRUE, FALSE);
1165 if (! append_type (info, "bitsize ")
1166 || ! append_type (info, ab)
1167 || ! append_type (info, ", "))
1171 print_vma (bitpos, ab, TRUE, FALSE);
1172 if (! append_type (info, "bitpos ")
1173 || ! append_type (info, ab)
1174 || ! append_type (info, " */\n")
1175 || ! indent_type (info))
1178 t = pop_type (info);
1182 if (! pr_fix_visibility (info, visibility))
1185 return append_type (info, t);
1188 /* Finish a struct type. */
1191 pr_end_struct_type (void *p)
1193 struct pr_handle *info = (struct pr_handle *) p;
1196 assert (info->stack != NULL);
1197 assert (info->indent >= 2);
1201 /* Change the trailing indentation to have a close brace. */
1202 s = info->stack->type + strlen (info->stack->type) - 2;
1203 assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1211 /* Start a class type. */
1214 pr_start_class_type (void *p, const char *tag, unsigned int id,
1215 bfd_boolean structp, unsigned int size,
1216 bfd_boolean vptr, bfd_boolean ownvptr)
1218 struct pr_handle *info = (struct pr_handle *) p;
1223 if (vptr && ! ownvptr)
1225 tv = pop_type (info);
1230 if (! push_type (info, structp ? "class " : "union class "))
1234 if (! append_type (info, tag))
1241 sprintf (idbuf, "%%anon%u", id);
1242 if (! append_type (info, idbuf))
1246 if (! append_type (info, " {"))
1248 if (size != 0 || vptr || ownvptr || tag != NULL)
1250 if (! append_type (info, " /*"))
1257 sprintf (ab, "%u", size);
1258 if (! append_type (info, " size ")
1259 || ! append_type (info, ab))
1265 if (! append_type (info, " vtable "))
1269 if (! append_type (info, "self "))
1274 if (! append_type (info, tv)
1275 || ! append_type (info, " "))
1284 sprintf (ab, " id %u", id);
1285 if (! append_type (info, ab))
1289 if (! append_type (info, " */"))
1293 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1295 return (append_type (info, "\n")
1296 && indent_type (info));
1299 /* Add a static member to a class. */
1302 pr_class_static_member (void *p, const char *name, const char *physname,
1303 enum debug_visibility visibility)
1305 struct pr_handle *info = (struct pr_handle *) p;
1308 if (! substitute_type (info, name))
1311 if (! prepend_type (info, "static ")
1312 || ! append_type (info, "; /* ")
1313 || ! append_type (info, physname)
1314 || ! append_type (info, " */\n")
1315 || ! indent_type (info))
1318 t = pop_type (info);
1322 if (! pr_fix_visibility (info, visibility))
1325 return append_type (info, t);
1328 /* Add a base class to a class. */
1331 pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
1332 enum debug_visibility visibility)
1334 struct pr_handle *info = (struct pr_handle *) p;
1340 assert (info->stack != NULL && info->stack->next != NULL);
1342 if (! substitute_type (info, ""))
1345 t = pop_type (info);
1349 if (CONST_STRNEQ (t, "class "))
1350 t += sizeof "class " - 1;
1352 /* Push it back on to take advantage of the prepend_type and
1353 append_type routines. */
1354 if (! push_type (info, t))
1359 if (! prepend_type (info, "virtual "))
1365 case DEBUG_VISIBILITY_PUBLIC:
1368 case DEBUG_VISIBILITY_PROTECTED:
1369 prefix = "protected ";
1371 case DEBUG_VISIBILITY_PRIVATE:
1372 prefix = "private ";
1375 prefix = "/* unknown visibility */ ";
1379 if (! prepend_type (info, prefix))
1384 print_vma (bitpos, ab, TRUE, FALSE);
1385 if (! append_type (info, " /* bitpos ")
1386 || ! append_type (info, ab)
1387 || ! append_type (info, " */"))
1391 /* Now the top of the stack is something like "public A / * bitpos
1392 10 * /". The next element on the stack is something like "class
1393 xx { / * size 8 * /\n...". We want to substitute the top of the
1394 stack in before the {. */
1395 s = strchr (info->stack->next->type, '{');
1399 /* If there is already a ':', then we already have a baseclass, and
1400 we must append this one after a comma. */
1401 for (l = info->stack->next->type; l != s; l++)
1404 if (! prepend_type (info, l == s ? " : " : ", "))
1407 t = pop_type (info);
1411 n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1412 memcpy (n, info->stack->type, s - info->stack->type);
1413 strcpy (n + (s - info->stack->type), t);
1416 free (info->stack->type);
1417 info->stack->type = n;
1424 /* Start adding a method to a class. */
1427 pr_class_start_method (void *p, const char *name)
1429 struct pr_handle *info = (struct pr_handle *) p;
1431 assert (info->stack != NULL);
1432 info->stack->method = name;
1436 /* Add a variant to a method. */
1439 pr_class_method_variant (void *p, const char *physname,
1440 enum debug_visibility visibility,
1441 bfd_boolean constp, bfd_boolean volatilep,
1442 bfd_vma voffset, bfd_boolean context)
1444 struct pr_handle *info = (struct pr_handle *) p;
1448 assert (info->stack != NULL);
1449 assert (info->stack->next != NULL);
1451 /* Put the const and volatile qualifiers on the type. */
1454 if (! append_type (info, " volatile"))
1459 if (! append_type (info, " const"))
1463 /* Stick the name of the method into its type. */
1464 if (! substitute_type (info,
1466 ? info->stack->next->next->method
1467 : info->stack->next->method)))
1471 method_type = pop_type (info);
1472 if (method_type == NULL)
1475 /* Pull off the context type if there is one. */
1477 context_type = NULL;
1480 context_type = pop_type (info);
1481 if (context_type == NULL)
1485 /* Now the top of the stack is the class. */
1487 if (! pr_fix_visibility (info, visibility))
1490 if (! append_type (info, method_type)
1491 || ! append_type (info, " /* ")
1492 || ! append_type (info, physname)
1493 || ! append_type (info, " "))
1495 if (context || voffset != 0)
1501 if (! append_type (info, "context ")
1502 || ! append_type (info, context_type)
1503 || ! append_type (info, " "))
1506 print_vma (voffset, ab, TRUE, FALSE);
1507 if (! append_type (info, "voffset ")
1508 || ! append_type (info, ab))
1512 return (append_type (info, " */;\n")
1513 && indent_type (info));
1516 /* Add a static variant to a method. */
1519 pr_class_static_method_variant (void *p, const char *physname,
1520 enum debug_visibility visibility,
1521 bfd_boolean constp, bfd_boolean volatilep)
1523 struct pr_handle *info = (struct pr_handle *) p;
1526 assert (info->stack != NULL);
1527 assert (info->stack->next != NULL);
1528 assert (info->stack->next->method != NULL);
1530 /* Put the const and volatile qualifiers on the type. */
1533 if (! append_type (info, " volatile"))
1538 if (! append_type (info, " const"))
1542 /* Mark it as static. */
1543 if (! prepend_type (info, "static "))
1546 /* Stick the name of the method into its type. */
1547 if (! substitute_type (info, info->stack->next->method))
1551 method_type = pop_type (info);
1552 if (method_type == NULL)
1555 /* Now the top of the stack is the class. */
1557 if (! pr_fix_visibility (info, visibility))
1560 return (append_type (info, method_type)
1561 && append_type (info, " /* ")
1562 && append_type (info, physname)
1563 && append_type (info, " */;\n")
1564 && indent_type (info));
1567 /* Finish up a method. */
1570 pr_class_end_method (void *p)
1572 struct pr_handle *info = (struct pr_handle *) p;
1574 info->stack->method = NULL;
1578 /* Finish up a class. */
1581 pr_end_class_type (void *p)
1583 return pr_end_struct_type (p);
1586 /* Push a type on the stack using a typedef name. */
1589 pr_typedef_type (void *p, const char *name)
1591 struct pr_handle *info = (struct pr_handle *) p;
1593 return push_type (info, name);
1596 /* Push a type on the stack using a tag name. */
1599 pr_tag_type (void *p, const char *name, unsigned int id,
1600 enum debug_type_kind kind)
1602 struct pr_handle *info = (struct pr_handle *) p;
1603 const char *t, *tag;
1608 case DEBUG_KIND_STRUCT:
1611 case DEBUG_KIND_UNION:
1614 case DEBUG_KIND_ENUM:
1617 case DEBUG_KIND_CLASS:
1620 case DEBUG_KIND_UNION_CLASS:
1628 if (! push_type (info, t))
1634 sprintf (idbuf, "%%anon%u", id);
1638 if (! append_type (info, tag))
1640 if (name != NULL && kind != DEBUG_KIND_ENUM)
1642 sprintf (idbuf, " /* id %u */", id);
1643 if (! append_type (info, idbuf))
1650 /* Output a typedef. */
1653 pr_typdef (void *p, const char *name)
1655 struct pr_handle *info = (struct pr_handle *) p;
1658 if (! substitute_type (info, name))
1661 s = pop_type (info);
1666 fprintf (info->f, "typedef %s;\n", s);
1673 /* Output a tag. The tag should already be in the string on the
1674 stack, so all we have to do here is print it out. */
1677 pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
1679 struct pr_handle *info = (struct pr_handle *) p;
1682 t = pop_type (info);
1687 fprintf (info->f, "%s;\n", t);
1694 /* Output an integer constant. */
1697 pr_int_constant (void *p, const char *name, bfd_vma val)
1699 struct pr_handle *info = (struct pr_handle *) p;
1703 print_vma (val, ab, FALSE, FALSE);
1704 fprintf (info->f, "const int %s = %s;\n", name, ab);
1708 /* Output a floating point constant. */
1711 pr_float_constant (void *p, const char *name, double val)
1713 struct pr_handle *info = (struct pr_handle *) p;
1716 fprintf (info->f, "const double %s = %g;\n", name, val);
1720 /* Output a typed constant. */
1723 pr_typed_constant (void *p, const char *name, bfd_vma val)
1725 struct pr_handle *info = (struct pr_handle *) p;
1729 t = pop_type (info);
1734 print_vma (val, ab, FALSE, FALSE);
1735 fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1742 /* Output a variable. */
1745 pr_variable (void *p, const char *name, enum debug_var_kind kind,
1748 struct pr_handle *info = (struct pr_handle *) p;
1752 if (! substitute_type (info, name))
1755 t = pop_type (info);
1763 case DEBUG_LOCAL_STATIC:
1764 fprintf (info->f, "static ");
1766 case DEBUG_REGISTER:
1767 fprintf (info->f, "register ");
1772 print_vma (val, ab, TRUE, TRUE);
1773 fprintf (info->f, "%s /* %s */;\n", t, ab);
1780 /* Start outputting a function. */
1783 pr_start_function (void *p, const char *name, bfd_boolean global)
1785 struct pr_handle *info = (struct pr_handle *) p;
1788 if (! substitute_type (info, name))
1791 t = pop_type (info);
1797 fprintf (info->f, "static ");
1798 fprintf (info->f, "%s (", t);
1800 info->parameter = 1;
1805 /* Output a function parameter. */
1808 pr_function_parameter (void *p, const char *name,
1809 enum debug_parm_kind kind, bfd_vma val)
1811 struct pr_handle *info = (struct pr_handle *) p;
1815 if (kind == DEBUG_PARM_REFERENCE
1816 || kind == DEBUG_PARM_REF_REG)
1818 if (! pr_reference_type (p))
1822 if (! substitute_type (info, name))
1825 t = pop_type (info);
1829 if (info->parameter != 1)
1830 fprintf (info->f, ", ");
1832 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1833 fprintf (info->f, "register ");
1835 print_vma (val, ab, TRUE, TRUE);
1836 fprintf (info->f, "%s /* %s */", t, ab);
1845 /* Start writing out a block. */
1848 pr_start_block (void *p, bfd_vma addr)
1850 struct pr_handle *info = (struct pr_handle *) p;
1853 if (info->parameter > 0)
1855 fprintf (info->f, ")\n");
1856 info->parameter = 0;
1860 print_vma (addr, ab, TRUE, TRUE);
1861 fprintf (info->f, "{ /* %s */\n", ab);
1868 /* Write out line number information. */
1871 pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1873 struct pr_handle *info = (struct pr_handle *) p;
1877 print_vma (addr, ab, TRUE, TRUE);
1878 fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1883 /* Finish writing out a block. */
1886 pr_end_block (void *p, bfd_vma addr)
1888 struct pr_handle *info = (struct pr_handle *) p;
1894 print_vma (addr, ab, TRUE, TRUE);
1895 fprintf (info->f, "} /* %s */\n", ab);
1900 /* Finish writing out a function. */
1903 pr_end_function (void *p ATTRIBUTE_UNUSED)
1908 /* Tags style generation functions start here. */
1910 /* Variables for address to line translation. */
1912 static const char *filename;
1913 static const char *functionname;
1914 static unsigned int line;
1915 static bfd_boolean found;
1917 /* Look for an address in a section. This is called via
1918 bfd_map_over_sections. */
1921 find_address_in_section (bfd *abfd, asection *section, void *data)
1925 asymbol **syms = (asymbol **) data;
1930 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
1933 vma = bfd_get_section_vma (abfd, section);
1937 size = bfd_get_section_size (section);
1938 if (pc >= vma + size)
1941 found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
1942 &filename, &functionname, &line);
1946 translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1948 pc = bfd_scan_vma (addr_hex, NULL, 16);
1950 bfd_map_over_sections (abfd, find_address_in_section, syms);
1955 fprintf (f, "%u", line);
1958 /* Start a new compilation unit. */
1961 tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED)
1963 struct pr_handle *info = (struct pr_handle *) p;
1965 free (info->filename);
1966 /* Should it be relative? best way to do it here?. */
1967 info->filename = strdup (fname);
1972 /* Start a source file within a compilation unit. */
1975 tg_start_source (void *p, const char *fname)
1977 struct pr_handle *info = (struct pr_handle *) p;
1979 free (info->filename);
1980 /* Should it be relative? best way to do it here?. */
1981 info->filename = strdup (fname);
1986 /* Push an enum type onto the type stack. */
1989 tg_enum_type (void *p, const char *tag, const char **names,
1990 bfd_signed_vma *values)
1992 struct pr_handle *info = (struct pr_handle *) p;
1997 if (! pr_enum_type (p, tag, names, values))
2000 name = tag ? tag : "unknown";
2001 /* Generate an entry for the enum. */
2003 fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
2004 info->filename, info->stack->type);
2006 /* Generate entries for the values. */
2009 for (i = 0; names[i] != NULL; i++)
2011 print_vma (values[i], ab, FALSE, FALSE);
2012 fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
2013 names[i], info->filename, name, ab);
2020 /* Start accumulating a struct type. */
2023 tg_start_struct_type (void *p, const char *tag, unsigned int id,
2024 bfd_boolean structp,
2025 unsigned int size ATTRIBUTE_UNUSED)
2027 struct pr_handle *info = (struct pr_handle *) p;
2036 sprintf (idbuf, "%%anon%u", id);
2039 if (! push_type (info, name))
2042 info->stack->flavor = structp ? "struct" : "union";
2044 fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
2045 info->stack->flavor[0]);
2047 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
2049 return indent_type (info);
2052 /* Output the visibility of a field in a struct. */
2055 tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2057 assert (info->stack != NULL);
2059 if (info->stack->visibility == visibility)
2062 assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
2064 info->stack->visibility = visibility;
2069 /* Add a field to a struct type. */
2072 tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
2073 bfd_vma bitsize ATTRIBUTE_UNUSED,
2074 enum debug_visibility visibility)
2076 struct pr_handle *info = (struct pr_handle *) p;
2079 t = pop_type (info);
2083 if (! tg_fix_visibility (info, visibility))
2086 /* It happens, a bug? */
2090 fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
2091 name, info->filename, t, info->stack->flavor, info->stack->type,
2092 visibility_name (visibility));
2097 /* Finish a struct type. */
2100 tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
2102 assert (((struct pr_handle *) p)->stack != NULL);
2107 /* Start a class type. */
2110 tg_start_class_type (void *p, const char *tag, unsigned int id,
2111 bfd_boolean structp, unsigned int size,
2112 bfd_boolean vptr, bfd_boolean ownvptr)
2114 struct pr_handle *info = (struct pr_handle *) p;
2120 if (vptr && ! ownvptr)
2122 tv = pop_type (info);
2133 sprintf (idbuf, "%%anon%u", id);
2137 if (! push_type (info, name))
2140 info->stack->flavor = structp ? "class" : "union class";
2141 info->stack->parents = NULL;
2142 info->stack->num_parents = 0;
2144 if (size != 0 || vptr || ownvptr || tag != NULL)
2148 if (! append_type (info, " vtable "))
2152 if (! append_type (info, "self "))
2157 if (! append_type (info, tv)
2158 || ! append_type (info, " "))
2164 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2169 /* Add a static member to a class. */
2172 tg_class_static_member (void *p, const char *name,
2173 const char *physname ATTRIBUTE_UNUSED,
2174 enum debug_visibility visibility)
2176 struct pr_handle *info = (struct pr_handle *) p;
2178 int len_var, len_class;
2181 len_var = strlen (name);
2182 len_class = strlen (info->stack->next->type);
2183 full_name = (char *) xmalloc (len_var + len_class + 3);
2186 sprintf (full_name, "%s::%s", info->stack->next->type, name);
2188 if (! substitute_type (info, full_name))
2194 if (! prepend_type (info, "static "))
2200 t = pop_type (info);
2207 if (! tg_fix_visibility (info, visibility))
2214 fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2215 name, info->filename, t, info->stack->type,
2216 visibility_name (visibility));
2223 /* Add a base class to a class. */
2226 tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2227 bfd_boolean is_virtual, enum debug_visibility visibility)
2229 struct pr_handle *info = (struct pr_handle *) p;
2233 assert (info->stack != NULL && info->stack->next != NULL);
2235 t = pop_type (info);
2239 if (CONST_STRNEQ (t, "class "))
2240 t += sizeof "class " - 1;
2242 /* Push it back on to take advantage of the prepend_type and
2243 append_type routines. */
2244 if (! push_type (info, t))
2249 if (! prepend_type (info, "virtual "))
2255 case DEBUG_VISIBILITY_PUBLIC:
2258 case DEBUG_VISIBILITY_PROTECTED:
2259 prefix = "protected ";
2261 case DEBUG_VISIBILITY_PRIVATE:
2262 prefix = "private ";
2265 prefix = "/* unknown visibility */ ";
2269 if (! prepend_type (info, prefix))
2272 t = pop_type (info);
2276 if (info->stack->num_parents && ! append_parent (info, ", "))
2279 if (! append_parent (info, t))
2281 info->stack->num_parents++;
2288 /* Add a variant to a method. */
2291 tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2292 enum debug_visibility visibility,
2293 bfd_boolean constp, bfd_boolean volatilep,
2294 bfd_vma voffset ATTRIBUTE_UNUSED,
2295 bfd_boolean context)
2297 struct pr_handle *info = (struct pr_handle *) p;
2302 assert (info->stack != NULL);
2303 assert (info->stack->next != NULL);
2305 /* Put the const and volatile qualifiers on the type. */
2308 if (! append_type (info, " volatile"))
2313 if (! append_type (info, " const"))
2317 method_name = strdup (context ? info->stack->next->next->method
2318 : info->stack->next->method);
2320 /* Stick the name of the method into its type. */
2321 if (! substitute_type (info, method_name))
2328 method_type = pop_type (info);
2329 if (method_type == NULL)
2335 /* Pull off the context type if there is one. */
2337 context_type = NULL;
2340 context_type = pop_type (info);
2341 if (context_type == NULL)
2349 /* Now the top of the stack is the class. */
2350 if (! tg_fix_visibility (info, visibility))
2354 free (context_type);
2358 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2359 method_name, info->filename, method_type, info->stack->type);
2362 free (context_type);
2367 /* Add a static variant to a method. */
2370 tg_class_static_method_variant (void *p,
2371 const char *physname ATTRIBUTE_UNUSED,
2372 enum debug_visibility visibility,
2373 bfd_boolean constp, bfd_boolean volatilep)
2375 struct pr_handle *info = (struct pr_handle *) p;
2379 assert (info->stack != NULL);
2380 assert (info->stack->next != NULL);
2381 assert (info->stack->next->method != NULL);
2383 /* Put the const and volatile qualifiers on the type. */
2386 if (! append_type (info, " volatile"))
2391 if (! append_type (info, " const"))
2395 /* Mark it as static. */
2396 if (! prepend_type (info, "static "))
2399 method_name = strdup (info->stack->next->method);
2400 /* Stick the name of the method into its type. */
2401 if (! substitute_type (info, info->stack->next->method))
2408 method_type = pop_type (info);
2409 if (method_type == NULL)
2415 /* Now the top of the stack is the class. */
2416 if (! tg_fix_visibility (info, visibility))
2423 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2424 method_name, info->filename, method_type, info->stack->type,
2425 visibility_name (visibility));
2432 /* Finish up a class. */
2435 tg_end_class_type (void *p)
2437 struct pr_handle *info = (struct pr_handle *) p;
2439 fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2440 info->filename, info->stack->flavor);
2441 if (info->stack->num_parents)
2443 fprintf (info->f, "\tinherits:%s", info->stack->parents);
2444 free (info->stack->parents);
2446 fputc ('\n', info->f);
2448 return tg_end_struct_type (p);
2451 /* Push a type on the stack using a tag name. */
2454 tg_tag_type (void *p, const char *name, unsigned int id,
2455 enum debug_type_kind kind)
2457 struct pr_handle *info = (struct pr_handle *) p;
2458 const char *t, *tag;
2463 case DEBUG_KIND_STRUCT:
2466 case DEBUG_KIND_UNION:
2469 case DEBUG_KIND_ENUM:
2472 case DEBUG_KIND_CLASS:
2475 case DEBUG_KIND_UNION_CLASS:
2483 if (! push_type (info, t))
2489 sprintf (idbuf, "%%anon%u", id);
2493 if (! append_type (info, tag))
2499 /* Output a typedef. */
2502 tg_typdef (void *p, const char *name)
2504 struct pr_handle *info = (struct pr_handle *) p;
2507 s = pop_type (info);
2511 fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2519 /* Output a tag. The tag should already be in the string on the
2520 stack, so all we have to do here is print it out. */
2523 tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2525 struct pr_handle *info = (struct pr_handle *) p;
2528 t = pop_type (info);
2536 /* Output an integer constant. */
2539 tg_int_constant (void *p, const char *name, bfd_vma val)
2541 struct pr_handle *info = (struct pr_handle *) p;
2545 print_vma (val, ab, FALSE, FALSE);
2546 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2547 name, info->filename, ab);
2551 /* Output a floating point constant. */
2554 tg_float_constant (void *p, const char *name, double val)
2556 struct pr_handle *info = (struct pr_handle *) p;
2559 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2560 name, info->filename, val);
2564 /* Output a typed constant. */
2567 tg_typed_constant (void *p, const char *name, bfd_vma val)
2569 struct pr_handle *info = (struct pr_handle *) p;
2573 t = pop_type (info);
2578 print_vma (val, ab, FALSE, FALSE);
2579 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2580 name, info->filename, t, ab);
2587 /* Output a variable. */
2590 tg_variable (void *p, const char *name, enum debug_var_kind kind,
2591 bfd_vma val ATTRIBUTE_UNUSED)
2593 struct pr_handle *info = (struct pr_handle *) p;
2594 char *t, *dname, *from_class;
2596 t = pop_type (info);
2601 if (info->demangler)
2602 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2608 sep = strstr (dname, "::");
2616 /* Obscure types as vts and type_info nodes. */
2620 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2625 case DEBUG_LOCAL_STATIC:
2626 fprintf (info->f, "\tfile:");
2628 case DEBUG_REGISTER:
2629 fprintf (info->f, "\tregister:");
2636 fprintf (info->f, "\tclass:%s", from_class);
2641 fprintf (info->f, "\n");
2648 /* Start outputting a function. */
2651 tg_start_function (void *p, const char *name, bfd_boolean global)
2653 struct pr_handle *info = (struct pr_handle *) p;
2657 info->stack->flavor = "static";
2659 info->stack->flavor = NULL;
2662 if (info->demangler)
2663 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2665 if (! substitute_type (info, dname ? dname : name))
2668 info->stack->method = NULL;
2672 sep = strstr (dname, "::");
2675 info->stack->method = dname;
2681 info->stack->method = "";
2684 sep = strchr (name, '(');
2687 /* Obscure functions as type_info function. */
2690 info->stack->parents = strdup (name);
2692 if (! info->stack->method && ! append_type (info, "("))
2695 info->parameter = 1;
2700 /* Output a function parameter. */
2703 tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2704 bfd_vma val ATTRIBUTE_UNUSED)
2706 struct pr_handle *info = (struct pr_handle *) p;
2709 if (kind == DEBUG_PARM_REFERENCE
2710 || kind == DEBUG_PARM_REF_REG)
2712 if (! pr_reference_type (p))
2716 if (! substitute_type (info, name))
2719 t = pop_type (info);
2723 if (! info->stack->method)
2725 if (info->parameter != 1 && ! append_type (info, ", "))
2728 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2729 if (! append_type (info, "register "))
2732 if (! append_type (info, t))
2743 /* Start writing out a block. */
2746 tg_start_block (void *p, bfd_vma addr)
2748 struct pr_handle *info = (struct pr_handle *) p;
2749 char ab[20], kind, *partof;
2753 if (info->parameter > 0)
2755 info->parameter = 0;
2758 fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2759 free (info->stack->parents);
2761 print_vma (addr, ab, TRUE, TRUE);
2762 translate_addresses (info->abfd, ab, info->f, info->syms);
2763 local = info->stack->flavor != NULL;
2764 if (info->stack->method && *info->stack->method)
2767 partof = (char *) info->stack->method;
2773 if (! info->stack->method && ! append_type (info, ")"))
2776 t = pop_type (info);
2779 fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2781 fputs ("\tfile:", info->f);
2784 fprintf (info->f, "\tclass:%s", partof);
2787 fputc ('\n', info->f);
2793 /* Write out line number information. */
2796 tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED,
2797 unsigned long lineno ATTRIBUTE_UNUSED,
2798 bfd_vma addr ATTRIBUTE_UNUSED)
2803 /* Finish writing out a block. */
2806 tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2811 /* Convert the visibility value into a human readable name. */
2814 visibility_name (enum debug_visibility visibility)
2820 case DEBUG_VISIBILITY_PUBLIC:
2823 case DEBUG_VISIBILITY_PRIVATE:
2826 case DEBUG_VISIBILITY_PROTECTED:
2829 case DEBUG_VISIBILITY_IGNORE: