OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [prdbg.c] - Blame information for rev 277

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.