1 /* prdbg.c -- Print out generic debugging information.
2 Copyright 1995, 1996, 2002, 2003 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 2 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., 59 Temple Place - Suite 330, Boston, MA
23 /* This file prints out the generic debugging information, by
24 supplying a set of routines to debug_write. */
31 #include "libiberty.h"
35 /* This is the structure we use as a handle for these routines. */
39 /* File to print information to. */
41 /* Current indentation level. */
44 struct pr_stack *stack;
45 /* Parameter number we are about to output. */
47 /* The following are used only by the tags code (tg_). */
48 /* Name of the file we are using. */
52 /* The symbols table for this BFD. */
54 /* Pointer to a function to demangle symbols. */
55 char *(*demangler) (bfd *, const char *);
62 /* Next element on the stack. */
63 struct pr_stack *next;
66 /* Current visibility of fields if this is a class. */
67 enum debug_visibility visibility;
68 /* Name of the current method we are handling. */
70 /* The following are used only by the tags code (tg_). */
71 /* Type for the container (struct, union, class, union class). */
73 /* A comma separated list of parent classes. */
75 /* How many parents contains parents. */
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);
195 static const struct debug_write_fns pr_fns =
197 pr_start_compilation_unit,
216 pr_start_struct_type,
220 pr_class_static_member,
222 pr_class_start_method,
223 pr_class_method_variant,
224 pr_class_static_method_variant,
236 pr_function_parameter,
243 static const struct debug_write_fns tg_fns =
245 tg_start_compilation_unit,
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. */
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,
268 tg_class_static_member,
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. */
275 pr_typedef_type, /* Same, just push type. */
279 tg_int_constant, /* Untested. */
280 tg_float_constant, /* Untested. */
281 tg_typed_constant, /* Untested. */
284 tg_function_parameter,
287 pr_end_function, /* Same, does nothing. */
291 /* Print out the generic debugging information recorded in dhandle. */
294 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
295 void *demangler, bfd_boolean as_tags)
297 struct pr_handle info;
303 info.filename = NULL;
306 info.demangler = demangler;
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);
316 return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
317 : debug_write (dhandle, &pr_fns, (void *) & info);
320 /* Indent to the current indentation level. */
323 indent (struct pr_handle *info)
327 for (i = 0; i < info->indent; i++)
331 /* Push a type on the type stack. */
334 push_type (struct pr_handle *info, const char *type)
341 n = (struct pr_stack *) xmalloc (sizeof *n);
342 memset (n, 0, sizeof *n);
344 n->type = xstrdup (type);
345 n->visibility = DEBUG_VISIBILITY_IGNORE;
347 n->next = info->stack;
353 /* Prepend a string onto the type on the top of the type stack. */
356 prepend_type (struct pr_handle *info, const char *s)
360 assert (info->stack != NULL);
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;
370 /* Append a string to the type on the top of the type stack. */
373 append_type (struct pr_handle *info, const char *s)
380 assert (info->stack != NULL);
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);
390 /* Append a string to the parents on the top of the type stack. */
393 append_parent (struct pr_handle *info, const char *s)
400 assert (info->stack != NULL);
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);
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. */
415 substitute_type (struct pr_handle *info, const char *s)
419 assert (info->stack != NULL);
421 u = strchr (info->stack->type, '|');
426 n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
428 memcpy (n, info->stack->type, u - info->stack->type);
429 strcpy (n + (u - info->stack->type), s);
432 free (info->stack->type);
433 info->stack->type = n;
438 if (strchr (s, '|') != NULL
439 && (strchr (info->stack->type, '{') != NULL
440 || strchr (info->stack->type, '(') != NULL))
442 if (! prepend_type (info, "(")
443 || ! append_type (info, ")"))
450 return (append_type (info, " ")
451 && append_type (info, s));
454 /* Indent the type at the top of the stack by appending spaces. */
457 indent_type (struct pr_handle *info)
461 for (i = 0; i < info->indent; i++)
463 if (! append_type (info, " "))
470 /* Pop a type from the type stack. */
473 pop_type (struct pr_handle *info)
478 assert (info->stack != NULL);
481 info->stack = o->next;
488 /* Print a VMA value into a string. */
491 print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
493 if (sizeof (vma) <= sizeof (unsigned long))
496 sprintf (buf, "0x%lx", (unsigned long) vma);
498 sprintf (buf, "%lu", (unsigned long) vma);
500 sprintf (buf, "%ld", (long) vma);
506 sprintf_vma (buf + 2, vma);
510 /* Start a new compilation unit. */
513 pr_start_compilation_unit (void *p, const char *filename)
515 struct pr_handle *info = (struct pr_handle *) p;
517 assert (info->indent == 0);
519 fprintf (info->f, "%s:\n", filename);
524 /* Start a source file within a compilation unit. */
527 pr_start_source (void *p, const char *filename)
529 struct pr_handle *info = (struct pr_handle *) p;
531 assert (info->indent == 0);
533 fprintf (info->f, " %s:\n", filename);
538 /* Push an empty type onto the type stack. */
541 pr_empty_type (void *p)
543 struct pr_handle *info = (struct pr_handle *) p;
545 return push_type (info, "<undefined>");
548 /* Push a void type onto the type stack. */
551 pr_void_type (void *p)
553 struct pr_handle *info = (struct pr_handle *) p;
555 return push_type (info, "void");
558 /* Push an integer type onto the type stack. */
561 pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
563 struct pr_handle *info = (struct pr_handle *) p;
566 sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
567 return push_type (info, ab);
570 /* Push a floating type onto the type stack. */
573 pr_float_type (void *p, unsigned int size)
575 struct pr_handle *info = (struct pr_handle *) p;
579 return push_type (info, "float");
581 return push_type (info, "double");
583 sprintf (ab, "float%d", size * 8);
584 return push_type (info, ab);
587 /* Push a complex type onto the type stack. */
590 pr_complex_type (void *p, unsigned int size)
592 struct pr_handle *info = (struct pr_handle *) p;
594 if (! pr_float_type (p, size))
597 return prepend_type (info, "complex ");
600 /* Push a bfd_boolean type onto the type stack. */
603 pr_bool_type (void *p, unsigned int size)
605 struct pr_handle *info = (struct pr_handle *) p;
608 sprintf (ab, "bool%d", size * 8);
610 return push_type (info, ab);
613 /* Push an enum type onto the type stack. */
616 pr_enum_type (void *p, const char *tag, const char **names,
617 bfd_signed_vma *values)
619 struct pr_handle *info = (struct pr_handle *) p;
623 if (! push_type (info, "enum "))
627 if (! append_type (info, tag)
628 || ! append_type (info, " "))
631 if (! append_type (info, "{ "))
636 if (! append_type (info, "/* undefined */"))
642 for (i = 0; names[i] != NULL; i++)
646 if (! append_type (info, ", "))
650 if (! append_type (info, names[i]))
653 if (values[i] != val)
657 print_vma (values[i], ab, FALSE, FALSE);
658 if (! append_type (info, " = ")
659 || ! append_type (info, ab))
668 return append_type (info, " }");
671 /* Turn the top type on the stack into a pointer. */
674 pr_pointer_type (void *p)
676 struct pr_handle *info = (struct pr_handle *) p;
679 assert (info->stack != NULL);
681 s = strchr (info->stack->type, '|');
682 if (s != NULL && s[1] == '[')
683 return substitute_type (info, "(*|)");
684 return substitute_type (info, "*|");
687 /* Turn the top type on the stack into a function returning that type. */
690 pr_function_type (void *p, int argcount, bfd_boolean varargs)
692 struct pr_handle *info = (struct pr_handle *) p;
697 assert (info->stack != NULL);
710 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
711 for (i = argcount - 1; i >= 0; i--)
713 if (! substitute_type (info, ""))
715 arg_types[i] = pop_type (info);
716 if (arg_types[i] == NULL)
718 len += strlen (arg_types[i]) + 2;
724 /* Now the return type is on the top of the stack. */
726 s = (char *) xmalloc (len);
730 strcat (s, "/* unknown */");
735 for (i = 0; i < argcount; i++)
739 strcat (s, arg_types[i]);
753 if (! substitute_type (info, s))
761 /* Turn the top type on the stack into a reference to that type. */
764 pr_reference_type (void *p)
766 struct pr_handle *info = (struct pr_handle *) p;
768 assert (info->stack != NULL);
770 return substitute_type (info, "&|");
773 /* Make a range type. */
776 pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
778 struct pr_handle *info = (struct pr_handle *) p;
779 char abl[20], abu[20];
781 assert (info->stack != NULL);
783 if (! substitute_type (info, ""))
786 print_vma (lower, abl, FALSE, FALSE);
787 print_vma (upper, abu, FALSE, FALSE);
789 return (prepend_type (info, "range (")
790 && append_type (info, "):")
791 && append_type (info, abl)
792 && append_type (info, ":")
793 && append_type (info, abu));
796 /* Make an array type. */
799 pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
802 struct pr_handle *info = (struct pr_handle *) p;
804 char abl[20], abu[20], ab[50];
806 range_type = pop_type (info);
807 if (range_type == NULL)
816 print_vma (upper + 1, abu, FALSE, FALSE);
817 sprintf (ab, "|[%s]", abu);
822 print_vma (lower, abl, FALSE, FALSE);
823 print_vma (upper, abu, FALSE, FALSE);
824 sprintf (ab, "|[%s:%s]", abl, abu);
827 if (! substitute_type (info, ab))
830 if (strcmp (range_type, "int") != 0)
832 if (! append_type (info, ":")
833 || ! append_type (info, range_type))
839 if (! append_type (info, " /* string */"))
846 /* Make a set type. */
849 pr_set_type (void *p, bfd_boolean bitstringp)
851 struct pr_handle *info = (struct pr_handle *) p;
853 if (! substitute_type (info, ""))
856 if (! prepend_type (info, "set { ")
857 || ! append_type (info, " }"))
862 if (! append_type (info, "/* bitstring */"))
869 /* Make an offset type. */
872 pr_offset_type (void *p)
874 struct pr_handle *info = (struct pr_handle *) p;
877 if (! substitute_type (info, ""))
884 return (substitute_type (info, "")
885 && prepend_type (info, " ")
886 && prepend_type (info, t)
887 && append_type (info, "::|"));
890 /* Make a method type. */
893 pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
895 struct pr_handle *info = (struct pr_handle *) p;
907 if (! substitute_type (info, ""))
909 domain_type = pop_type (info);
910 if (domain_type == NULL)
912 if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
913 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
914 domain_type += sizeof "class " - 1;
915 else if (strncmp (domain_type, "union class ",
916 sizeof "union class ") == 0
917 && (strchr (domain_type + sizeof "union class " - 1, ' ')
919 domain_type += sizeof "union class " - 1;
920 len += strlen (domain_type);
932 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
933 for (i = argcount - 1; i >= 0; i--)
935 if (! substitute_type (info, ""))
937 arg_types[i] = pop_type (info);
938 if (arg_types[i] == NULL)
940 len += strlen (arg_types[i]) + 2;
946 /* Now the return type is on the top of the stack. */
948 s = (char *) xmalloc (len);
952 strcpy (s, domain_type);
956 strcat (s, "/* unknown */");
961 for (i = 0; i < argcount; i++)
965 strcat (s, arg_types[i]);
979 if (! substitute_type (info, s))
987 /* Make a const qualified type. */
990 pr_const_type (void *p)
992 struct pr_handle *info = (struct pr_handle *) p;
994 return substitute_type (info, "const |");
997 /* Make a volatile qualified type. */
1000 pr_volatile_type (void *p)
1002 struct pr_handle *info = (struct pr_handle *) p;
1004 return substitute_type (info, "volatile |");
1007 /* Start accumulating a struct type. */
1010 pr_start_struct_type (void *p, const char *tag, unsigned int id,
1011 bfd_boolean structp, unsigned int size)
1013 struct pr_handle *info = (struct pr_handle *) p;
1017 if (! push_type (info, structp ? "struct " : "union "))
1021 if (! append_type (info, tag))
1028 sprintf (idbuf, "%%anon%u", id);
1029 if (! append_type (info, idbuf))
1033 if (! append_type (info, " {"))
1035 if (size != 0 || tag != NULL)
1039 if (! append_type (info, " /*"))
1044 sprintf (ab, " size %u", size);
1045 if (! append_type (info, ab))
1050 sprintf (ab, " id %u", id);
1051 if (! append_type (info, ab))
1054 if (! append_type (info, " */"))
1057 if (! append_type (info, "\n"))
1060 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
1062 return indent_type (info);
1065 /* Output the visibility of a field in a struct. */
1068 pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1070 const char *s = NULL;
1074 assert (info->stack != NULL);
1076 if (info->stack->visibility == visibility)
1081 case DEBUG_VISIBILITY_PUBLIC:
1084 case DEBUG_VISIBILITY_PRIVATE:
1087 case DEBUG_VISIBILITY_PROTECTED:
1090 case DEBUG_VISIBILITY_IGNORE:
1098 /* Trim off a trailing space in the struct string, to make the
1099 output look a bit better, then stick on the visibility string. */
1101 t = info->stack->type;
1103 assert (t[len - 1] == ' ');
1106 if (! append_type (info, s)
1107 || ! append_type (info, ":\n")
1108 || ! indent_type (info))
1111 info->stack->visibility = visibility;
1116 /* Add a field to a struct type. */
1119 pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
1120 enum debug_visibility visibility)
1122 struct pr_handle *info = (struct pr_handle *) p;
1126 if (! substitute_type (info, name))
1129 if (! append_type (info, "; /* "))
1134 print_vma (bitsize, ab, TRUE, FALSE);
1135 if (! append_type (info, "bitsize ")
1136 || ! append_type (info, ab)
1137 || ! append_type (info, ", "))
1141 print_vma (bitpos, ab, TRUE, FALSE);
1142 if (! append_type (info, "bitpos ")
1143 || ! append_type (info, ab)
1144 || ! append_type (info, " */\n")
1145 || ! indent_type (info))
1148 t = pop_type (info);
1152 if (! pr_fix_visibility (info, visibility))
1155 return append_type (info, t);
1158 /* Finish a struct type. */
1161 pr_end_struct_type (void *p)
1163 struct pr_handle *info = (struct pr_handle *) p;
1166 assert (info->stack != NULL);
1167 assert (info->indent >= 2);
1171 /* Change the trailing indentation to have a close brace. */
1172 s = info->stack->type + strlen (info->stack->type) - 2;
1173 assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1181 /* Start a class type. */
1184 pr_start_class_type (void *p, const char *tag, unsigned int id,
1185 bfd_boolean structp, unsigned int size,
1186 bfd_boolean vptr, bfd_boolean ownvptr)
1188 struct pr_handle *info = (struct pr_handle *) p;
1193 if (vptr && ! ownvptr)
1195 tv = pop_type (info);
1200 if (! push_type (info, structp ? "class " : "union class "))
1204 if (! append_type (info, tag))
1211 sprintf (idbuf, "%%anon%u", id);
1212 if (! append_type (info, idbuf))
1216 if (! append_type (info, " {"))
1218 if (size != 0 || vptr || ownvptr || tag != NULL)
1220 if (! append_type (info, " /*"))
1227 sprintf (ab, "%u", size);
1228 if (! append_type (info, " size ")
1229 || ! append_type (info, ab))
1235 if (! append_type (info, " vtable "))
1239 if (! append_type (info, "self "))
1244 if (! append_type (info, tv)
1245 || ! append_type (info, " "))
1254 sprintf (ab, " id %u", id);
1255 if (! append_type (info, ab))
1259 if (! append_type (info, " */"))
1263 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1265 return (append_type (info, "\n")
1266 && indent_type (info));
1269 /* Add a static member to a class. */
1272 pr_class_static_member (void *p, const char *name, const char *physname,
1273 enum debug_visibility visibility)
1275 struct pr_handle *info = (struct pr_handle *) p;
1278 if (! substitute_type (info, name))
1281 if (! prepend_type (info, "static ")
1282 || ! append_type (info, "; /* ")
1283 || ! append_type (info, physname)
1284 || ! append_type (info, " */\n")
1285 || ! indent_type (info))
1288 t = pop_type (info);
1292 if (! pr_fix_visibility (info, visibility))
1295 return append_type (info, t);
1298 /* Add a base class to a class. */
1301 pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
1302 enum debug_visibility visibility)
1304 struct pr_handle *info = (struct pr_handle *) p;
1310 assert (info->stack != NULL && info->stack->next != NULL);
1312 if (! substitute_type (info, ""))
1315 t = pop_type (info);
1319 if (strncmp (t, "class ", sizeof "class " - 1) == 0)
1320 t += sizeof "class " - 1;
1322 /* Push it back on to take advantage of the prepend_type and
1323 append_type routines. */
1324 if (! push_type (info, t))
1329 if (! prepend_type (info, "virtual "))
1335 case DEBUG_VISIBILITY_PUBLIC:
1338 case DEBUG_VISIBILITY_PROTECTED:
1339 prefix = "protected ";
1341 case DEBUG_VISIBILITY_PRIVATE:
1342 prefix = "private ";
1345 prefix = "/* unknown visibility */ ";
1349 if (! prepend_type (info, prefix))
1354 print_vma (bitpos, ab, TRUE, FALSE);
1355 if (! append_type (info, " /* bitpos ")
1356 || ! append_type (info, ab)
1357 || ! append_type (info, " */"))
1361 /* Now the top of the stack is something like "public A / * bitpos
1362 10 * /". The next element on the stack is something like "class
1363 xx { / * size 8 * /\n...". We want to substitute the top of the
1364 stack in before the {. */
1365 s = strchr (info->stack->next->type, '{');
1369 /* If there is already a ':', then we already have a baseclass, and
1370 we must append this one after a comma. */
1371 for (l = info->stack->next->type; l != s; l++)
1374 if (! prepend_type (info, l == s ? " : " : ", "))
1377 t = pop_type (info);
1381 n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1382 memcpy (n, info->stack->type, s - info->stack->type);
1383 strcpy (n + (s - info->stack->type), t);
1386 free (info->stack->type);
1387 info->stack->type = n;
1394 /* Start adding a method to a class. */
1397 pr_class_start_method (void *p, const char *name)
1399 struct pr_handle *info = (struct pr_handle *) p;
1401 assert (info->stack != NULL);
1402 info->stack->method = name;
1406 /* Add a variant to a method. */
1409 pr_class_method_variant (void *p, const char *physname,
1410 enum debug_visibility visibility,
1411 bfd_boolean constp, bfd_boolean volatilep,
1412 bfd_vma voffset, bfd_boolean context)
1414 struct pr_handle *info = (struct pr_handle *) p;
1418 assert (info->stack != NULL);
1419 assert (info->stack->next != NULL);
1421 /* Put the const and volatile qualifiers on the type. */
1424 if (! append_type (info, " volatile"))
1429 if (! append_type (info, " const"))
1433 /* Stick the name of the method into its type. */
1434 if (! substitute_type (info,
1436 ? info->stack->next->next->method
1437 : info->stack->next->method)))
1441 method_type = pop_type (info);
1442 if (method_type == NULL)
1445 /* Pull off the context type if there is one. */
1447 context_type = NULL;
1450 context_type = pop_type (info);
1451 if (context_type == NULL)
1455 /* Now the top of the stack is the class. */
1457 if (! pr_fix_visibility (info, visibility))
1460 if (! append_type (info, method_type)
1461 || ! append_type (info, " /* ")
1462 || ! append_type (info, physname)
1463 || ! append_type (info, " "))
1465 if (context || voffset != 0)
1471 if (! append_type (info, "context ")
1472 || ! append_type (info, context_type)
1473 || ! append_type (info, " "))
1476 print_vma (voffset, ab, TRUE, FALSE);
1477 if (! append_type (info, "voffset ")
1478 || ! append_type (info, ab))
1482 return (append_type (info, " */;\n")
1483 && indent_type (info));
1486 /* Add a static variant to a method. */
1489 pr_class_static_method_variant (void *p, const char *physname,
1490 enum debug_visibility visibility,
1491 bfd_boolean constp, bfd_boolean volatilep)
1493 struct pr_handle *info = (struct pr_handle *) p;
1496 assert (info->stack != NULL);
1497 assert (info->stack->next != NULL);
1498 assert (info->stack->next->method != NULL);
1500 /* Put the const and volatile qualifiers on the type. */
1503 if (! append_type (info, " volatile"))
1508 if (! append_type (info, " const"))
1512 /* Mark it as static. */
1513 if (! prepend_type (info, "static "))
1516 /* Stick the name of the method into its type. */
1517 if (! substitute_type (info, info->stack->next->method))
1521 method_type = pop_type (info);
1522 if (method_type == NULL)
1525 /* Now the top of the stack is the class. */
1527 if (! pr_fix_visibility (info, visibility))
1530 return (append_type (info, method_type)
1531 && append_type (info, " /* ")
1532 && append_type (info, physname)
1533 && append_type (info, " */;\n")
1534 && indent_type (info));
1537 /* Finish up a method. */
1540 pr_class_end_method (void *p)
1542 struct pr_handle *info = (struct pr_handle *) p;
1544 info->stack->method = NULL;
1548 /* Finish up a class. */
1551 pr_end_class_type (void *p)
1553 return pr_end_struct_type (p);
1556 /* Push a type on the stack using a typedef name. */
1559 pr_typedef_type (void *p, const char *name)
1561 struct pr_handle *info = (struct pr_handle *) p;
1563 return push_type (info, name);
1566 /* Push a type on the stack using a tag name. */
1569 pr_tag_type (void *p, const char *name, unsigned int id,
1570 enum debug_type_kind kind)
1572 struct pr_handle *info = (struct pr_handle *) p;
1573 const char *t, *tag;
1578 case DEBUG_KIND_STRUCT:
1581 case DEBUG_KIND_UNION:
1584 case DEBUG_KIND_ENUM:
1587 case DEBUG_KIND_CLASS:
1590 case DEBUG_KIND_UNION_CLASS:
1598 if (! push_type (info, t))
1604 sprintf (idbuf, "%%anon%u", id);
1608 if (! append_type (info, tag))
1610 if (name != NULL && kind != DEBUG_KIND_ENUM)
1612 sprintf (idbuf, " /* id %u */", id);
1613 if (! append_type (info, idbuf))
1620 /* Output a typedef. */
1623 pr_typdef (void *p, const char *name)
1625 struct pr_handle *info = (struct pr_handle *) p;
1628 if (! substitute_type (info, name))
1631 s = pop_type (info);
1636 fprintf (info->f, "typedef %s;\n", s);
1643 /* Output a tag. The tag should already be in the string on the
1644 stack, so all we have to do here is print it out. */
1647 pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
1649 struct pr_handle *info = (struct pr_handle *) p;
1652 t = pop_type (info);
1657 fprintf (info->f, "%s;\n", t);
1664 /* Output an integer constant. */
1667 pr_int_constant (void *p, const char *name, bfd_vma val)
1669 struct pr_handle *info = (struct pr_handle *) p;
1673 print_vma (val, ab, FALSE, FALSE);
1674 fprintf (info->f, "const int %s = %s;\n", name, ab);
1678 /* Output a floating point constant. */
1681 pr_float_constant (void *p, const char *name, double val)
1683 struct pr_handle *info = (struct pr_handle *) p;
1686 fprintf (info->f, "const double %s = %g;\n", name, val);
1690 /* Output a typed constant. */
1693 pr_typed_constant (void *p, const char *name, bfd_vma val)
1695 struct pr_handle *info = (struct pr_handle *) p;
1699 t = pop_type (info);
1704 print_vma (val, ab, FALSE, FALSE);
1705 fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1712 /* Output a variable. */
1715 pr_variable (void *p, const char *name, enum debug_var_kind kind,
1718 struct pr_handle *info = (struct pr_handle *) p;
1722 if (! substitute_type (info, name))
1725 t = pop_type (info);
1733 case DEBUG_LOCAL_STATIC:
1734 fprintf (info->f, "static ");
1736 case DEBUG_REGISTER:
1737 fprintf (info->f, "register ");
1742 print_vma (val, ab, TRUE, TRUE);
1743 fprintf (info->f, "%s /* %s */;\n", t, ab);
1750 /* Start outputting a function. */
1753 pr_start_function (void *p, const char *name, bfd_boolean global)
1755 struct pr_handle *info = (struct pr_handle *) p;
1758 if (! substitute_type (info, name))
1761 t = pop_type (info);
1767 fprintf (info->f, "static ");
1768 fprintf (info->f, "%s (", t);
1770 info->parameter = 1;
1775 /* Output a function parameter. */
1778 pr_function_parameter (void *p, const char *name,
1779 enum debug_parm_kind kind, bfd_vma val)
1781 struct pr_handle *info = (struct pr_handle *) p;
1785 if (kind == DEBUG_PARM_REFERENCE
1786 || kind == DEBUG_PARM_REF_REG)
1788 if (! pr_reference_type (p))
1792 if (! substitute_type (info, name))
1795 t = pop_type (info);
1799 if (info->parameter != 1)
1800 fprintf (info->f, ", ");
1802 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1803 fprintf (info->f, "register ");
1805 print_vma (val, ab, TRUE, TRUE);
1806 fprintf (info->f, "%s /* %s */", t, ab);
1815 /* Start writing out a block. */
1818 pr_start_block (void *p, bfd_vma addr)
1820 struct pr_handle *info = (struct pr_handle *) p;
1823 if (info->parameter > 0)
1825 fprintf (info->f, ")\n");
1826 info->parameter = 0;
1830 print_vma (addr, ab, TRUE, TRUE);
1831 fprintf (info->f, "{ /* %s */\n", ab);
1838 /* Write out line number information. */
1841 pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1843 struct pr_handle *info = (struct pr_handle *) p;
1847 print_vma (addr, ab, TRUE, TRUE);
1848 fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1853 /* Finish writing out a block. */
1856 pr_end_block (void *p, bfd_vma addr)
1858 struct pr_handle *info = (struct pr_handle *) p;
1864 print_vma (addr, ab, TRUE, TRUE);
1865 fprintf (info->f, "} /* %s */\n", ab);
1870 /* Finish writing out a function. */
1873 pr_end_function (void *p ATTRIBUTE_UNUSED)
1878 /* Tags style generation functions start here. */
1880 /* Variables for address to line translation. */
1882 static const char *filename;
1883 static const char *functionname;
1884 static unsigned int line;
1885 static bfd_boolean found;
1887 /* Look for an address in a section. This is called via
1888 bfd_map_over_sections. */
1891 find_address_in_section (bfd *abfd, asection *section, void *data)
1895 asymbol **syms = (asymbol **) data;
1900 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
1903 vma = bfd_get_section_vma (abfd, section);
1907 size = bfd_get_section_size_before_reloc (section);
1908 if (pc >= vma + size)
1911 found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
1912 &filename, &functionname, &line);
1916 translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1918 pc = bfd_scan_vma (addr_hex, NULL, 16);
1920 bfd_map_over_sections (abfd, find_address_in_section, syms);
1925 fprintf (f, "%u", line);
1928 /* Start a new compilation unit. */
1931 tg_start_compilation_unit (void * p, const char *filename ATTRIBUTE_UNUSED)
1933 struct pr_handle *info = (struct pr_handle *) p;
1935 fprintf (stderr, "New compilation unit: %s\n", filename);
1937 free (info->filename);
1938 /* Should it be relative? best way to do it here?. */
1939 info->filename = strdup (filename);
1944 /* Start a source file within a compilation unit. */
1947 tg_start_source (void *p, const char *filename)
1949 struct pr_handle *info = (struct pr_handle *) p;
1951 free (info->filename);
1952 /* Should it be relative? best way to do it here?. */
1953 info->filename = strdup (filename);
1958 /* Push an enum type onto the type stack. */
1961 tg_enum_type (void *p, const char *tag, const char **names,
1962 bfd_signed_vma *values)
1964 struct pr_handle *info = (struct pr_handle *) p;
1969 if (! pr_enum_type (p, tag, names, values))
1972 name = tag ? tag : "unknown";
1973 /* Generate an entry for the enum. */
1975 fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
1976 info->filename, info->stack->type);
1978 /* Generate entries for the values. */
1981 for (i = 0; names[i] != NULL; i++)
1983 print_vma (values[i], ab, FALSE, FALSE);
1984 fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
1985 names[i], info->filename, name, ab);
1992 /* Start accumulating a struct type. */
1995 tg_start_struct_type (void *p, const char *tag, unsigned int id,
1996 bfd_boolean structp,
1997 unsigned int size ATTRIBUTE_UNUSED)
1999 struct pr_handle *info = (struct pr_handle *) p;
2008 sprintf (idbuf, "%%anon%u", id);
2011 if (! push_type (info, name))
2014 info->stack->flavor = structp ? "struct" : "union";
2016 fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
2017 info->stack->flavor[0]);
2019 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
2021 return indent_type (info);
2024 /* Output the visibility of a field in a struct. */
2027 tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2029 assert (info->stack != NULL);
2031 if (info->stack->visibility == visibility)
2034 assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
2036 info->stack->visibility = visibility;
2041 /* Add a field to a struct type. */
2044 tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
2045 bfd_vma bitsize ATTRIBUTE_UNUSED,
2046 enum debug_visibility visibility)
2048 struct pr_handle *info = (struct pr_handle *) p;
2051 t = pop_type (info);
2055 if (! tg_fix_visibility (info, visibility))
2058 /* It happens, a bug? */
2062 fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
2063 name, info->filename, t, info->stack->flavor, info->stack->type,
2064 visibility_name (visibility));
2069 /* Finish a struct type. */
2072 tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
2074 struct pr_handle *info = (struct pr_handle *) p;
2075 assert (info->stack != NULL);
2080 /* Start a class type. */
2083 tg_start_class_type (void *p, const char *tag, unsigned int id,
2084 bfd_boolean structp, unsigned int size,
2085 bfd_boolean vptr, bfd_boolean ownvptr)
2087 struct pr_handle *info = (struct pr_handle *) p;
2093 if (vptr && ! ownvptr)
2095 tv = pop_type (info);
2106 sprintf (idbuf, "%%anon%u", id);
2110 if (! push_type (info, name))
2113 info->stack->flavor = structp ? "class" : "union class";
2114 info->stack->parents = NULL;
2115 info->stack->num_parents = 0;
2117 if (size != 0 || vptr || ownvptr || tag != NULL)
2121 if (! append_type (info, " vtable "))
2125 if (! append_type (info, "self "))
2130 if (! append_type (info, tv)
2131 || ! append_type (info, " "))
2137 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2142 /* Add a static member to a class. */
2145 tg_class_static_member (void *p, const char *name,
2146 const char *physname ATTRIBUTE_UNUSED,
2147 enum debug_visibility visibility)
2149 struct pr_handle *info = (struct pr_handle *) p;
2151 int len_var, len_class;
2154 len_var = strlen (name);
2155 len_class = strlen (info->stack->next->type);
2156 full_name = (char *) xmalloc (len_var + len_class + 3);
2159 memcpy (full_name, info->stack->next->type, len_class);
2160 memcpy (full_name + len_class, "::", 2);
2161 memcpy (full_name + len_class + 2, name, len_var + 1);
2163 if (! substitute_type (info, full_name))
2166 if (! prepend_type (info, "static "))
2169 t = pop_type (info);
2173 if (! tg_fix_visibility (info, visibility))
2176 fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2177 name, info->filename, t, info->stack->type,
2178 visibility_name (visibility));
2185 /* Add a base class to a class. */
2188 tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2189 bfd_boolean virtual, enum debug_visibility visibility)
2191 struct pr_handle *info = (struct pr_handle *) p;
2195 assert (info->stack != NULL && info->stack->next != NULL);
2197 t = pop_type (info);
2201 if (strncmp (t, "class ", sizeof "class " - 1) == 0)
2202 t += sizeof "class " - 1;
2204 /* Push it back on to take advantage of the prepend_type and
2205 append_type routines. */
2206 if (! push_type (info, t))
2211 if (! prepend_type (info, "virtual "))
2217 case DEBUG_VISIBILITY_PUBLIC:
2220 case DEBUG_VISIBILITY_PROTECTED:
2221 prefix = "protected ";
2223 case DEBUG_VISIBILITY_PRIVATE:
2224 prefix = "private ";
2227 prefix = "/* unknown visibility */ ";
2231 if (! prepend_type (info, prefix))
2234 t = pop_type (info);
2238 if (info->stack->num_parents && ! append_parent (info, ", "))
2241 if (! append_parent (info, t))
2243 info->stack->num_parents++;
2250 /* Add a variant to a method. */
2253 tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2254 enum debug_visibility visibility,
2255 bfd_boolean constp, bfd_boolean volatilep,
2256 bfd_vma voffset ATTRIBUTE_UNUSED,
2257 bfd_boolean context)
2259 struct pr_handle *info = (struct pr_handle *) p;
2264 assert (info->stack != NULL);
2265 assert (info->stack->next != NULL);
2267 /* Put the const and volatile qualifiers on the type. */
2270 if (! append_type (info, " volatile"))
2275 if (! append_type (info, " const"))
2279 method_name = strdup (context ? info->stack->next->next->method
2280 : info->stack->next->method);
2282 /* Stick the name of the method into its type. */
2283 if (! substitute_type (info, method_name))
2287 method_type = pop_type (info);
2288 if (method_type == NULL)
2291 /* Pull off the context type if there is one. */
2293 context_type = NULL;
2296 context_type = pop_type (info);
2297 if (context_type == NULL)
2301 /* Now the top of the stack is the class. */
2302 if (! tg_fix_visibility (info, visibility))
2305 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2306 method_name, info->filename, method_type, info->stack->type);
2309 free (context_type);
2314 /* Add a static variant to a method. */
2317 tg_class_static_method_variant (void *p,
2318 const char *physname ATTRIBUTE_UNUSED,
2319 enum debug_visibility visibility,
2320 bfd_boolean constp, bfd_boolean volatilep)
2322 struct pr_handle *info = (struct pr_handle *) p;
2326 assert (info->stack != NULL);
2327 assert (info->stack->next != NULL);
2328 assert (info->stack->next->method != NULL);
2330 /* Put the const and volatile qualifiers on the type. */
2333 if (! append_type (info, " volatile"))
2338 if (! append_type (info, " const"))
2342 /* Mark it as static. */
2343 if (! prepend_type (info, "static "))
2346 method_name = strdup (info->stack->next->method);
2347 /* Stick the name of the method into its type. */
2348 if (! substitute_type (info, info->stack->next->method))
2352 method_type = pop_type (info);
2353 if (method_type == NULL)
2356 /* Now the top of the stack is the class. */
2357 if (! tg_fix_visibility (info, visibility))
2360 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2361 method_name, info->filename, method_type, info->stack->type,
2362 visibility_name (visibility));
2369 /* Finish up a class. */
2372 tg_end_class_type (void *p)
2374 struct pr_handle *info = (struct pr_handle *) p;
2376 fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2377 info->filename, info->stack->flavor);
2378 if (info->stack->num_parents)
2380 fprintf (info->f, "\tinherits:%s", info->stack->parents);
2381 free (info->stack->parents);
2383 fputc ('\n', info->f);
2385 return tg_end_struct_type (p);
2388 /* Push a type on the stack using a tag name. */
2391 tg_tag_type (void *p, const char *name, unsigned int id,
2392 enum debug_type_kind kind)
2394 struct pr_handle *info = (struct pr_handle *) p;
2395 const char *t, *tag;
2400 case DEBUG_KIND_STRUCT:
2403 case DEBUG_KIND_UNION:
2406 case DEBUG_KIND_ENUM:
2409 case DEBUG_KIND_CLASS:
2412 case DEBUG_KIND_UNION_CLASS:
2420 if (! push_type (info, t))
2426 sprintf (idbuf, "%%anon%u", id);
2430 if (! append_type (info, tag))
2436 /* Output a typedef. */
2439 tg_typdef (void *p, const char *name)
2441 struct pr_handle *info = (struct pr_handle *) p;
2444 s = pop_type (info);
2448 fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2456 /* Output a tag. The tag should already be in the string on the
2457 stack, so all we have to do here is print it out. */
2460 tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2462 struct pr_handle *info = (struct pr_handle *) p;
2465 t = pop_type (info);
2473 /* Output an integer constant. */
2476 tg_int_constant (void *p, const char *name, bfd_vma val)
2478 struct pr_handle *info = (struct pr_handle *) p;
2482 print_vma (val, ab, FALSE, FALSE);
2483 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2484 name, info->filename, ab);
2488 /* Output a floating point constant. */
2491 tg_float_constant (void *p, const char *name, double val)
2493 struct pr_handle *info = (struct pr_handle *) p;
2496 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2497 name, info->filename, val);
2501 /* Output a typed constant. */
2504 tg_typed_constant (void *p, const char *name, bfd_vma val)
2506 struct pr_handle *info = (struct pr_handle *) p;
2510 t = pop_type (info);
2515 print_vma (val, ab, FALSE, FALSE);
2516 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2517 name, info->filename, t, ab);
2524 /* Output a variable. */
2527 tg_variable (void *p, const char *name, enum debug_var_kind kind,
2528 bfd_vma val ATTRIBUTE_UNUSED)
2530 struct pr_handle *info = (struct pr_handle *) p;
2532 const char *dname, *from_class;
2534 t = pop_type (info);
2539 if (info->demangler)
2541 dname = info->demangler (info->abfd, name);
2542 if (strcmp (name, dname) == 0)
2544 free ((char *) dname);
2552 sep = strstr (dname, "::");
2561 /* Obscure types as vts and type_info nodes. */
2569 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2574 case DEBUG_LOCAL_STATIC:
2575 fprintf (info->f, "\tfile:");
2577 case DEBUG_REGISTER:
2578 fprintf (info->f, "\tregister:");
2586 fprintf (info->f, "\tclass:%s",from_class);
2587 free ((char *) dname);
2590 fprintf (info->f, "\n");
2597 /* Start outputting a function. */
2600 tg_start_function (void *p, const char *name, bfd_boolean global)
2602 struct pr_handle *info = (struct pr_handle *) p;
2606 info->stack->flavor = "static";
2608 info->stack->flavor = NULL;
2611 if (info->demangler)
2613 dname = info->demangler (info->abfd, name);
2614 if (strcmp (name, dname) == 0)
2616 free ((char *) dname);
2621 if (! substitute_type (info, dname))
2627 sep = strstr (dname, "::");
2630 info->stack->method = dname;
2636 info->stack->method = "";
2639 sep = strchr (name, '(');
2642 /* Obscure functions as type_info function. */
2645 info->stack->method = NULL;
2647 info->stack->parents = strdup (name);
2649 if (! info->stack->method && ! append_type (info, "("))
2652 info->parameter = 1;
2657 /* Output a function parameter. */
2660 tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2661 bfd_vma val ATTRIBUTE_UNUSED)
2663 struct pr_handle *info = (struct pr_handle *) p;
2666 if (kind == DEBUG_PARM_REFERENCE
2667 || kind == DEBUG_PARM_REF_REG)
2669 if (! pr_reference_type (p))
2673 if (! substitute_type (info, name))
2676 t = pop_type (info);
2680 if (! info->stack->method)
2682 if (info->parameter != 1 && ! append_type (info, ", "))
2685 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2686 if (! append_type (info, "register "))
2689 if (! append_type (info, t))
2700 /* Start writing out a block. */
2703 tg_start_block (void *p, bfd_vma addr)
2705 struct pr_handle *info = (struct pr_handle *) p;
2706 char ab[20], kind, *partof;
2710 if (info->parameter > 0)
2712 info->parameter = 0;
2715 fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2716 free (info->stack->parents);
2718 print_vma (addr, ab, TRUE, TRUE);
2719 translate_addresses (info->abfd, ab, info->f, info->syms);
2720 local = info->stack->flavor != NULL;
2721 if (info->stack->method && *info->stack->method)
2724 partof = (char *) info->stack->method;
2730 if (! info->stack->method && ! append_type (info, ")"))
2733 t = pop_type (info);
2736 fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2738 fputs ("\tfile:", info->f);
2741 fprintf (info->f, "\tclass:%s", partof);
2744 fputc ('\n', info->f);
2750 /* Write out line number information. */
2753 tg_lineno (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED,
2754 unsigned long lineno ATTRIBUTE_UNUSED,
2755 bfd_vma addr ATTRIBUTE_UNUSED)
2760 /* Finish writing out a block. */
2763 tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2768 /* Convert the visibility value into a human readable name. */
2771 visibility_name (enum debug_visibility visibility)
2777 case DEBUG_VISIBILITY_PUBLIC:
2780 case DEBUG_VISIBILITY_PRIVATE:
2783 case DEBUG_VISIBILITY_PROTECTED:
2786 case DEBUG_VISIBILITY_IGNORE: