daily update
[binutils.git] / binutils / prdbg.c
blob39b9e3fb8cc5bc52b3d32dd98aa83587932a3b70
1 /* prdbg.c -- Print out generic debugging information.
2 Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
5 Tags style generation written by Salvador E. Tropea <set@computer.org>.
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
24 /* This file prints out the generic debugging information, by
25 supplying a set of routines to debug_write. */
27 #include "sysdep.h"
28 #include <assert.h>
29 #include "bfd.h"
30 #include "libiberty.h"
31 #include "demangle.h"
32 #include "debug.h"
33 #include "budbg.h"
35 /* This is the structure we use as a handle for these routines. */
37 struct pr_handle
39 /* File to print information to. */
40 FILE *f;
41 /* Current indentation level. */
42 unsigned int indent;
43 /* Type stack. */
44 struct pr_stack *stack;
45 /* Parameter number we are about to output. */
46 int parameter;
47 /* The following are used only by the tags code (tg_). */
48 /* Name of the file we are using. */
49 char *filename;
50 /* The BFD. */
51 bfd *abfd;
52 /* The symbols table for this BFD. */
53 asymbol **syms;
54 /* Pointer to a function to demangle symbols. */
55 char *(*demangler) (bfd *, const char *, int);
58 /* The type stack. */
60 struct pr_stack
62 /* Next element on the stack. */
63 struct pr_stack *next;
64 /* This element. */
65 char *type;
66 /* Current visibility of fields if this is a class. */
67 enum debug_visibility visibility;
68 /* Name of the current method we are handling. */
69 const char *method;
70 /* The following are used only by the tags code (tg_). */
71 /* Type for the container (struct, union, class, union class). */
72 const char *flavor;
73 /* A comma separated list of parent classes. */
74 char *parents;
75 /* How many parents contains parents. */
76 int num_parents;
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,
198 pr_start_source,
199 pr_empty_type,
200 pr_void_type,
201 pr_int_type,
202 pr_float_type,
203 pr_complex_type,
204 pr_bool_type,
205 pr_enum_type,
206 pr_pointer_type,
207 pr_function_type,
208 pr_reference_type,
209 pr_range_type,
210 pr_array_type,
211 pr_set_type,
212 pr_offset_type,
213 pr_method_type,
214 pr_const_type,
215 pr_volatile_type,
216 pr_start_struct_type,
217 pr_struct_field,
218 pr_end_struct_type,
219 pr_start_class_type,
220 pr_class_static_member,
221 pr_class_baseclass,
222 pr_class_start_method,
223 pr_class_method_variant,
224 pr_class_static_method_variant,
225 pr_class_end_method,
226 pr_end_class_type,
227 pr_typedef_type,
228 pr_tag_type,
229 pr_typdef,
230 pr_tag,
231 pr_int_constant,
232 pr_float_constant,
233 pr_typed_constant,
234 pr_variable,
235 pr_start_function,
236 pr_function_parameter,
237 pr_start_block,
238 pr_end_block,
239 pr_end_function,
240 pr_lineno
243 static const struct debug_write_fns tg_fns =
245 tg_start_compilation_unit,
246 tg_start_source,
247 pr_empty_type, /* Same, push_type. */
248 pr_void_type, /* Same, push_type. */
249 pr_int_type, /* Same, push_type. */
250 pr_float_type, /* Same, push_type. */
251 pr_complex_type, /* Same, push_type. */
252 pr_bool_type, /* Same, push_type. */
253 tg_enum_type,
254 pr_pointer_type, /* Same, changes to pointer. */
255 pr_function_type, /* Same, push_type. */
256 pr_reference_type, /* Same, changes to reference. */
257 pr_range_type, /* FIXME: What's that?. */
258 pr_array_type, /* Same, push_type. */
259 pr_set_type, /* FIXME: What's that?. */
260 pr_offset_type, /* FIXME: What's that?. */
261 pr_method_type, /* Same. */
262 pr_const_type, /* Same, changes to const. */
263 pr_volatile_type, /* Same, changes to volatile. */
264 tg_start_struct_type,
265 tg_struct_field,
266 tg_end_struct_type,
267 tg_start_class_type,
268 tg_class_static_member,
269 tg_class_baseclass,
270 pr_class_start_method, /* Same, remembers that's a method. */
271 tg_class_method_variant,
272 tg_class_static_method_variant,
273 pr_class_end_method, /* Same, forgets that's a method. */
274 tg_end_class_type,
275 pr_typedef_type, /* Same, just push type. */
276 tg_tag_type,
277 tg_typdef,
278 tg_tag,
279 tg_int_constant, /* Untested. */
280 tg_float_constant, /* Untested. */
281 tg_typed_constant, /* Untested. */
282 tg_variable,
283 tg_start_function,
284 tg_function_parameter,
285 tg_start_block,
286 tg_end_block,
287 pr_end_function, /* Same, does nothing. */
288 tg_lineno
291 /* Print out the generic debugging information recorded in dhandle. */
293 bfd_boolean
294 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
295 void *demangler, bfd_boolean as_tags)
297 struct pr_handle info;
299 info.f = f;
300 info.indent = 0;
301 info.stack = NULL;
302 info.parameter = 0;
303 info.filename = NULL;
304 info.abfd = abfd;
305 info.syms = syms;
306 info.demangler = demangler;
308 if (as_tags)
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. */
322 static void
323 indent (struct pr_handle *info)
325 unsigned int i;
327 for (i = 0; i < info->indent; i++)
328 putc (' ', info->f);
331 /* Push a type on the type stack. */
333 static bfd_boolean
334 push_type (struct pr_handle *info, const char *type)
336 struct pr_stack *n;
338 if (type == NULL)
339 return FALSE;
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;
346 n->method = NULL;
347 n->next = info->stack;
348 info->stack = n;
350 return TRUE;
353 /* Prepend a string onto the type on the top of the type stack. */
355 static bfd_boolean
356 prepend_type (struct pr_handle *info, const char *s)
358 char *n;
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;
367 return TRUE;
370 /* Append a string to the type on the top of the type stack. */
372 static bfd_boolean
373 append_type (struct pr_handle *info, const char *s)
375 unsigned int len;
377 if (s == NULL)
378 return FALSE;
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);
387 return TRUE;
390 /* Append a string to the parents on the top of the type stack. */
392 static bfd_boolean
393 append_parent (struct pr_handle *info, const char *s)
395 unsigned int len;
397 if (s == NULL)
398 return FALSE;
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);
407 return TRUE;
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. */
414 static bfd_boolean
415 substitute_type (struct pr_handle *info, const char *s)
417 char *u;
419 assert (info->stack != NULL);
421 u = strchr (info->stack->type, '|');
422 if (u != NULL)
424 char *n;
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);
430 strcat (n, u + 1);
432 free (info->stack->type);
433 info->stack->type = n;
435 return TRUE;
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, ")"))
444 return FALSE;
447 if (*s == '\0')
448 return TRUE;
450 return (append_type (info, " ")
451 && append_type (info, s));
454 /* Indent the type at the top of the stack by appending spaces. */
456 static bfd_boolean
457 indent_type (struct pr_handle *info)
459 unsigned int i;
461 for (i = 0; i < info->indent; i++)
463 if (! append_type (info, " "))
464 return FALSE;
467 return TRUE;
470 /* Pop a type from the type stack. */
472 static char *
473 pop_type (struct pr_handle *info)
475 struct pr_stack *o;
476 char *ret;
478 assert (info->stack != NULL);
480 o = info->stack;
481 info->stack = o->next;
482 ret = o->type;
483 free (o);
485 return ret;
488 /* Print a VMA value into a string. */
490 static void
491 print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
493 if (sizeof (vma) <= sizeof (unsigned long))
495 if (hexp)
496 sprintf (buf, "0x%lx", (unsigned long) vma);
497 else if (unsignedp)
498 sprintf (buf, "%lu", (unsigned long) vma);
499 else
500 sprintf (buf, "%ld", (long) vma);
502 #if BFD_HOST_64BIT_LONG_LONG
503 else if (sizeof (vma) <= sizeof (unsigned long long))
505 #ifndef __MSVCRT__
506 if (hexp)
507 sprintf (buf, "0x%llx", (unsigned long long) vma);
508 else if (unsignedp)
509 sprintf (buf, "%llu", (unsigned long long) vma);
510 else
511 sprintf (buf, "%lld", (long long) vma);
512 #else
513 if (hexp)
514 sprintf (buf, "0x%I64x", (unsigned long long) vma);
515 else if (unsignedp)
516 sprintf (buf, "%I64u", (unsigned long long) vma);
517 else
518 sprintf (buf, "%I64d", (long long) vma);
519 #endif
521 #endif
522 else
524 buf[0] = '0';
525 buf[1] = 'x';
526 sprintf_vma (buf + 2, vma);
530 /* Start a new compilation unit. */
532 static bfd_boolean
533 pr_start_compilation_unit (void *p, const char *filename)
535 struct pr_handle *info = (struct pr_handle *) p;
537 assert (info->indent == 0);
539 fprintf (info->f, "%s:\n", filename);
541 return TRUE;
544 /* Start a source file within a compilation unit. */
546 static bfd_boolean
547 pr_start_source (void *p, const char *filename)
549 struct pr_handle *info = (struct pr_handle *) p;
551 assert (info->indent == 0);
553 fprintf (info->f, " %s:\n", filename);
555 return TRUE;
558 /* Push an empty type onto the type stack. */
560 static bfd_boolean
561 pr_empty_type (void *p)
563 struct pr_handle *info = (struct pr_handle *) p;
565 return push_type (info, "<undefined>");
568 /* Push a void type onto the type stack. */
570 static bfd_boolean
571 pr_void_type (void *p)
573 struct pr_handle *info = (struct pr_handle *) p;
575 return push_type (info, "void");
578 /* Push an integer type onto the type stack. */
580 static bfd_boolean
581 pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
583 struct pr_handle *info = (struct pr_handle *) p;
584 char ab[10];
586 sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
587 return push_type (info, ab);
590 /* Push a floating type onto the type stack. */
592 static bfd_boolean
593 pr_float_type (void *p, unsigned int size)
595 struct pr_handle *info = (struct pr_handle *) p;
596 char ab[10];
598 if (size == 4)
599 return push_type (info, "float");
600 else if (size == 8)
601 return push_type (info, "double");
603 sprintf (ab, "float%d", size * 8);
604 return push_type (info, ab);
607 /* Push a complex type onto the type stack. */
609 static bfd_boolean
610 pr_complex_type (void *p, unsigned int size)
612 struct pr_handle *info = (struct pr_handle *) p;
614 if (! pr_float_type (p, size))
615 return FALSE;
617 return prepend_type (info, "complex ");
620 /* Push a bfd_boolean type onto the type stack. */
622 static bfd_boolean
623 pr_bool_type (void *p, unsigned int size)
625 struct pr_handle *info = (struct pr_handle *) p;
626 char ab[10];
628 sprintf (ab, "bool%d", size * 8);
630 return push_type (info, ab);
633 /* Push an enum type onto the type stack. */
635 static bfd_boolean
636 pr_enum_type (void *p, const char *tag, const char **names,
637 bfd_signed_vma *values)
639 struct pr_handle *info = (struct pr_handle *) p;
640 unsigned int i;
641 bfd_signed_vma val;
643 if (! push_type (info, "enum "))
644 return FALSE;
645 if (tag != NULL)
647 if (! append_type (info, tag)
648 || ! append_type (info, " "))
649 return FALSE;
651 if (! append_type (info, "{ "))
652 return FALSE;
654 if (names == NULL)
656 if (! append_type (info, "/* undefined */"))
657 return FALSE;
659 else
661 val = 0;
662 for (i = 0; names[i] != NULL; i++)
664 if (i > 0)
666 if (! append_type (info, ", "))
667 return FALSE;
670 if (! append_type (info, names[i]))
671 return FALSE;
673 if (values[i] != val)
675 char ab[20];
677 print_vma (values[i], ab, FALSE, FALSE);
678 if (! append_type (info, " = ")
679 || ! append_type (info, ab))
680 return FALSE;
681 val = values[i];
684 ++val;
688 return append_type (info, " }");
691 /* Turn the top type on the stack into a pointer. */
693 static bfd_boolean
694 pr_pointer_type (void *p)
696 struct pr_handle *info = (struct pr_handle *) p;
697 char *s;
699 assert (info->stack != NULL);
701 s = strchr (info->stack->type, '|');
702 if (s != NULL && s[1] == '[')
703 return substitute_type (info, "(*|)");
704 return substitute_type (info, "*|");
707 /* Turn the top type on the stack into a function returning that type. */
709 static bfd_boolean
710 pr_function_type (void *p, int argcount, bfd_boolean varargs)
712 struct pr_handle *info = (struct pr_handle *) p;
713 char **arg_types;
714 unsigned int len;
715 char *s;
717 assert (info->stack != NULL);
719 len = 10;
721 if (argcount <= 0)
723 arg_types = NULL;
724 len += 15;
726 else
728 int i;
730 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
731 for (i = argcount - 1; i >= 0; i--)
733 if (! substitute_type (info, ""))
734 return FALSE;
735 arg_types[i] = pop_type (info);
736 if (arg_types[i] == NULL)
737 return FALSE;
738 len += strlen (arg_types[i]) + 2;
740 if (varargs)
741 len += 5;
744 /* Now the return type is on the top of the stack. */
746 s = xmalloc (len);
747 LITSTRCPY (s, "(|) (");
749 if (argcount < 0)
750 strcat (s, "/* unknown */");
751 else
753 int i;
755 for (i = 0; i < argcount; i++)
757 if (i > 0)
758 strcat (s, ", ");
759 strcat (s, arg_types[i]);
761 if (varargs)
763 if (i > 0)
764 strcat (s, ", ");
765 strcat (s, "...");
767 if (argcount > 0)
768 free (arg_types);
771 strcat (s, ")");
773 if (! substitute_type (info, s))
774 return FALSE;
776 free (s);
778 return TRUE;
781 /* Turn the top type on the stack into a reference to that type. */
783 static bfd_boolean
784 pr_reference_type (void *p)
786 struct pr_handle *info = (struct pr_handle *) p;
788 assert (info->stack != NULL);
790 return substitute_type (info, "&|");
793 /* Make a range type. */
795 static bfd_boolean
796 pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
798 struct pr_handle *info = (struct pr_handle *) p;
799 char abl[20], abu[20];
801 assert (info->stack != NULL);
803 if (! substitute_type (info, ""))
804 return FALSE;
806 print_vma (lower, abl, FALSE, FALSE);
807 print_vma (upper, abu, FALSE, FALSE);
809 return (prepend_type (info, "range (")
810 && append_type (info, "):")
811 && append_type (info, abl)
812 && append_type (info, ":")
813 && append_type (info, abu));
816 /* Make an array type. */
818 static bfd_boolean
819 pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
820 bfd_boolean stringp)
822 struct pr_handle *info = (struct pr_handle *) p;
823 char *range_type;
824 char abl[20], abu[20], ab[50];
826 range_type = pop_type (info);
827 if (range_type == NULL)
828 return FALSE;
830 if (lower == 0)
832 if (upper == -1)
833 sprintf (ab, "|[]");
834 else
836 print_vma (upper + 1, abu, FALSE, FALSE);
837 sprintf (ab, "|[%s]", abu);
840 else
842 print_vma (lower, abl, FALSE, FALSE);
843 print_vma (upper, abu, FALSE, FALSE);
844 sprintf (ab, "|[%s:%s]", abl, abu);
847 if (! substitute_type (info, ab))
848 return FALSE;
850 if (strcmp (range_type, "int") != 0)
852 if (! append_type (info, ":")
853 || ! append_type (info, range_type))
854 return FALSE;
857 if (stringp)
859 if (! append_type (info, " /* string */"))
860 return FALSE;
863 return TRUE;
866 /* Make a set type. */
868 static bfd_boolean
869 pr_set_type (void *p, bfd_boolean bitstringp)
871 struct pr_handle *info = (struct pr_handle *) p;
873 if (! substitute_type (info, ""))
874 return FALSE;
876 if (! prepend_type (info, "set { ")
877 || ! append_type (info, " }"))
878 return FALSE;
880 if (bitstringp)
882 if (! append_type (info, "/* bitstring */"))
883 return FALSE;
886 return TRUE;
889 /* Make an offset type. */
891 static bfd_boolean
892 pr_offset_type (void *p)
894 struct pr_handle *info = (struct pr_handle *) p;
895 char *t;
897 if (! substitute_type (info, ""))
898 return FALSE;
900 t = pop_type (info);
901 if (t == NULL)
902 return FALSE;
904 return (substitute_type (info, "")
905 && prepend_type (info, " ")
906 && prepend_type (info, t)
907 && append_type (info, "::|"));
910 /* Make a method type. */
912 static bfd_boolean
913 pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
915 struct pr_handle *info = (struct pr_handle *) p;
916 unsigned int len;
917 char *domain_type;
918 char **arg_types;
919 char *s;
921 len = 10;
923 if (! domain)
924 domain_type = NULL;
925 else
927 if (! substitute_type (info, ""))
928 return FALSE;
929 domain_type = pop_type (info);
930 if (domain_type == NULL)
931 return FALSE;
932 if (CONST_STRNEQ (domain_type, "class ")
933 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
934 domain_type += sizeof "class " - 1;
935 else if (CONST_STRNEQ (domain_type, "union class ")
936 && (strchr (domain_type + sizeof "union class " - 1, ' ')
937 == NULL))
938 domain_type += sizeof "union class " - 1;
939 len += strlen (domain_type);
942 if (argcount <= 0)
944 arg_types = NULL;
945 len += 15;
947 else
949 int i;
951 arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
952 for (i = argcount - 1; i >= 0; i--)
954 if (! substitute_type (info, ""))
955 return FALSE;
956 arg_types[i] = pop_type (info);
957 if (arg_types[i] == NULL)
958 return FALSE;
959 len += strlen (arg_types[i]) + 2;
961 if (varargs)
962 len += 5;
965 /* Now the return type is on the top of the stack. */
967 s = (char *) xmalloc (len);
968 if (! domain)
969 *s = '\0';
970 else
971 strcpy (s, domain_type);
972 strcat (s, "::| (");
974 if (argcount < 0)
975 strcat (s, "/* unknown */");
976 else
978 int i;
980 for (i = 0; i < argcount; i++)
982 if (i > 0)
983 strcat (s, ", ");
984 strcat (s, arg_types[i]);
986 if (varargs)
988 if (i > 0)
989 strcat (s, ", ");
990 strcat (s, "...");
992 if (argcount > 0)
993 free (arg_types);
996 strcat (s, ")");
998 if (! substitute_type (info, s))
999 return FALSE;
1001 free (s);
1003 return TRUE;
1006 /* Make a const qualified type. */
1008 static bfd_boolean
1009 pr_const_type (void *p)
1011 struct pr_handle *info = (struct pr_handle *) p;
1013 return substitute_type (info, "const |");
1016 /* Make a volatile qualified type. */
1018 static bfd_boolean
1019 pr_volatile_type (void *p)
1021 struct pr_handle *info = (struct pr_handle *) p;
1023 return substitute_type (info, "volatile |");
1026 /* Start accumulating a struct type. */
1028 static bfd_boolean
1029 pr_start_struct_type (void *p, const char *tag, unsigned int id,
1030 bfd_boolean structp, unsigned int size)
1032 struct pr_handle *info = (struct pr_handle *) p;
1034 info->indent += 2;
1036 if (! push_type (info, structp ? "struct " : "union "))
1037 return FALSE;
1038 if (tag != NULL)
1040 if (! append_type (info, tag))
1041 return FALSE;
1043 else
1045 char idbuf[20];
1047 sprintf (idbuf, "%%anon%u", id);
1048 if (! append_type (info, idbuf))
1049 return FALSE;
1052 if (! append_type (info, " {"))
1053 return FALSE;
1054 if (size != 0 || tag != NULL)
1056 char ab[30];
1058 if (! append_type (info, " /*"))
1059 return FALSE;
1061 if (size != 0)
1063 sprintf (ab, " size %u", size);
1064 if (! append_type (info, ab))
1065 return FALSE;
1067 if (tag != NULL)
1069 sprintf (ab, " id %u", id);
1070 if (! append_type (info, ab))
1071 return FALSE;
1073 if (! append_type (info, " */"))
1074 return FALSE;
1076 if (! append_type (info, "\n"))
1077 return FALSE;
1079 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
1081 return indent_type (info);
1084 /* Output the visibility of a field in a struct. */
1086 static bfd_boolean
1087 pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1089 const char *s = NULL;
1090 char *t;
1091 unsigned int len;
1093 assert (info->stack != NULL);
1095 if (info->stack->visibility == visibility)
1096 return TRUE;
1098 switch (visibility)
1100 case DEBUG_VISIBILITY_PUBLIC:
1101 s = "public";
1102 break;
1103 case DEBUG_VISIBILITY_PRIVATE:
1104 s = "private";
1105 break;
1106 case DEBUG_VISIBILITY_PROTECTED:
1107 s = "protected";
1108 break;
1109 case DEBUG_VISIBILITY_IGNORE:
1110 s = "/* ignore */";
1111 break;
1112 default:
1113 abort ();
1114 return FALSE;
1117 /* Trim off a trailing space in the struct string, to make the
1118 output look a bit better, then stick on the visibility string. */
1120 t = info->stack->type;
1121 len = strlen (t);
1122 assert (t[len - 1] == ' ');
1123 t[len - 1] = '\0';
1125 if (! append_type (info, s)
1126 || ! append_type (info, ":\n")
1127 || ! indent_type (info))
1128 return FALSE;
1130 info->stack->visibility = visibility;
1132 return TRUE;
1135 /* Add a field to a struct type. */
1137 static bfd_boolean
1138 pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
1139 enum debug_visibility visibility)
1141 struct pr_handle *info = (struct pr_handle *) p;
1142 char ab[20];
1143 char *t;
1145 if (! substitute_type (info, name))
1146 return FALSE;
1148 if (! append_type (info, "; /* "))
1149 return FALSE;
1151 if (bitsize != 0)
1153 print_vma (bitsize, ab, TRUE, FALSE);
1154 if (! append_type (info, "bitsize ")
1155 || ! append_type (info, ab)
1156 || ! append_type (info, ", "))
1157 return FALSE;
1160 print_vma (bitpos, ab, TRUE, FALSE);
1161 if (! append_type (info, "bitpos ")
1162 || ! append_type (info, ab)
1163 || ! append_type (info, " */\n")
1164 || ! indent_type (info))
1165 return FALSE;
1167 t = pop_type (info);
1168 if (t == NULL)
1169 return FALSE;
1171 if (! pr_fix_visibility (info, visibility))
1172 return FALSE;
1174 return append_type (info, t);
1177 /* Finish a struct type. */
1179 static bfd_boolean
1180 pr_end_struct_type (void *p)
1182 struct pr_handle *info = (struct pr_handle *) p;
1183 char *s;
1185 assert (info->stack != NULL);
1186 assert (info->indent >= 2);
1188 info->indent -= 2;
1190 /* Change the trailing indentation to have a close brace. */
1191 s = info->stack->type + strlen (info->stack->type) - 2;
1192 assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1194 *s++ = '}';
1195 *s = '\0';
1197 return TRUE;
1200 /* Start a class type. */
1202 static bfd_boolean
1203 pr_start_class_type (void *p, const char *tag, unsigned int id,
1204 bfd_boolean structp, unsigned int size,
1205 bfd_boolean vptr, bfd_boolean ownvptr)
1207 struct pr_handle *info = (struct pr_handle *) p;
1208 char *tv = NULL;
1210 info->indent += 2;
1212 if (vptr && ! ownvptr)
1214 tv = pop_type (info);
1215 if (tv == NULL)
1216 return FALSE;
1219 if (! push_type (info, structp ? "class " : "union class "))
1220 return FALSE;
1221 if (tag != NULL)
1223 if (! append_type (info, tag))
1224 return FALSE;
1226 else
1228 char idbuf[20];
1230 sprintf (idbuf, "%%anon%u", id);
1231 if (! append_type (info, idbuf))
1232 return FALSE;
1235 if (! append_type (info, " {"))
1236 return FALSE;
1237 if (size != 0 || vptr || ownvptr || tag != NULL)
1239 if (! append_type (info, " /*"))
1240 return FALSE;
1242 if (size != 0)
1244 char ab[20];
1246 sprintf (ab, "%u", size);
1247 if (! append_type (info, " size ")
1248 || ! append_type (info, ab))
1249 return FALSE;
1252 if (vptr)
1254 if (! append_type (info, " vtable "))
1255 return FALSE;
1256 if (ownvptr)
1258 if (! append_type (info, "self "))
1259 return FALSE;
1261 else
1263 if (! append_type (info, tv)
1264 || ! append_type (info, " "))
1265 return FALSE;
1269 if (tag != NULL)
1271 char ab[30];
1273 sprintf (ab, " id %u", id);
1274 if (! append_type (info, ab))
1275 return FALSE;
1278 if (! append_type (info, " */"))
1279 return FALSE;
1282 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1284 return (append_type (info, "\n")
1285 && indent_type (info));
1288 /* Add a static member to a class. */
1290 static bfd_boolean
1291 pr_class_static_member (void *p, const char *name, const char *physname,
1292 enum debug_visibility visibility)
1294 struct pr_handle *info = (struct pr_handle *) p;
1295 char *t;
1297 if (! substitute_type (info, name))
1298 return FALSE;
1300 if (! prepend_type (info, "static ")
1301 || ! append_type (info, "; /* ")
1302 || ! append_type (info, physname)
1303 || ! append_type (info, " */\n")
1304 || ! indent_type (info))
1305 return FALSE;
1307 t = pop_type (info);
1308 if (t == NULL)
1309 return FALSE;
1311 if (! pr_fix_visibility (info, visibility))
1312 return FALSE;
1314 return append_type (info, t);
1317 /* Add a base class to a class. */
1319 static bfd_boolean
1320 pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
1321 enum debug_visibility visibility)
1323 struct pr_handle *info = (struct pr_handle *) p;
1324 char *t;
1325 const char *prefix;
1326 char ab[20];
1327 char *s, *l, *n;
1329 assert (info->stack != NULL && info->stack->next != NULL);
1331 if (! substitute_type (info, ""))
1332 return FALSE;
1334 t = pop_type (info);
1335 if (t == NULL)
1336 return FALSE;
1338 if (CONST_STRNEQ (t, "class "))
1339 t += sizeof "class " - 1;
1341 /* Push it back on to take advantage of the prepend_type and
1342 append_type routines. */
1343 if (! push_type (info, t))
1344 return FALSE;
1346 if (virtual)
1348 if (! prepend_type (info, "virtual "))
1349 return FALSE;
1352 switch (visibility)
1354 case DEBUG_VISIBILITY_PUBLIC:
1355 prefix = "public ";
1356 break;
1357 case DEBUG_VISIBILITY_PROTECTED:
1358 prefix = "protected ";
1359 break;
1360 case DEBUG_VISIBILITY_PRIVATE:
1361 prefix = "private ";
1362 break;
1363 default:
1364 prefix = "/* unknown visibility */ ";
1365 break;
1368 if (! prepend_type (info, prefix))
1369 return FALSE;
1371 if (bitpos != 0)
1373 print_vma (bitpos, ab, TRUE, FALSE);
1374 if (! append_type (info, " /* bitpos ")
1375 || ! append_type (info, ab)
1376 || ! append_type (info, " */"))
1377 return FALSE;
1380 /* Now the top of the stack is something like "public A / * bitpos
1381 10 * /". The next element on the stack is something like "class
1382 xx { / * size 8 * /\n...". We want to substitute the top of the
1383 stack in before the {. */
1384 s = strchr (info->stack->next->type, '{');
1385 assert (s != NULL);
1386 --s;
1388 /* If there is already a ':', then we already have a baseclass, and
1389 we must append this one after a comma. */
1390 for (l = info->stack->next->type; l != s; l++)
1391 if (*l == ':')
1392 break;
1393 if (! prepend_type (info, l == s ? " : " : ", "))
1394 return FALSE;
1396 t = pop_type (info);
1397 if (t == NULL)
1398 return FALSE;
1400 n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1401 memcpy (n, info->stack->type, s - info->stack->type);
1402 strcpy (n + (s - info->stack->type), t);
1403 strcat (n, s);
1405 free (info->stack->type);
1406 info->stack->type = n;
1408 free (t);
1410 return TRUE;
1413 /* Start adding a method to a class. */
1415 static bfd_boolean
1416 pr_class_start_method (void *p, const char *name)
1418 struct pr_handle *info = (struct pr_handle *) p;
1420 assert (info->stack != NULL);
1421 info->stack->method = name;
1422 return TRUE;
1425 /* Add a variant to a method. */
1427 static bfd_boolean
1428 pr_class_method_variant (void *p, const char *physname,
1429 enum debug_visibility visibility,
1430 bfd_boolean constp, bfd_boolean volatilep,
1431 bfd_vma voffset, bfd_boolean context)
1433 struct pr_handle *info = (struct pr_handle *) p;
1434 char *method_type;
1435 char *context_type;
1437 assert (info->stack != NULL);
1438 assert (info->stack->next != NULL);
1440 /* Put the const and volatile qualifiers on the type. */
1441 if (volatilep)
1443 if (! append_type (info, " volatile"))
1444 return FALSE;
1446 if (constp)
1448 if (! append_type (info, " const"))
1449 return FALSE;
1452 /* Stick the name of the method into its type. */
1453 if (! substitute_type (info,
1454 (context
1455 ? info->stack->next->next->method
1456 : info->stack->next->method)))
1457 return FALSE;
1459 /* Get the type. */
1460 method_type = pop_type (info);
1461 if (method_type == NULL)
1462 return FALSE;
1464 /* Pull off the context type if there is one. */
1465 if (! context)
1466 context_type = NULL;
1467 else
1469 context_type = pop_type (info);
1470 if (context_type == NULL)
1471 return FALSE;
1474 /* Now the top of the stack is the class. */
1476 if (! pr_fix_visibility (info, visibility))
1477 return FALSE;
1479 if (! append_type (info, method_type)
1480 || ! append_type (info, " /* ")
1481 || ! append_type (info, physname)
1482 || ! append_type (info, " "))
1483 return FALSE;
1484 if (context || voffset != 0)
1486 char ab[20];
1488 if (context)
1490 if (! append_type (info, "context ")
1491 || ! append_type (info, context_type)
1492 || ! append_type (info, " "))
1493 return FALSE;
1495 print_vma (voffset, ab, TRUE, FALSE);
1496 if (! append_type (info, "voffset ")
1497 || ! append_type (info, ab))
1498 return FALSE;
1501 return (append_type (info, " */;\n")
1502 && indent_type (info));
1505 /* Add a static variant to a method. */
1507 static bfd_boolean
1508 pr_class_static_method_variant (void *p, const char *physname,
1509 enum debug_visibility visibility,
1510 bfd_boolean constp, bfd_boolean volatilep)
1512 struct pr_handle *info = (struct pr_handle *) p;
1513 char *method_type;
1515 assert (info->stack != NULL);
1516 assert (info->stack->next != NULL);
1517 assert (info->stack->next->method != NULL);
1519 /* Put the const and volatile qualifiers on the type. */
1520 if (volatilep)
1522 if (! append_type (info, " volatile"))
1523 return FALSE;
1525 if (constp)
1527 if (! append_type (info, " const"))
1528 return FALSE;
1531 /* Mark it as static. */
1532 if (! prepend_type (info, "static "))
1533 return FALSE;
1535 /* Stick the name of the method into its type. */
1536 if (! substitute_type (info, info->stack->next->method))
1537 return FALSE;
1539 /* Get the type. */
1540 method_type = pop_type (info);
1541 if (method_type == NULL)
1542 return FALSE;
1544 /* Now the top of the stack is the class. */
1546 if (! pr_fix_visibility (info, visibility))
1547 return FALSE;
1549 return (append_type (info, method_type)
1550 && append_type (info, " /* ")
1551 && append_type (info, physname)
1552 && append_type (info, " */;\n")
1553 && indent_type (info));
1556 /* Finish up a method. */
1558 static bfd_boolean
1559 pr_class_end_method (void *p)
1561 struct pr_handle *info = (struct pr_handle *) p;
1563 info->stack->method = NULL;
1564 return TRUE;
1567 /* Finish up a class. */
1569 static bfd_boolean
1570 pr_end_class_type (void *p)
1572 return pr_end_struct_type (p);
1575 /* Push a type on the stack using a typedef name. */
1577 static bfd_boolean
1578 pr_typedef_type (void *p, const char *name)
1580 struct pr_handle *info = (struct pr_handle *) p;
1582 return push_type (info, name);
1585 /* Push a type on the stack using a tag name. */
1587 static bfd_boolean
1588 pr_tag_type (void *p, const char *name, unsigned int id,
1589 enum debug_type_kind kind)
1591 struct pr_handle *info = (struct pr_handle *) p;
1592 const char *t, *tag;
1593 char idbuf[20];
1595 switch (kind)
1597 case DEBUG_KIND_STRUCT:
1598 t = "struct ";
1599 break;
1600 case DEBUG_KIND_UNION:
1601 t = "union ";
1602 break;
1603 case DEBUG_KIND_ENUM:
1604 t = "enum ";
1605 break;
1606 case DEBUG_KIND_CLASS:
1607 t = "class ";
1608 break;
1609 case DEBUG_KIND_UNION_CLASS:
1610 t = "union class ";
1611 break;
1612 default:
1613 abort ();
1614 return FALSE;
1617 if (! push_type (info, t))
1618 return FALSE;
1619 if (name != NULL)
1620 tag = name;
1621 else
1623 sprintf (idbuf, "%%anon%u", id);
1624 tag = idbuf;
1627 if (! append_type (info, tag))
1628 return FALSE;
1629 if (name != NULL && kind != DEBUG_KIND_ENUM)
1631 sprintf (idbuf, " /* id %u */", id);
1632 if (! append_type (info, idbuf))
1633 return FALSE;
1636 return TRUE;
1639 /* Output a typedef. */
1641 static bfd_boolean
1642 pr_typdef (void *p, const char *name)
1644 struct pr_handle *info = (struct pr_handle *) p;
1645 char *s;
1647 if (! substitute_type (info, name))
1648 return FALSE;
1650 s = pop_type (info);
1651 if (s == NULL)
1652 return FALSE;
1654 indent (info);
1655 fprintf (info->f, "typedef %s;\n", s);
1657 free (s);
1659 return TRUE;
1662 /* Output a tag. The tag should already be in the string on the
1663 stack, so all we have to do here is print it out. */
1665 static bfd_boolean
1666 pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
1668 struct pr_handle *info = (struct pr_handle *) p;
1669 char *t;
1671 t = pop_type (info);
1672 if (t == NULL)
1673 return FALSE;
1675 indent (info);
1676 fprintf (info->f, "%s;\n", t);
1678 free (t);
1680 return TRUE;
1683 /* Output an integer constant. */
1685 static bfd_boolean
1686 pr_int_constant (void *p, const char *name, bfd_vma val)
1688 struct pr_handle *info = (struct pr_handle *) p;
1689 char ab[20];
1691 indent (info);
1692 print_vma (val, ab, FALSE, FALSE);
1693 fprintf (info->f, "const int %s = %s;\n", name, ab);
1694 return TRUE;
1697 /* Output a floating point constant. */
1699 static bfd_boolean
1700 pr_float_constant (void *p, const char *name, double val)
1702 struct pr_handle *info = (struct pr_handle *) p;
1704 indent (info);
1705 fprintf (info->f, "const double %s = %g;\n", name, val);
1706 return TRUE;
1709 /* Output a typed constant. */
1711 static bfd_boolean
1712 pr_typed_constant (void *p, const char *name, bfd_vma val)
1714 struct pr_handle *info = (struct pr_handle *) p;
1715 char *t;
1716 char ab[20];
1718 t = pop_type (info);
1719 if (t == NULL)
1720 return FALSE;
1722 indent (info);
1723 print_vma (val, ab, FALSE, FALSE);
1724 fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1726 free (t);
1728 return TRUE;
1731 /* Output a variable. */
1733 static bfd_boolean
1734 pr_variable (void *p, const char *name, enum debug_var_kind kind,
1735 bfd_vma val)
1737 struct pr_handle *info = (struct pr_handle *) p;
1738 char *t;
1739 char ab[20];
1741 if (! substitute_type (info, name))
1742 return FALSE;
1744 t = pop_type (info);
1745 if (t == NULL)
1746 return FALSE;
1748 indent (info);
1749 switch (kind)
1751 case DEBUG_STATIC:
1752 case DEBUG_LOCAL_STATIC:
1753 fprintf (info->f, "static ");
1754 break;
1755 case DEBUG_REGISTER:
1756 fprintf (info->f, "register ");
1757 break;
1758 default:
1759 break;
1761 print_vma (val, ab, TRUE, TRUE);
1762 fprintf (info->f, "%s /* %s */;\n", t, ab);
1764 free (t);
1766 return TRUE;
1769 /* Start outputting a function. */
1771 static bfd_boolean
1772 pr_start_function (void *p, const char *name, bfd_boolean global)
1774 struct pr_handle *info = (struct pr_handle *) p;
1775 char *t;
1777 if (! substitute_type (info, name))
1778 return FALSE;
1780 t = pop_type (info);
1781 if (t == NULL)
1782 return FALSE;
1784 indent (info);
1785 if (! global)
1786 fprintf (info->f, "static ");
1787 fprintf (info->f, "%s (", t);
1789 info->parameter = 1;
1791 return TRUE;
1794 /* Output a function parameter. */
1796 static bfd_boolean
1797 pr_function_parameter (void *p, const char *name,
1798 enum debug_parm_kind kind, bfd_vma val)
1800 struct pr_handle *info = (struct pr_handle *) p;
1801 char *t;
1802 char ab[20];
1804 if (kind == DEBUG_PARM_REFERENCE
1805 || kind == DEBUG_PARM_REF_REG)
1807 if (! pr_reference_type (p))
1808 return FALSE;
1811 if (! substitute_type (info, name))
1812 return FALSE;
1814 t = pop_type (info);
1815 if (t == NULL)
1816 return FALSE;
1818 if (info->parameter != 1)
1819 fprintf (info->f, ", ");
1821 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1822 fprintf (info->f, "register ");
1824 print_vma (val, ab, TRUE, TRUE);
1825 fprintf (info->f, "%s /* %s */", t, ab);
1827 free (t);
1829 ++info->parameter;
1831 return TRUE;
1834 /* Start writing out a block. */
1836 static bfd_boolean
1837 pr_start_block (void *p, bfd_vma addr)
1839 struct pr_handle *info = (struct pr_handle *) p;
1840 char ab[20];
1842 if (info->parameter > 0)
1844 fprintf (info->f, ")\n");
1845 info->parameter = 0;
1848 indent (info);
1849 print_vma (addr, ab, TRUE, TRUE);
1850 fprintf (info->f, "{ /* %s */\n", ab);
1852 info->indent += 2;
1854 return TRUE;
1857 /* Write out line number information. */
1859 static bfd_boolean
1860 pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1862 struct pr_handle *info = (struct pr_handle *) p;
1863 char ab[20];
1865 indent (info);
1866 print_vma (addr, ab, TRUE, TRUE);
1867 fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1869 return TRUE;
1872 /* Finish writing out a block. */
1874 static bfd_boolean
1875 pr_end_block (void *p, bfd_vma addr)
1877 struct pr_handle *info = (struct pr_handle *) p;
1878 char ab[20];
1880 info->indent -= 2;
1882 indent (info);
1883 print_vma (addr, ab, TRUE, TRUE);
1884 fprintf (info->f, "} /* %s */\n", ab);
1886 return TRUE;
1889 /* Finish writing out a function. */
1891 static bfd_boolean
1892 pr_end_function (void *p ATTRIBUTE_UNUSED)
1894 return TRUE;
1897 /* Tags style generation functions start here. */
1899 /* Variables for address to line translation. */
1900 static bfd_vma pc;
1901 static const char *filename;
1902 static const char *functionname;
1903 static unsigned int line;
1904 static bfd_boolean found;
1906 /* Look for an address in a section. This is called via
1907 bfd_map_over_sections. */
1909 static void
1910 find_address_in_section (bfd *abfd, asection *section, void *data)
1912 bfd_vma vma;
1913 bfd_size_type size;
1914 asymbol **syms = (asymbol **) data;
1916 if (found)
1917 return;
1919 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
1920 return;
1922 vma = bfd_get_section_vma (abfd, section);
1923 if (pc < vma)
1924 return;
1926 size = bfd_get_section_size (section);
1927 if (pc >= vma + size)
1928 return;
1930 found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
1931 &filename, &functionname, &line);
1934 static void
1935 translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1937 pc = bfd_scan_vma (addr_hex, NULL, 16);
1938 found = FALSE;
1939 bfd_map_over_sections (abfd, find_address_in_section, syms);
1941 if (! found)
1942 fprintf (f, "??");
1943 else
1944 fprintf (f, "%u", line);
1947 /* Start a new compilation unit. */
1949 static bfd_boolean
1950 tg_start_compilation_unit (void * p, const char *filename ATTRIBUTE_UNUSED)
1952 struct pr_handle *info = (struct pr_handle *) p;
1954 free (info->filename);
1955 /* Should it be relative? best way to do it here?. */
1956 info->filename = strdup (filename);
1958 return TRUE;
1961 /* Start a source file within a compilation unit. */
1963 static bfd_boolean
1964 tg_start_source (void *p, const char *filename)
1966 struct pr_handle *info = (struct pr_handle *) p;
1968 free (info->filename);
1969 /* Should it be relative? best way to do it here?. */
1970 info->filename = strdup (filename);
1972 return TRUE;
1975 /* Push an enum type onto the type stack. */
1977 static bfd_boolean
1978 tg_enum_type (void *p, const char *tag, const char **names,
1979 bfd_signed_vma *values)
1981 struct pr_handle *info = (struct pr_handle *) p;
1982 unsigned int i;
1983 const char *name;
1984 char ab[20];
1986 if (! pr_enum_type (p, tag, names, values))
1987 return FALSE;
1989 name = tag ? tag : "unknown";
1990 /* Generate an entry for the enum. */
1991 if (tag)
1992 fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
1993 info->filename, info->stack->type);
1995 /* Generate entries for the values. */
1996 if (names != NULL)
1998 for (i = 0; names[i] != NULL; i++)
2000 print_vma (values[i], ab, FALSE, FALSE);
2001 fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
2002 names[i], info->filename, name, ab);
2006 return TRUE;
2009 /* Start accumulating a struct type. */
2011 static bfd_boolean
2012 tg_start_struct_type (void *p, const char *tag, unsigned int id,
2013 bfd_boolean structp,
2014 unsigned int size ATTRIBUTE_UNUSED)
2016 struct pr_handle *info = (struct pr_handle *) p;
2017 const char *name;
2018 char idbuf[20];
2020 if (tag != NULL)
2021 name = tag;
2022 else
2024 name = idbuf;
2025 sprintf (idbuf, "%%anon%u", id);
2028 if (! push_type (info, name))
2029 return FALSE;
2031 info->stack->flavor = structp ? "struct" : "union";
2033 fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
2034 info->stack->flavor[0]);
2036 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
2038 return indent_type (info);
2041 /* Output the visibility of a field in a struct. */
2043 static bfd_boolean
2044 tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2046 assert (info->stack != NULL);
2048 if (info->stack->visibility == visibility)
2049 return TRUE;
2051 assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
2053 info->stack->visibility = visibility;
2055 return TRUE;
2058 /* Add a field to a struct type. */
2060 static bfd_boolean
2061 tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
2062 bfd_vma bitsize ATTRIBUTE_UNUSED,
2063 enum debug_visibility visibility)
2065 struct pr_handle *info = (struct pr_handle *) p;
2066 char *t;
2068 t = pop_type (info);
2069 if (t == NULL)
2070 return FALSE;
2072 if (! tg_fix_visibility (info, visibility))
2073 return FALSE;
2075 /* It happens, a bug? */
2076 if (! name[0])
2077 return TRUE;
2079 fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
2080 name, info->filename, t, info->stack->flavor, info->stack->type,
2081 visibility_name (visibility));
2083 return TRUE;
2086 /* Finish a struct type. */
2088 static bfd_boolean
2089 tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
2091 struct pr_handle *info = (struct pr_handle *) p;
2092 assert (info->stack != NULL);
2094 return TRUE;
2097 /* Start a class type. */
2099 static bfd_boolean
2100 tg_start_class_type (void *p, const char *tag, unsigned int id,
2101 bfd_boolean structp, unsigned int size,
2102 bfd_boolean vptr, bfd_boolean ownvptr)
2104 struct pr_handle *info = (struct pr_handle *) p;
2105 char *tv = NULL;
2106 const char *name;
2108 info->indent += 2;
2110 if (vptr && ! ownvptr)
2112 tv = pop_type (info);
2113 if (tv == NULL)
2114 return FALSE;
2117 if (tag != NULL)
2118 name = tag;
2119 else
2121 char idbuf[20];
2123 sprintf (idbuf, "%%anon%u", id);
2124 name = idbuf;
2127 if (! push_type (info, name))
2128 return FALSE;
2130 info->stack->flavor = structp ? "class" : "union class";
2131 info->stack->parents = NULL;
2132 info->stack->num_parents = 0;
2134 if (size != 0 || vptr || ownvptr || tag != NULL)
2136 if (vptr)
2138 if (! append_type (info, " vtable "))
2139 return FALSE;
2140 if (ownvptr)
2142 if (! append_type (info, "self "))
2143 return FALSE;
2145 else
2147 if (! append_type (info, tv)
2148 || ! append_type (info, " "))
2149 return FALSE;
2154 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2156 return TRUE;
2159 /* Add a static member to a class. */
2161 static bfd_boolean
2162 tg_class_static_member (void *p, const char *name,
2163 const char *physname ATTRIBUTE_UNUSED,
2164 enum debug_visibility visibility)
2166 struct pr_handle *info = (struct pr_handle *) p;
2167 char *t;
2168 int len_var, len_class;
2169 char *full_name;
2171 len_var = strlen (name);
2172 len_class = strlen (info->stack->next->type);
2173 full_name = xmalloc (len_var + len_class + 3);
2174 if (! full_name)
2175 return FALSE;
2176 sprintf (full_name, "%s::%s", info->stack->next->type, name);
2178 if (! substitute_type (info, full_name))
2179 return FALSE;
2181 if (! prepend_type (info, "static "))
2182 return FALSE;
2184 t = pop_type (info);
2185 if (t == NULL)
2186 return FALSE;
2188 if (! tg_fix_visibility (info, visibility))
2189 return FALSE;
2191 fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2192 name, info->filename, t, info->stack->type,
2193 visibility_name (visibility));
2194 free (t);
2195 free (full_name);
2197 return TRUE;
2200 /* Add a base class to a class. */
2202 static bfd_boolean
2203 tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2204 bfd_boolean virtual, enum debug_visibility visibility)
2206 struct pr_handle *info = (struct pr_handle *) p;
2207 char *t;
2208 const char *prefix;
2210 assert (info->stack != NULL && info->stack->next != NULL);
2212 t = pop_type (info);
2213 if (t == NULL)
2214 return FALSE;
2216 if (CONST_STRNEQ (t, "class "))
2217 t += sizeof "class " - 1;
2219 /* Push it back on to take advantage of the prepend_type and
2220 append_type routines. */
2221 if (! push_type (info, t))
2222 return FALSE;
2224 if (virtual)
2226 if (! prepend_type (info, "virtual "))
2227 return FALSE;
2230 switch (visibility)
2232 case DEBUG_VISIBILITY_PUBLIC:
2233 prefix = "public ";
2234 break;
2235 case DEBUG_VISIBILITY_PROTECTED:
2236 prefix = "protected ";
2237 break;
2238 case DEBUG_VISIBILITY_PRIVATE:
2239 prefix = "private ";
2240 break;
2241 default:
2242 prefix = "/* unknown visibility */ ";
2243 break;
2246 if (! prepend_type (info, prefix))
2247 return FALSE;
2249 t = pop_type (info);
2250 if (t == NULL)
2251 return FALSE;
2253 if (info->stack->num_parents && ! append_parent (info, ", "))
2254 return FALSE;
2256 if (! append_parent (info, t))
2257 return FALSE;
2258 info->stack->num_parents++;
2260 free (t);
2262 return TRUE;
2265 /* Add a variant to a method. */
2267 static bfd_boolean
2268 tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2269 enum debug_visibility visibility,
2270 bfd_boolean constp, bfd_boolean volatilep,
2271 bfd_vma voffset ATTRIBUTE_UNUSED,
2272 bfd_boolean context)
2274 struct pr_handle *info = (struct pr_handle *) p;
2275 char *method_type;
2276 char *context_type;
2277 char *method_name;
2279 assert (info->stack != NULL);
2280 assert (info->stack->next != NULL);
2282 /* Put the const and volatile qualifiers on the type. */
2283 if (volatilep)
2285 if (! append_type (info, " volatile"))
2286 return FALSE;
2288 if (constp)
2290 if (! append_type (info, " const"))
2291 return FALSE;
2294 method_name = strdup (context ? info->stack->next->next->method
2295 : info->stack->next->method);
2297 /* Stick the name of the method into its type. */
2298 if (! substitute_type (info, method_name))
2299 return FALSE;
2301 /* Get the type. */
2302 method_type = pop_type (info);
2303 if (method_type == NULL)
2304 return FALSE;
2306 /* Pull off the context type if there is one. */
2307 if (! context)
2308 context_type = NULL;
2309 else
2311 context_type = pop_type (info);
2312 if (context_type == NULL)
2313 return FALSE;
2316 /* Now the top of the stack is the class. */
2317 if (! tg_fix_visibility (info, visibility))
2318 return FALSE;
2320 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2321 method_name, info->filename, method_type, info->stack->type);
2322 free (method_type);
2323 free (method_name);
2324 free (context_type);
2326 return TRUE;
2329 /* Add a static variant to a method. */
2331 static bfd_boolean
2332 tg_class_static_method_variant (void *p,
2333 const char *physname ATTRIBUTE_UNUSED,
2334 enum debug_visibility visibility,
2335 bfd_boolean constp, bfd_boolean volatilep)
2337 struct pr_handle *info = (struct pr_handle *) p;
2338 char *method_type;
2339 char *method_name;
2341 assert (info->stack != NULL);
2342 assert (info->stack->next != NULL);
2343 assert (info->stack->next->method != NULL);
2345 /* Put the const and volatile qualifiers on the type. */
2346 if (volatilep)
2348 if (! append_type (info, " volatile"))
2349 return FALSE;
2351 if (constp)
2353 if (! append_type (info, " const"))
2354 return FALSE;
2357 /* Mark it as static. */
2358 if (! prepend_type (info, "static "))
2359 return FALSE;
2361 method_name = strdup (info->stack->next->method);
2362 /* Stick the name of the method into its type. */
2363 if (! substitute_type (info, info->stack->next->method))
2364 return FALSE;
2366 /* Get the type. */
2367 method_type = pop_type (info);
2368 if (method_type == NULL)
2369 return FALSE;
2371 /* Now the top of the stack is the class. */
2372 if (! tg_fix_visibility (info, visibility))
2373 return FALSE;
2375 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2376 method_name, info->filename, method_type, info->stack->type,
2377 visibility_name (visibility));
2378 free (method_type);
2379 free (method_name);
2381 return TRUE;
2384 /* Finish up a class. */
2386 static bfd_boolean
2387 tg_end_class_type (void *p)
2389 struct pr_handle *info = (struct pr_handle *) p;
2391 fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2392 info->filename, info->stack->flavor);
2393 if (info->stack->num_parents)
2395 fprintf (info->f, "\tinherits:%s", info->stack->parents);
2396 free (info->stack->parents);
2398 fputc ('\n', info->f);
2400 return tg_end_struct_type (p);
2403 /* Push a type on the stack using a tag name. */
2405 static bfd_boolean
2406 tg_tag_type (void *p, const char *name, unsigned int id,
2407 enum debug_type_kind kind)
2409 struct pr_handle *info = (struct pr_handle *) p;
2410 const char *t, *tag;
2411 char idbuf[20];
2413 switch (kind)
2415 case DEBUG_KIND_STRUCT:
2416 t = "struct ";
2417 break;
2418 case DEBUG_KIND_UNION:
2419 t = "union ";
2420 break;
2421 case DEBUG_KIND_ENUM:
2422 t = "enum ";
2423 break;
2424 case DEBUG_KIND_CLASS:
2425 t = "class ";
2426 break;
2427 case DEBUG_KIND_UNION_CLASS:
2428 t = "union class ";
2429 break;
2430 default:
2431 abort ();
2432 return FALSE;
2435 if (! push_type (info, t))
2436 return FALSE;
2437 if (name != NULL)
2438 tag = name;
2439 else
2441 sprintf (idbuf, "%%anon%u", id);
2442 tag = idbuf;
2445 if (! append_type (info, tag))
2446 return FALSE;
2448 return TRUE;
2451 /* Output a typedef. */
2453 static bfd_boolean
2454 tg_typdef (void *p, const char *name)
2456 struct pr_handle *info = (struct pr_handle *) p;
2457 char *s;
2459 s = pop_type (info);
2460 if (s == NULL)
2461 return FALSE;
2463 fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2464 info->filename, s);
2466 free (s);
2468 return TRUE;
2471 /* Output a tag. The tag should already be in the string on the
2472 stack, so all we have to do here is print it out. */
2474 static bfd_boolean
2475 tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2477 struct pr_handle *info = (struct pr_handle *) p;
2478 char *t;
2480 t = pop_type (info);
2481 if (t == NULL)
2482 return FALSE;
2483 free (t);
2485 return TRUE;
2488 /* Output an integer constant. */
2490 static bfd_boolean
2491 tg_int_constant (void *p, const char *name, bfd_vma val)
2493 struct pr_handle *info = (struct pr_handle *) p;
2494 char ab[20];
2496 indent (info);
2497 print_vma (val, ab, FALSE, FALSE);
2498 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2499 name, info->filename, ab);
2500 return TRUE;
2503 /* Output a floating point constant. */
2505 static bfd_boolean
2506 tg_float_constant (void *p, const char *name, double val)
2508 struct pr_handle *info = (struct pr_handle *) p;
2510 indent (info);
2511 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2512 name, info->filename, val);
2513 return TRUE;
2516 /* Output a typed constant. */
2518 static bfd_boolean
2519 tg_typed_constant (void *p, const char *name, bfd_vma val)
2521 struct pr_handle *info = (struct pr_handle *) p;
2522 char *t;
2523 char ab[20];
2525 t = pop_type (info);
2526 if (t == NULL)
2527 return FALSE;
2529 indent (info);
2530 print_vma (val, ab, FALSE, FALSE);
2531 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2532 name, info->filename, t, ab);
2534 free (t);
2536 return TRUE;
2539 /* Output a variable. */
2541 static bfd_boolean
2542 tg_variable (void *p, const char *name, enum debug_var_kind kind,
2543 bfd_vma val ATTRIBUTE_UNUSED)
2545 struct pr_handle *info = (struct pr_handle *) p;
2546 char *t, *dname, *from_class;
2548 t = pop_type (info);
2549 if (t == NULL)
2550 return FALSE;
2552 dname = NULL;
2553 if (info->demangler)
2554 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2556 from_class = NULL;
2557 if (dname != NULL)
2559 char *sep;
2560 sep = strstr (dname, "::");
2561 if (sep)
2563 *sep = 0;
2564 name = sep + 2;
2565 from_class = dname;
2567 else
2568 /* Obscure types as vts and type_info nodes. */
2569 name = dname;
2572 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2574 switch (kind)
2576 case DEBUG_STATIC:
2577 case DEBUG_LOCAL_STATIC:
2578 fprintf (info->f, "\tfile:");
2579 break;
2580 case DEBUG_REGISTER:
2581 fprintf (info->f, "\tregister:");
2582 break;
2583 default:
2584 break;
2587 if (from_class)
2588 fprintf (info->f, "\tclass:%s", from_class);
2590 if (dname)
2591 free (dname);
2593 fprintf (info->f, "\n");
2595 free (t);
2597 return TRUE;
2600 /* Start outputting a function. */
2602 static bfd_boolean
2603 tg_start_function (void *p, const char *name, bfd_boolean global)
2605 struct pr_handle *info = (struct pr_handle *) p;
2606 char *dname;
2608 if (! global)
2609 info->stack->flavor = "static";
2610 else
2611 info->stack->flavor = NULL;
2613 dname = NULL;
2614 if (info->demangler)
2615 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2617 if (! substitute_type (info, dname ? dname : name))
2618 return FALSE;
2620 info->stack->method = NULL;
2621 if (dname != NULL)
2623 char *sep;
2624 sep = strstr (dname, "::");
2625 if (sep)
2627 info->stack->method = dname;
2628 *sep = 0;
2629 name = sep + 2;
2631 else
2633 info->stack->method = "";
2634 name = dname;
2636 sep = strchr (name, '(');
2637 if (sep)
2638 *sep = 0;
2639 /* Obscure functions as type_info function. */
2642 info->stack->parents = strdup (name);
2644 if (! info->stack->method && ! append_type (info, "("))
2645 return FALSE;
2647 info->parameter = 1;
2649 return TRUE;
2652 /* Output a function parameter. */
2654 static bfd_boolean
2655 tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2656 bfd_vma val ATTRIBUTE_UNUSED)
2658 struct pr_handle *info = (struct pr_handle *) p;
2659 char *t;
2661 if (kind == DEBUG_PARM_REFERENCE
2662 || kind == DEBUG_PARM_REF_REG)
2664 if (! pr_reference_type (p))
2665 return FALSE;
2668 if (! substitute_type (info, name))
2669 return FALSE;
2671 t = pop_type (info);
2672 if (t == NULL)
2673 return FALSE;
2675 if (! info->stack->method)
2677 if (info->parameter != 1 && ! append_type (info, ", "))
2678 return FALSE;
2680 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2681 if (! append_type (info, "register "))
2682 return FALSE;
2684 if (! append_type (info, t))
2685 return FALSE;
2688 free (t);
2690 ++info->parameter;
2692 return TRUE;
2695 /* Start writing out a block. */
2697 static bfd_boolean
2698 tg_start_block (void *p, bfd_vma addr)
2700 struct pr_handle *info = (struct pr_handle *) p;
2701 char ab[20], kind, *partof;
2702 char *t;
2703 bfd_boolean local;
2705 if (info->parameter > 0)
2707 info->parameter = 0;
2709 /* Delayed name. */
2710 fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2711 free (info->stack->parents);
2713 print_vma (addr, ab, TRUE, TRUE);
2714 translate_addresses (info->abfd, ab, info->f, info->syms);
2715 local = info->stack->flavor != NULL;
2716 if (info->stack->method && *info->stack->method)
2718 kind = 'm';
2719 partof = (char *) info->stack->method;
2721 else
2723 kind = 'f';
2724 partof = NULL;
2725 if (! info->stack->method && ! append_type (info, ")"))
2726 return FALSE;
2728 t = pop_type (info);
2729 if (t == NULL)
2730 return FALSE;
2731 fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2732 if (local)
2733 fputs ("\tfile:", info->f);
2734 if (partof)
2736 fprintf (info->f, "\tclass:%s", partof);
2737 free (partof);
2739 fputc ('\n', info->f);
2742 return TRUE;
2745 /* Write out line number information. */
2747 static bfd_boolean
2748 tg_lineno (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED,
2749 unsigned long lineno ATTRIBUTE_UNUSED,
2750 bfd_vma addr ATTRIBUTE_UNUSED)
2752 return TRUE;
2755 /* Finish writing out a block. */
2757 static bfd_boolean
2758 tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2760 return TRUE;
2763 /* Convert the visibility value into a human readable name. */
2765 static const char *
2766 visibility_name (enum debug_visibility visibility)
2768 const char *s;
2770 switch (visibility)
2772 case DEBUG_VISIBILITY_PUBLIC:
2773 s = "public";
2774 break;
2775 case DEBUG_VISIBILITY_PRIVATE:
2776 s = "private";
2777 break;
2778 case DEBUG_VISIBILITY_PROTECTED:
2779 s = "protected";
2780 break;
2781 case DEBUG_VISIBILITY_IGNORE:
2782 s = "/* ignore */";
2783 break;
2784 default:
2785 abort ();
2786 return FALSE;
2788 return s;