OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [binutils/] [prdbg.c] - Blame information for rev 38

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

Line No. Rev Author Line
1 38 julius
/* prdbg.c -- Print out generic debugging information.
2
   Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2006, 2007, 2008
3
   Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor <ian@cygnus.com>.
5
   Tags style generation written by Salvador E. Tropea <set@computer.org>.
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 = 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 = 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 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 (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
  struct pr_handle *info = (struct pr_handle *) p;
2092
  assert (info->stack != NULL);
2093
 
2094
  return TRUE;
2095
}
2096
 
2097
/* Start a class type.  */
2098
 
2099
static bfd_boolean
2100
tg_start_class_type (void *p, const char *tag, unsigned int id,
2101
                     bfd_boolean structp, unsigned int size,
2102
                     bfd_boolean vptr, bfd_boolean ownvptr)
2103
{
2104
  struct pr_handle *info = (struct pr_handle *) p;
2105
  char *tv = NULL;
2106
  const char *name;
2107
 
2108
  info->indent += 2;
2109
 
2110
  if (vptr && ! ownvptr)
2111
    {
2112
      tv = pop_type (info);
2113
      if (tv == NULL)
2114
        return FALSE;
2115
    }
2116
 
2117
  if (tag != NULL)
2118
    name = tag;
2119
  else
2120
    {
2121
      char idbuf[20];
2122
 
2123
      sprintf (idbuf, "%%anon%u", id);
2124
      name = idbuf;
2125
    }
2126
 
2127
  if (! push_type (info, name))
2128
    return FALSE;
2129
 
2130
  info->stack->flavor = structp ? "class" : "union class";
2131
  info->stack->parents = NULL;
2132
  info->stack->num_parents = 0;
2133
 
2134
  if (size != 0 || vptr || ownvptr || tag != NULL)
2135
    {
2136
      if (vptr)
2137
        {
2138
          if (! append_type (info, " vtable "))
2139
            return FALSE;
2140
          if (ownvptr)
2141
            {
2142
              if (! append_type (info, "self "))
2143
                return FALSE;
2144
            }
2145
          else
2146
            {
2147
              if (! append_type (info, tv)
2148
                  || ! append_type (info, " "))
2149
                return FALSE;
2150
            }
2151
        }
2152
    }
2153
 
2154
  info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2155
 
2156
  return TRUE;
2157
}
2158
 
2159
/* Add a static member to a class.  */
2160
 
2161
static bfd_boolean
2162
tg_class_static_member (void *p, const char *name,
2163
                        const char *physname ATTRIBUTE_UNUSED,
2164
                        enum debug_visibility visibility)
2165
{
2166
  struct pr_handle *info = (struct pr_handle *) p;
2167
  char *t;
2168
  int len_var, len_class;
2169
  char *full_name;
2170
 
2171
  len_var = strlen (name);
2172
  len_class = strlen (info->stack->next->type);
2173
  full_name = xmalloc (len_var + len_class + 3);
2174
  if (! full_name)
2175
    return FALSE;
2176
  sprintf (full_name, "%s::%s", info->stack->next->type, name);
2177
 
2178
  if (! substitute_type (info, full_name))
2179
    return FALSE;
2180
 
2181
  if (! prepend_type (info, "static "))
2182
    return FALSE;
2183
 
2184
  t = pop_type (info);
2185
  if (t == NULL)
2186
    return FALSE;
2187
 
2188
  if (! tg_fix_visibility (info, visibility))
2189
    return FALSE;
2190
 
2191
  fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2192
           name, info->filename, t, info->stack->type,
2193
           visibility_name (visibility));
2194
  free (t);
2195
  free (full_name);
2196
 
2197
  return TRUE;
2198
}
2199
 
2200
/* Add a base class to a class.  */
2201
 
2202
static bfd_boolean
2203
tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2204
                    bfd_boolean virtual, enum debug_visibility visibility)
2205
{
2206
  struct pr_handle *info = (struct pr_handle *) p;
2207
  char *t;
2208
  const char *prefix;
2209
 
2210
  assert (info->stack != NULL && info->stack->next != NULL);
2211
 
2212
  t = pop_type (info);
2213
  if (t == NULL)
2214
    return FALSE;
2215
 
2216
  if (CONST_STRNEQ (t, "class "))
2217
    t += sizeof "class " - 1;
2218
 
2219
  /* Push it back on to take advantage of the prepend_type and
2220
     append_type routines.  */
2221
  if (! push_type (info, t))
2222
    return FALSE;
2223
 
2224
  if (virtual)
2225
    {
2226
      if (! prepend_type (info, "virtual "))
2227
        return FALSE;
2228
    }
2229
 
2230
  switch (visibility)
2231
    {
2232
    case DEBUG_VISIBILITY_PUBLIC:
2233
      prefix = "public ";
2234
      break;
2235
    case DEBUG_VISIBILITY_PROTECTED:
2236
      prefix = "protected ";
2237
      break;
2238
    case DEBUG_VISIBILITY_PRIVATE:
2239
      prefix = "private ";
2240
      break;
2241
    default:
2242
      prefix = "/* unknown visibility */ ";
2243
      break;
2244
    }
2245
 
2246
  if (! prepend_type (info, prefix))
2247
    return FALSE;
2248
 
2249
  t = pop_type (info);
2250
  if (t == NULL)
2251
    return FALSE;
2252
 
2253
  if (info->stack->num_parents && ! append_parent (info, ", "))
2254
    return FALSE;
2255
 
2256
  if (! append_parent (info, t))
2257
    return FALSE;
2258
  info->stack->num_parents++;
2259
 
2260
  free (t);
2261
 
2262
  return TRUE;
2263
}
2264
 
2265
/* Add a variant to a method.  */
2266
 
2267
static bfd_boolean
2268
tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2269
                         enum debug_visibility visibility,
2270
                         bfd_boolean constp, bfd_boolean volatilep,
2271
                         bfd_vma voffset ATTRIBUTE_UNUSED,
2272
                         bfd_boolean context)
2273
{
2274
  struct pr_handle *info = (struct pr_handle *) p;
2275
  char *method_type;
2276
  char *context_type;
2277
  char *method_name;
2278
 
2279
  assert (info->stack != NULL);
2280
  assert (info->stack->next != NULL);
2281
 
2282
  /* Put the const and volatile qualifiers on the type.  */
2283
  if (volatilep)
2284
    {
2285
      if (! append_type (info, " volatile"))
2286
        return FALSE;
2287
    }
2288
  if (constp)
2289
    {
2290
      if (! append_type (info, " const"))
2291
        return FALSE;
2292
    }
2293
 
2294
  method_name = strdup (context ? info->stack->next->next->method
2295
                        : info->stack->next->method);
2296
 
2297
  /* Stick the name of the method into its type.  */
2298
  if (! substitute_type (info, method_name))
2299
    return FALSE;
2300
 
2301
  /* Get the type.  */
2302
  method_type = pop_type (info);
2303
  if (method_type == NULL)
2304
    return FALSE;
2305
 
2306
  /* Pull off the context type if there is one.  */
2307
  if (! context)
2308
    context_type = NULL;
2309
  else
2310
    {
2311
      context_type = pop_type (info);
2312
      if (context_type == NULL)
2313
        return FALSE;
2314
    }
2315
 
2316
  /* Now the top of the stack is the class.  */
2317
  if (! tg_fix_visibility (info, visibility))
2318
    return FALSE;
2319
 
2320
  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2321
           method_name, info->filename, method_type, info->stack->type);
2322
  free (method_type);
2323
  free (method_name);
2324
  free (context_type);
2325
 
2326
  return TRUE;
2327
}
2328
 
2329
/* Add a static variant to a method.  */
2330
 
2331
static bfd_boolean
2332
tg_class_static_method_variant (void *p,
2333
                                const char *physname ATTRIBUTE_UNUSED,
2334
                                enum debug_visibility visibility,
2335
                                bfd_boolean constp, bfd_boolean volatilep)
2336
{
2337
  struct pr_handle *info = (struct pr_handle *) p;
2338
  char *method_type;
2339
  char *method_name;
2340
 
2341
  assert (info->stack != NULL);
2342
  assert (info->stack->next != NULL);
2343
  assert (info->stack->next->method != NULL);
2344
 
2345
  /* Put the const and volatile qualifiers on the type.  */
2346
  if (volatilep)
2347
    {
2348
      if (! append_type (info, " volatile"))
2349
        return FALSE;
2350
    }
2351
  if (constp)
2352
    {
2353
      if (! append_type (info, " const"))
2354
        return FALSE;
2355
    }
2356
 
2357
  /* Mark it as static.  */
2358
  if (! prepend_type (info, "static "))
2359
    return FALSE;
2360
 
2361
  method_name = strdup (info->stack->next->method);
2362
  /* Stick the name of the method into its type.  */
2363
  if (! substitute_type (info, info->stack->next->method))
2364
    return FALSE;
2365
 
2366
  /* Get the type.  */
2367
  method_type = pop_type (info);
2368
  if (method_type == NULL)
2369
    return FALSE;
2370
 
2371
  /* Now the top of the stack is the class.  */
2372
  if (! tg_fix_visibility (info, visibility))
2373
    return FALSE;
2374
 
2375
  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2376
           method_name, info->filename, method_type, info->stack->type,
2377
           visibility_name (visibility));
2378
  free (method_type);
2379
  free (method_name);
2380
 
2381
  return TRUE;
2382
}
2383
 
2384
/* Finish up a class.  */
2385
 
2386
static bfd_boolean
2387
tg_end_class_type (void *p)
2388
{
2389
  struct pr_handle *info = (struct pr_handle *) p;
2390
 
2391
  fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2392
           info->filename, info->stack->flavor);
2393
  if (info->stack->num_parents)
2394
    {
2395
      fprintf  (info->f, "\tinherits:%s", info->stack->parents);
2396
      free (info->stack->parents);
2397
    }
2398
  fputc ('\n', info->f);
2399
 
2400
  return tg_end_struct_type (p);
2401
}
2402
 
2403
/* Push a type on the stack using a tag name.  */
2404
 
2405
static bfd_boolean
2406
tg_tag_type (void *p, const char *name, unsigned int id,
2407
             enum debug_type_kind kind)
2408
{
2409
  struct pr_handle *info = (struct pr_handle *) p;
2410
  const char *t, *tag;
2411
  char idbuf[20];
2412
 
2413
  switch (kind)
2414
    {
2415
    case DEBUG_KIND_STRUCT:
2416
      t = "struct ";
2417
      break;
2418
    case DEBUG_KIND_UNION:
2419
      t = "union ";
2420
      break;
2421
    case DEBUG_KIND_ENUM:
2422
      t = "enum ";
2423
      break;
2424
    case DEBUG_KIND_CLASS:
2425
      t = "class ";
2426
      break;
2427
    case DEBUG_KIND_UNION_CLASS:
2428
      t = "union class ";
2429
      break;
2430
    default:
2431
      abort ();
2432
      return FALSE;
2433
    }
2434
 
2435
  if (! push_type (info, t))
2436
    return FALSE;
2437
  if (name != NULL)
2438
    tag = name;
2439
  else
2440
    {
2441
      sprintf (idbuf, "%%anon%u", id);
2442
      tag = idbuf;
2443
    }
2444
 
2445
  if (! append_type (info, tag))
2446
    return FALSE;
2447
 
2448
  return TRUE;
2449
}
2450
 
2451
/* Output a typedef.  */
2452
 
2453
static bfd_boolean
2454
tg_typdef (void *p, const char *name)
2455
{
2456
  struct pr_handle *info = (struct pr_handle *) p;
2457
  char *s;
2458
 
2459
  s = pop_type (info);
2460
  if (s == NULL)
2461
    return FALSE;
2462
 
2463
  fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2464
           info->filename, s);
2465
 
2466
  free (s);
2467
 
2468
  return TRUE;
2469
}
2470
 
2471
/* Output a tag.  The tag should already be in the string on the
2472
   stack, so all we have to do here is print it out.  */
2473
 
2474
static bfd_boolean
2475
tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2476
{
2477
  struct pr_handle *info = (struct pr_handle *) p;
2478
  char *t;
2479
 
2480
  t = pop_type (info);
2481
  if (t == NULL)
2482
    return FALSE;
2483
  free (t);
2484
 
2485
  return TRUE;
2486
}
2487
 
2488
/* Output an integer constant.  */
2489
 
2490
static bfd_boolean
2491
tg_int_constant (void *p, const char *name, bfd_vma val)
2492
{
2493
  struct pr_handle *info = (struct pr_handle *) p;
2494
  char ab[20];
2495
 
2496
  indent (info);
2497
  print_vma (val, ab, FALSE, FALSE);
2498
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2499
           name, info->filename, ab);
2500
  return TRUE;
2501
}
2502
 
2503
/* Output a floating point constant.  */
2504
 
2505
static bfd_boolean
2506
tg_float_constant (void *p, const char *name, double val)
2507
{
2508
  struct pr_handle *info = (struct pr_handle *) p;
2509
 
2510
  indent (info);
2511
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2512
           name, info->filename, val);
2513
  return TRUE;
2514
}
2515
 
2516
/* Output a typed constant.  */
2517
 
2518
static bfd_boolean
2519
tg_typed_constant (void *p, const char *name, bfd_vma val)
2520
{
2521
  struct pr_handle *info = (struct pr_handle *) p;
2522
  char *t;
2523
  char ab[20];
2524
 
2525
  t = pop_type (info);
2526
  if (t == NULL)
2527
    return FALSE;
2528
 
2529
  indent (info);
2530
  print_vma (val, ab, FALSE, FALSE);
2531
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2532
           name, info->filename, t, ab);
2533
 
2534
  free (t);
2535
 
2536
  return TRUE;
2537
}
2538
 
2539
/* Output a variable.  */
2540
 
2541
static bfd_boolean
2542
tg_variable (void *p, const char *name, enum debug_var_kind kind,
2543
             bfd_vma val ATTRIBUTE_UNUSED)
2544
{
2545
  struct pr_handle *info = (struct pr_handle *) p;
2546
  char *t, *dname, *from_class;
2547
 
2548
  t = pop_type (info);
2549
  if (t == NULL)
2550
    return FALSE;
2551
 
2552
  dname = NULL;
2553
  if (info->demangler)
2554
    dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2555
 
2556
  from_class = NULL;
2557
  if (dname != NULL)
2558
    {
2559
      char *sep;
2560
      sep = strstr (dname, "::");
2561
      if (sep)
2562
        {
2563
          *sep = 0;
2564
          name = sep + 2;
2565
          from_class = dname;
2566
        }
2567
      else
2568
        /* Obscure types as vts and type_info nodes.  */
2569
        name = dname;
2570
    }
2571
 
2572
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2573
 
2574
  switch (kind)
2575
    {
2576
    case DEBUG_STATIC:
2577
    case DEBUG_LOCAL_STATIC:
2578
      fprintf (info->f, "\tfile:");
2579
      break;
2580
    case DEBUG_REGISTER:
2581
      fprintf (info->f, "\tregister:");
2582
      break;
2583
    default:
2584
      break;
2585
    }
2586
 
2587
  if (from_class)
2588
    fprintf (info->f, "\tclass:%s", from_class);
2589
 
2590
  if (dname)
2591
    free (dname);
2592
 
2593
  fprintf (info->f, "\n");
2594
 
2595
  free (t);
2596
 
2597
  return TRUE;
2598
}
2599
 
2600
/* Start outputting a function.  */
2601
 
2602
static bfd_boolean
2603
tg_start_function (void *p, const char *name, bfd_boolean global)
2604
{
2605
  struct pr_handle *info = (struct pr_handle *) p;
2606
  char *dname;
2607
 
2608
  if (! global)
2609
    info->stack->flavor = "static";
2610
  else
2611
    info->stack->flavor = NULL;
2612
 
2613
  dname = NULL;
2614
  if (info->demangler)
2615
    dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2616
 
2617
  if (! substitute_type (info, dname ? dname : name))
2618
    return FALSE;
2619
 
2620
  info->stack->method = NULL;
2621
  if (dname != NULL)
2622
    {
2623
      char *sep;
2624
      sep = strstr (dname, "::");
2625
      if (sep)
2626
        {
2627
          info->stack->method = dname;
2628
          *sep = 0;
2629
          name = sep + 2;
2630
        }
2631
      else
2632
        {
2633
          info->stack->method = "";
2634
          name = dname;
2635
        }
2636
      sep = strchr (name, '(');
2637
      if (sep)
2638
        *sep = 0;
2639
      /* Obscure functions as type_info function.  */
2640
    }
2641
 
2642
  info->stack->parents = strdup (name);
2643
 
2644
  if (! info->stack->method && ! append_type (info, "("))
2645
    return FALSE;
2646
 
2647
  info->parameter = 1;
2648
 
2649
  return TRUE;
2650
}
2651
 
2652
/* Output a function parameter.  */
2653
 
2654
static bfd_boolean
2655
tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2656
                       bfd_vma val ATTRIBUTE_UNUSED)
2657
{
2658
  struct pr_handle *info = (struct pr_handle *) p;
2659
  char *t;
2660
 
2661
  if (kind == DEBUG_PARM_REFERENCE
2662
      || kind == DEBUG_PARM_REF_REG)
2663
    {
2664
      if (! pr_reference_type (p))
2665
        return FALSE;
2666
    }
2667
 
2668
  if (! substitute_type (info, name))
2669
    return FALSE;
2670
 
2671
  t = pop_type (info);
2672
  if (t == NULL)
2673
    return FALSE;
2674
 
2675
  if (! info->stack->method)
2676
    {
2677
      if (info->parameter != 1 && ! append_type (info, ", "))
2678
        return FALSE;
2679
 
2680
      if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2681
        if (! append_type (info, "register "))
2682
          return FALSE;
2683
 
2684
      if (! append_type (info, t))
2685
        return FALSE;
2686
    }
2687
 
2688
  free (t);
2689
 
2690
  ++info->parameter;
2691
 
2692
  return TRUE;
2693
}
2694
 
2695
/* Start writing out a block.  */
2696
 
2697
static bfd_boolean
2698
tg_start_block (void *p, bfd_vma addr)
2699
{
2700
  struct pr_handle *info = (struct pr_handle *) p;
2701
  char ab[20], kind, *partof;
2702
  char *t;
2703
  bfd_boolean local;
2704
 
2705
  if (info->parameter > 0)
2706
    {
2707
      info->parameter = 0;
2708
 
2709
      /* Delayed name.  */
2710
      fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2711
      free (info->stack->parents);
2712
 
2713
      print_vma (addr, ab, TRUE, TRUE);
2714
      translate_addresses (info->abfd, ab, info->f, info->syms);
2715
      local = info->stack->flavor != NULL;
2716
      if (info->stack->method && *info->stack->method)
2717
        {
2718
          kind = 'm';
2719
          partof = (char *) info->stack->method;
2720
        }
2721
      else
2722
        {
2723
          kind = 'f';
2724
          partof = NULL;
2725
          if (! info->stack->method && ! append_type (info, ")"))
2726
            return FALSE;
2727
        }
2728
      t = pop_type (info);
2729
      if (t == NULL)
2730
        return FALSE;
2731
      fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2732
      if (local)
2733
        fputs ("\tfile:", info->f);
2734
      if (partof)
2735
        {
2736
          fprintf (info->f, "\tclass:%s", partof);
2737
          free (partof);
2738
        }
2739
      fputc ('\n', info->f);
2740
    }
2741
 
2742
  return TRUE;
2743
}
2744
 
2745
/* Write out line number information.  */
2746
 
2747
static bfd_boolean
2748
tg_lineno (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED,
2749
           unsigned long lineno ATTRIBUTE_UNUSED,
2750
           bfd_vma addr ATTRIBUTE_UNUSED)
2751
{
2752
  return TRUE;
2753
}
2754
 
2755
/* Finish writing out a block.  */
2756
 
2757
static bfd_boolean
2758
tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2759
{
2760
  return TRUE;
2761
}
2762
 
2763
/* Convert the visibility value into a human readable name.  */
2764
 
2765
static const char *
2766
visibility_name (enum debug_visibility visibility)
2767
{
2768
  const char *s;
2769
 
2770
  switch (visibility)
2771
    {
2772
    case DEBUG_VISIBILITY_PUBLIC:
2773
      s = "public";
2774
      break;
2775
    case DEBUG_VISIBILITY_PRIVATE:
2776
      s = "private";
2777
      break;
2778
    case DEBUG_VISIBILITY_PROTECTED:
2779
      s = "protected";
2780
      break;
2781
    case DEBUG_VISIBILITY_IGNORE:
2782
      s = "/* ignore */";
2783
      break;
2784
    default:
2785
      abort ();
2786
      return FALSE;
2787
    }
2788
  return s;
2789
}

powered by: WebSVN 2.1.0

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