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