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

Subversion Repositories openrisc

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

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.