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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [prdbg.c] - Blame information for rev 53

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

Line No. Rev Author Line
1 15 khays
/* prdbg.c -- Print out generic debugging information.
2
   Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3
   2009, 2011  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
            {
735
              free (arg_types);
736
              return FALSE;
737
            }
738
          arg_types[i] = pop_type (info);
739
          if (arg_types[i] == NULL)
740
            {
741
              free (arg_types);
742
              return FALSE;
743
            }
744
          len += strlen (arg_types[i]) + 2;
745
        }
746
      if (varargs)
747
        len += 5;
748
    }
749
 
750
  /* Now the return type is on the top of the stack.  */
751
 
752
  s = (char *) xmalloc (len);
753
  LITSTRCPY (s, "(|) (");
754
 
755
  if (argcount < 0)
756
    strcat (s, "/* unknown */");
757
  else
758
    {
759
      int i;
760
 
761
      for (i = 0; i < argcount; i++)
762
        {
763
          if (i > 0)
764
            strcat (s, ", ");
765
          strcat (s, arg_types[i]);
766
        }
767
      if (varargs)
768
        {
769
          if (i > 0)
770
            strcat (s, ", ");
771
          strcat (s, "...");
772
        }
773
      if (argcount > 0)
774
        free (arg_types);
775
    }
776
 
777
  strcat (s, ")");
778
 
779
  if (! substitute_type (info, s))
780
    return FALSE;
781
 
782
  free (s);
783
 
784
  return TRUE;
785
}
786
 
787
/* Turn the top type on the stack into a reference to that type.  */
788
 
789
static bfd_boolean
790
pr_reference_type (void *p)
791
{
792
  struct pr_handle *info = (struct pr_handle *) p;
793
 
794
  assert (info->stack != NULL);
795
 
796
  return substitute_type (info, "&|");
797
}
798
 
799
/* Make a range type.  */
800
 
801
static bfd_boolean
802
pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
803
{
804
  struct pr_handle *info = (struct pr_handle *) p;
805
  char abl[20], abu[20];
806
 
807
  assert (info->stack != NULL);
808
 
809
  if (! substitute_type (info, ""))
810
    return FALSE;
811
 
812
  print_vma (lower, abl, FALSE, FALSE);
813
  print_vma (upper, abu, FALSE, FALSE);
814
 
815
  return (prepend_type (info, "range (")
816
          && append_type (info, "):")
817
          && append_type (info, abl)
818
          && append_type (info, ":")
819
          && append_type (info, abu));
820
}
821
 
822
/* Make an array type.  */
823
 
824
static bfd_boolean
825
pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
826
               bfd_boolean stringp)
827
{
828
  struct pr_handle *info = (struct pr_handle *) p;
829
  char *range_type;
830
  char abl[20], abu[20], ab[50];
831
 
832
  range_type = pop_type (info);
833
  if (range_type == NULL)
834
    return FALSE;
835
 
836
  if (lower == 0)
837
    {
838
      if (upper == -1)
839
        sprintf (ab, "|[]");
840
      else
841
        {
842
          print_vma (upper + 1, abu, FALSE, FALSE);
843
          sprintf (ab, "|[%s]", abu);
844
        }
845
    }
846
  else
847
    {
848
      print_vma (lower, abl, FALSE, FALSE);
849
      print_vma (upper, abu, FALSE, FALSE);
850
      sprintf (ab, "|[%s:%s]", abl, abu);
851
    }
852
 
853
  if (! substitute_type (info, ab))
854
    return FALSE;
855
 
856
  if (strcmp (range_type, "int") != 0)
857
    {
858
      if (! append_type (info, ":")
859
          || ! append_type (info, range_type))
860
        return FALSE;
861
    }
862
 
863
  if (stringp)
864
    {
865
      if (! append_type (info, " /* string */"))
866
        return FALSE;
867
    }
868
 
869
  return TRUE;
870
}
871
 
872
/* Make a set type.  */
873
 
874
static bfd_boolean
875
pr_set_type (void *p, bfd_boolean bitstringp)
876
{
877
  struct pr_handle *info = (struct pr_handle *) p;
878
 
879
  if (! substitute_type (info, ""))
880
    return FALSE;
881
 
882
  if (! prepend_type (info, "set { ")
883
      || ! append_type (info, " }"))
884
    return FALSE;
885
 
886
  if (bitstringp)
887
    {
888
      if (! append_type (info, "/* bitstring */"))
889
        return FALSE;
890
    }
891
 
892
  return TRUE;
893
}
894
 
895
/* Make an offset type.  */
896
 
897
static bfd_boolean
898
pr_offset_type (void *p)
899
{
900
  struct pr_handle *info = (struct pr_handle *) p;
901
  char *t;
902
 
903
  if (! substitute_type (info, ""))
904
    return FALSE;
905
 
906
  t = pop_type (info);
907
  if (t == NULL)
908
    return FALSE;
909
 
910
  return (substitute_type (info, "")
911
          && prepend_type (info, " ")
912
          && prepend_type (info, t)
913
          && append_type (info, "::|"));
914
}
915
 
916
/* Make a method type.  */
917
 
918
static bfd_boolean
919
pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
920
{
921
  struct pr_handle *info = (struct pr_handle *) p;
922
  unsigned int len;
923
  char *domain_type;
924
  char **arg_types;
925
  char *s;
926
 
927
  len = 10;
928
 
929
  if (! domain)
930
    domain_type = NULL;
931
  else
932
    {
933
      if (! substitute_type (info, ""))
934
        return FALSE;
935
      domain_type = pop_type (info);
936
      if (domain_type == NULL)
937
        return FALSE;
938
      if (CONST_STRNEQ (domain_type, "class ")
939
          && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
940
        domain_type += sizeof "class " - 1;
941
      else if (CONST_STRNEQ (domain_type, "union class ")
942
               && (strchr (domain_type + sizeof "union class " - 1, ' ')
943
                   == NULL))
944
        domain_type += sizeof "union class " - 1;
945
      len += strlen (domain_type);
946
    }
947
 
948
  if (argcount <= 0)
949
    {
950
      arg_types = NULL;
951
      len += 15;
952
    }
953
  else
954
    {
955
      int i;
956
 
957
      arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
958
      for (i = argcount - 1; i >= 0; i--)
959
        {
960
          if (! substitute_type (info, ""))
961
            {
962
              free (arg_types);
963
              return FALSE;
964
            }
965
          arg_types[i] = pop_type (info);
966
          if (arg_types[i] == NULL)
967
            {
968
              free (arg_types);
969
              return FALSE;
970
            }
971
          len += strlen (arg_types[i]) + 2;
972
        }
973
      if (varargs)
974
        len += 5;
975
    }
976
 
977
  /* Now the return type is on the top of the stack.  */
978
 
979
  s = (char *) xmalloc (len);
980
  if (! domain)
981
    *s = '\0';
982
  else
983
    strcpy (s, domain_type);
984
  strcat (s, "::| (");
985
 
986
  if (argcount < 0)
987
    strcat (s, "/* unknown */");
988
  else
989
    {
990
      int i;
991
 
992
      for (i = 0; i < argcount; i++)
993
        {
994
          if (i > 0)
995
            strcat (s, ", ");
996
          strcat (s, arg_types[i]);
997
        }
998
      if (varargs)
999
        {
1000
          if (i > 0)
1001
            strcat (s, ", ");
1002
          strcat (s, "...");
1003
        }
1004
      if (argcount > 0)
1005
        free (arg_types);
1006
    }
1007
 
1008
  strcat (s, ")");
1009
 
1010
  if (! substitute_type (info, s))
1011
    return FALSE;
1012
 
1013
  free (s);
1014
 
1015
  return TRUE;
1016
}
1017
 
1018
/* Make a const qualified type.  */
1019
 
1020
static bfd_boolean
1021
pr_const_type (void *p)
1022
{
1023
  struct pr_handle *info = (struct pr_handle *) p;
1024
 
1025
  return substitute_type (info, "const |");
1026
}
1027
 
1028
/* Make a volatile qualified type.  */
1029
 
1030
static bfd_boolean
1031
pr_volatile_type (void *p)
1032
{
1033
  struct pr_handle *info = (struct pr_handle *) p;
1034
 
1035
  return substitute_type (info, "volatile |");
1036
}
1037
 
1038
/* Start accumulating a struct type.  */
1039
 
1040
static bfd_boolean
1041
pr_start_struct_type (void *p, const char *tag, unsigned int id,
1042
                      bfd_boolean structp, unsigned int size)
1043
{
1044
  struct pr_handle *info = (struct pr_handle *) p;
1045
 
1046
  info->indent += 2;
1047
 
1048
  if (! push_type (info, structp ? "struct " : "union "))
1049
    return FALSE;
1050
  if (tag != NULL)
1051
    {
1052
      if (! append_type (info, tag))
1053
        return FALSE;
1054
    }
1055
  else
1056
    {
1057
      char idbuf[20];
1058
 
1059
      sprintf (idbuf, "%%anon%u", id);
1060
      if (! append_type (info, idbuf))
1061
        return FALSE;
1062
    }
1063
 
1064
  if (! append_type (info, " {"))
1065
    return FALSE;
1066
  if (size != 0 || tag != NULL)
1067
    {
1068
      char ab[30];
1069
 
1070
      if (! append_type (info, " /*"))
1071
        return FALSE;
1072
 
1073
      if (size != 0)
1074
        {
1075
          sprintf (ab, " size %u", size);
1076
          if (! append_type (info, ab))
1077
            return FALSE;
1078
        }
1079
      if (tag != NULL)
1080
        {
1081
          sprintf (ab, " id %u", id);
1082
          if (! append_type (info, ab))
1083
            return FALSE;
1084
        }
1085
      if (! append_type (info, " */"))
1086
        return FALSE;
1087
    }
1088
  if (! append_type (info, "\n"))
1089
    return FALSE;
1090
 
1091
  info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
1092
 
1093
  return indent_type (info);
1094
}
1095
 
1096
/* Output the visibility of a field in a struct.  */
1097
 
1098
static bfd_boolean
1099
pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1100
{
1101
  const char *s = NULL;
1102
  char *t;
1103
  unsigned int len;
1104
 
1105
  assert (info->stack != NULL);
1106
 
1107
  if (info->stack->visibility == visibility)
1108
    return TRUE;
1109
 
1110
  switch (visibility)
1111
    {
1112
    case DEBUG_VISIBILITY_PUBLIC:
1113
      s = "public";
1114
      break;
1115
    case DEBUG_VISIBILITY_PRIVATE:
1116
      s = "private";
1117
      break;
1118
    case DEBUG_VISIBILITY_PROTECTED:
1119
      s = "protected";
1120
      break;
1121
    case DEBUG_VISIBILITY_IGNORE:
1122
      s = "/* ignore */";
1123
      break;
1124
    default:
1125
      abort ();
1126
      return FALSE;
1127
    }
1128
 
1129
  /* Trim off a trailing space in the struct string, to make the
1130
     output look a bit better, then stick on the visibility string.  */
1131
 
1132
  t = info->stack->type;
1133
  len = strlen (t);
1134
  assert (t[len - 1] == ' ');
1135
  t[len - 1] = '\0';
1136
 
1137
  if (! append_type (info, s)
1138
      || ! append_type (info, ":\n")
1139
      || ! indent_type (info))
1140
    return FALSE;
1141
 
1142
  info->stack->visibility = visibility;
1143
 
1144
  return TRUE;
1145
}
1146
 
1147
/* Add a field to a struct type.  */
1148
 
1149
static bfd_boolean
1150
pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
1151
                 enum debug_visibility visibility)
1152
{
1153
  struct pr_handle *info = (struct pr_handle *) p;
1154
  char ab[20];
1155
  char *t;
1156
 
1157
  if (! substitute_type (info, name))
1158
    return FALSE;
1159
 
1160
  if (! append_type (info, "; /* "))
1161
    return FALSE;
1162
 
1163
  if (bitsize != 0)
1164
    {
1165
      print_vma (bitsize, ab, TRUE, FALSE);
1166
      if (! append_type (info, "bitsize ")
1167
          || ! append_type (info, ab)
1168
          || ! append_type (info, ", "))
1169
        return FALSE;
1170
    }
1171
 
1172
  print_vma (bitpos, ab, TRUE, FALSE);
1173
  if (! append_type (info, "bitpos ")
1174
      || ! append_type (info, ab)
1175
      || ! append_type (info, " */\n")
1176
      || ! indent_type (info))
1177
    return FALSE;
1178
 
1179
  t = pop_type (info);
1180
  if (t == NULL)
1181
    return FALSE;
1182
 
1183
  if (! pr_fix_visibility (info, visibility))
1184
    return FALSE;
1185
 
1186
  return append_type (info, t);
1187
}
1188
 
1189
/* Finish a struct type.  */
1190
 
1191
static bfd_boolean
1192
pr_end_struct_type (void *p)
1193
{
1194
  struct pr_handle *info = (struct pr_handle *) p;
1195
  char *s;
1196
 
1197
  assert (info->stack != NULL);
1198
  assert (info->indent >= 2);
1199
 
1200
  info->indent -= 2;
1201
 
1202
  /* Change the trailing indentation to have a close brace.  */
1203
  s = info->stack->type + strlen (info->stack->type) - 2;
1204
  assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1205
 
1206
  *s++ = '}';
1207
  *s = '\0';
1208
 
1209
  return TRUE;
1210
}
1211
 
1212
/* Start a class type.  */
1213
 
1214
static bfd_boolean
1215
pr_start_class_type (void *p, const char *tag, unsigned int id,
1216
                     bfd_boolean structp, unsigned int size,
1217
                     bfd_boolean vptr, bfd_boolean ownvptr)
1218
{
1219
  struct pr_handle *info = (struct pr_handle *) p;
1220
  char *tv = NULL;
1221
 
1222
  info->indent += 2;
1223
 
1224
  if (vptr && ! ownvptr)
1225
    {
1226
      tv = pop_type (info);
1227
      if (tv == NULL)
1228
        return FALSE;
1229
    }
1230
 
1231
  if (! push_type (info, structp ? "class " : "union class "))
1232
    return FALSE;
1233
  if (tag != NULL)
1234
    {
1235
      if (! append_type (info, tag))
1236
        return FALSE;
1237
    }
1238
  else
1239
    {
1240
      char idbuf[20];
1241
 
1242
      sprintf (idbuf, "%%anon%u", id);
1243
      if (! append_type (info, idbuf))
1244
        return FALSE;
1245
    }
1246
 
1247
  if (! append_type (info, " {"))
1248
    return FALSE;
1249
  if (size != 0 || vptr || ownvptr || tag != NULL)
1250
    {
1251
      if (! append_type (info, " /*"))
1252
        return FALSE;
1253
 
1254
      if (size != 0)
1255
        {
1256
          char ab[20];
1257
 
1258
          sprintf (ab, "%u", size);
1259
          if (! append_type (info, " size ")
1260
              || ! append_type (info, ab))
1261
            return FALSE;
1262
        }
1263
 
1264
      if (vptr)
1265
        {
1266
          if (! append_type (info, " vtable "))
1267
            return FALSE;
1268
          if (ownvptr)
1269
            {
1270
              if (! append_type (info, "self "))
1271
                return FALSE;
1272
            }
1273
          else
1274
            {
1275
              if (! append_type (info, tv)
1276
                  || ! append_type (info, " "))
1277
                return FALSE;
1278
            }
1279
        }
1280
 
1281
      if (tag != NULL)
1282
        {
1283
          char ab[30];
1284
 
1285
          sprintf (ab, " id %u", id);
1286
          if (! append_type (info, ab))
1287
            return FALSE;
1288
        }
1289
 
1290
      if (! append_type (info, " */"))
1291
        return FALSE;
1292
    }
1293
 
1294
  info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1295
 
1296
  return (append_type (info, "\n")
1297
          && indent_type (info));
1298
}
1299
 
1300
/* Add a static member to a class.  */
1301
 
1302
static bfd_boolean
1303
pr_class_static_member (void *p, const char *name, const char *physname,
1304
                        enum debug_visibility visibility)
1305
{
1306
  struct pr_handle *info = (struct pr_handle *) p;
1307
  char *t;
1308
 
1309
  if (! substitute_type (info, name))
1310
    return FALSE;
1311
 
1312
  if (! prepend_type (info, "static ")
1313
      || ! append_type (info, "; /* ")
1314
      || ! append_type (info, physname)
1315
      || ! append_type (info, " */\n")
1316
      || ! indent_type (info))
1317
    return FALSE;
1318
 
1319
  t = pop_type (info);
1320
  if (t == NULL)
1321
    return FALSE;
1322
 
1323
  if (! pr_fix_visibility (info, visibility))
1324
    return FALSE;
1325
 
1326
  return append_type (info, t);
1327
}
1328
 
1329
/* Add a base class to a class.  */
1330
 
1331
static bfd_boolean
1332
pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
1333
                    enum debug_visibility visibility)
1334
{
1335
  struct pr_handle *info = (struct pr_handle *) p;
1336
  char *t;
1337
  const char *prefix;
1338
  char ab[20];
1339
  char *s, *l, *n;
1340
 
1341
  assert (info->stack != NULL && info->stack->next != NULL);
1342
 
1343
  if (! substitute_type (info, ""))
1344
    return FALSE;
1345
 
1346
  t = pop_type (info);
1347
  if (t == NULL)
1348
    return FALSE;
1349
 
1350
  if (CONST_STRNEQ (t, "class "))
1351
    t += sizeof "class " - 1;
1352
 
1353
  /* Push it back on to take advantage of the prepend_type and
1354
     append_type routines.  */
1355
  if (! push_type (info, t))
1356
    return FALSE;
1357
 
1358
  if (is_virtual)
1359
    {
1360
      if (! prepend_type (info, "virtual "))
1361
        return FALSE;
1362
    }
1363
 
1364
  switch (visibility)
1365
    {
1366
    case DEBUG_VISIBILITY_PUBLIC:
1367
      prefix = "public ";
1368
      break;
1369
    case DEBUG_VISIBILITY_PROTECTED:
1370
      prefix = "protected ";
1371
      break;
1372
    case DEBUG_VISIBILITY_PRIVATE:
1373
      prefix = "private ";
1374
      break;
1375
    default:
1376
      prefix = "/* unknown visibility */ ";
1377
      break;
1378
    }
1379
 
1380
  if (! prepend_type (info, prefix))
1381
    return FALSE;
1382
 
1383
  if (bitpos != 0)
1384
    {
1385
      print_vma (bitpos, ab, TRUE, FALSE);
1386
      if (! append_type (info, " /* bitpos ")
1387
          || ! append_type (info, ab)
1388
          || ! append_type (info, " */"))
1389
        return FALSE;
1390
    }
1391
 
1392
  /* Now the top of the stack is something like "public A / * bitpos
1393
     10 * /".  The next element on the stack is something like "class
1394
     xx { / * size 8 * /\n...".  We want to substitute the top of the
1395
     stack in before the {.  */
1396
  s = strchr (info->stack->next->type, '{');
1397
  assert (s != NULL);
1398
  --s;
1399
 
1400
  /* If there is already a ':', then we already have a baseclass, and
1401
     we must append this one after a comma.  */
1402
  for (l = info->stack->next->type; l != s; l++)
1403
    if (*l == ':')
1404
      break;
1405
  if (! prepend_type (info, l == s ? " : " : ", "))
1406
    return FALSE;
1407
 
1408
  t = pop_type (info);
1409
  if (t == NULL)
1410
    return FALSE;
1411
 
1412
  n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1413
  memcpy (n, info->stack->type, s - info->stack->type);
1414
  strcpy (n + (s - info->stack->type), t);
1415
  strcat (n, s);
1416
 
1417
  free (info->stack->type);
1418
  info->stack->type = n;
1419
 
1420
  free (t);
1421
 
1422
  return TRUE;
1423
}
1424
 
1425
/* Start adding a method to a class.  */
1426
 
1427
static bfd_boolean
1428
pr_class_start_method (void *p, const char *name)
1429
{
1430
  struct pr_handle *info = (struct pr_handle *) p;
1431
 
1432
  assert (info->stack != NULL);
1433
  info->stack->method = name;
1434
  return TRUE;
1435
}
1436
 
1437
/* Add a variant to a method.  */
1438
 
1439
static bfd_boolean
1440
pr_class_method_variant (void *p, const char *physname,
1441
                         enum debug_visibility visibility,
1442
                         bfd_boolean constp, bfd_boolean volatilep,
1443
                         bfd_vma voffset, bfd_boolean context)
1444
{
1445
  struct pr_handle *info = (struct pr_handle *) p;
1446
  char *method_type;
1447
  char *context_type;
1448
 
1449
  assert (info->stack != NULL);
1450
  assert (info->stack->next != NULL);
1451
 
1452
  /* Put the const and volatile qualifiers on the type.  */
1453
  if (volatilep)
1454
    {
1455
      if (! append_type (info, " volatile"))
1456
        return FALSE;
1457
    }
1458
  if (constp)
1459
    {
1460
      if (! append_type (info, " const"))
1461
        return FALSE;
1462
    }
1463
 
1464
  /* Stick the name of the method into its type.  */
1465
  if (! substitute_type (info,
1466
                         (context
1467
                          ? info->stack->next->next->method
1468
                          : info->stack->next->method)))
1469
    return FALSE;
1470
 
1471
  /* Get the type.  */
1472
  method_type = pop_type (info);
1473
  if (method_type == NULL)
1474
    return FALSE;
1475
 
1476
  /* Pull off the context type if there is one.  */
1477
  if (! context)
1478
    context_type = NULL;
1479
  else
1480
    {
1481
      context_type = pop_type (info);
1482
      if (context_type == NULL)
1483
        return FALSE;
1484
    }
1485
 
1486
  /* Now the top of the stack is the class.  */
1487
 
1488
  if (! pr_fix_visibility (info, visibility))
1489
    return FALSE;
1490
 
1491
  if (! append_type (info, method_type)
1492
      || ! append_type (info, " /* ")
1493
      || ! append_type (info, physname)
1494
      || ! append_type (info, " "))
1495
    return FALSE;
1496
  if (context || voffset != 0)
1497
    {
1498
      char ab[20];
1499
 
1500
      if (context)
1501
        {
1502
          if (! append_type (info, "context ")
1503
              || ! append_type (info, context_type)
1504
              || ! append_type (info, " "))
1505
            return FALSE;
1506
        }
1507
      print_vma (voffset, ab, TRUE, FALSE);
1508
      if (! append_type (info, "voffset ")
1509
          || ! append_type (info, ab))
1510
        return FALSE;
1511
    }
1512
 
1513
  return (append_type (info, " */;\n")
1514
          && indent_type (info));
1515
}
1516
 
1517
/* Add a static variant to a method.  */
1518
 
1519
static bfd_boolean
1520
pr_class_static_method_variant (void *p, const char *physname,
1521
                                enum debug_visibility visibility,
1522
                                bfd_boolean constp, bfd_boolean volatilep)
1523
{
1524
  struct pr_handle *info = (struct pr_handle *) p;
1525
  char *method_type;
1526
 
1527
  assert (info->stack != NULL);
1528
  assert (info->stack->next != NULL);
1529
  assert (info->stack->next->method != NULL);
1530
 
1531
  /* Put the const and volatile qualifiers on the type.  */
1532
  if (volatilep)
1533
    {
1534
      if (! append_type (info, " volatile"))
1535
        return FALSE;
1536
    }
1537
  if (constp)
1538
    {
1539
      if (! append_type (info, " const"))
1540
        return FALSE;
1541
    }
1542
 
1543
  /* Mark it as static.  */
1544
  if (! prepend_type (info, "static "))
1545
    return FALSE;
1546
 
1547
  /* Stick the name of the method into its type.  */
1548
  if (! substitute_type (info, info->stack->next->method))
1549
    return FALSE;
1550
 
1551
  /* Get the type.  */
1552
  method_type = pop_type (info);
1553
  if (method_type == NULL)
1554
    return FALSE;
1555
 
1556
  /* Now the top of the stack is the class.  */
1557
 
1558
  if (! pr_fix_visibility (info, visibility))
1559
    return FALSE;
1560
 
1561
  return (append_type (info, method_type)
1562
          && append_type (info, " /* ")
1563
          && append_type (info, physname)
1564
          && append_type (info, " */;\n")
1565
          && indent_type (info));
1566
}
1567
 
1568
/* Finish up a method.  */
1569
 
1570
static bfd_boolean
1571
pr_class_end_method (void *p)
1572
{
1573
  struct pr_handle *info = (struct pr_handle *) p;
1574
 
1575
  info->stack->method = NULL;
1576
  return TRUE;
1577
}
1578
 
1579
/* Finish up a class.  */
1580
 
1581
static bfd_boolean
1582
pr_end_class_type (void *p)
1583
{
1584
  return pr_end_struct_type (p);
1585
}
1586
 
1587
/* Push a type on the stack using a typedef name.  */
1588
 
1589
static bfd_boolean
1590
pr_typedef_type (void *p, const char *name)
1591
{
1592
  struct pr_handle *info = (struct pr_handle *) p;
1593
 
1594
  return push_type (info, name);
1595
}
1596
 
1597
/* Push a type on the stack using a tag name.  */
1598
 
1599
static bfd_boolean
1600
pr_tag_type (void *p, const char *name, unsigned int id,
1601
             enum debug_type_kind kind)
1602
{
1603
  struct pr_handle *info = (struct pr_handle *) p;
1604
  const char *t, *tag;
1605
  char idbuf[20];
1606
 
1607
  switch (kind)
1608
    {
1609
    case DEBUG_KIND_STRUCT:
1610
      t = "struct ";
1611
      break;
1612
    case DEBUG_KIND_UNION:
1613
      t = "union ";
1614
      break;
1615
    case DEBUG_KIND_ENUM:
1616
      t = "enum ";
1617
      break;
1618
    case DEBUG_KIND_CLASS:
1619
      t = "class ";
1620
      break;
1621
    case DEBUG_KIND_UNION_CLASS:
1622
      t = "union class ";
1623
      break;
1624
    default:
1625
      abort ();
1626
      return FALSE;
1627
    }
1628
 
1629
  if (! push_type (info, t))
1630
    return FALSE;
1631
  if (name != NULL)
1632
    tag = name;
1633
  else
1634
    {
1635
      sprintf (idbuf, "%%anon%u", id);
1636
      tag = idbuf;
1637
    }
1638
 
1639
  if (! append_type (info, tag))
1640
    return FALSE;
1641
  if (name != NULL && kind != DEBUG_KIND_ENUM)
1642
    {
1643
      sprintf (idbuf, " /* id %u */", id);
1644
      if (! append_type (info, idbuf))
1645
        return FALSE;
1646
    }
1647
 
1648
  return TRUE;
1649
}
1650
 
1651
/* Output a typedef.  */
1652
 
1653
static bfd_boolean
1654
pr_typdef (void *p, const char *name)
1655
{
1656
  struct pr_handle *info = (struct pr_handle *) p;
1657
  char *s;
1658
 
1659
  if (! substitute_type (info, name))
1660
    return FALSE;
1661
 
1662
  s = pop_type (info);
1663
  if (s == NULL)
1664
    return FALSE;
1665
 
1666
  indent (info);
1667
  fprintf (info->f, "typedef %s;\n", s);
1668
 
1669
  free (s);
1670
 
1671
  return TRUE;
1672
}
1673
 
1674
/* Output a tag.  The tag should already be in the string on the
1675
   stack, so all we have to do here is print it out.  */
1676
 
1677
static bfd_boolean
1678
pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
1679
{
1680
  struct pr_handle *info = (struct pr_handle *) p;
1681
  char *t;
1682
 
1683
  t = pop_type (info);
1684
  if (t == NULL)
1685
    return FALSE;
1686
 
1687
  indent (info);
1688
  fprintf (info->f, "%s;\n", t);
1689
 
1690
  free (t);
1691
 
1692
  return TRUE;
1693
}
1694
 
1695
/* Output an integer constant.  */
1696
 
1697
static bfd_boolean
1698
pr_int_constant (void *p, const char *name, bfd_vma val)
1699
{
1700
  struct pr_handle *info = (struct pr_handle *) p;
1701
  char ab[20];
1702
 
1703
  indent (info);
1704
  print_vma (val, ab, FALSE, FALSE);
1705
  fprintf (info->f, "const int %s = %s;\n", name, ab);
1706
  return TRUE;
1707
}
1708
 
1709
/* Output a floating point constant.  */
1710
 
1711
static bfd_boolean
1712
pr_float_constant (void *p, const char *name, double val)
1713
{
1714
  struct pr_handle *info = (struct pr_handle *) p;
1715
 
1716
  indent (info);
1717
  fprintf (info->f, "const double %s = %g;\n", name, val);
1718
  return TRUE;
1719
}
1720
 
1721
/* Output a typed constant.  */
1722
 
1723
static bfd_boolean
1724
pr_typed_constant (void *p, const char *name, bfd_vma val)
1725
{
1726
  struct pr_handle *info = (struct pr_handle *) p;
1727
  char *t;
1728
  char ab[20];
1729
 
1730
  t = pop_type (info);
1731
  if (t == NULL)
1732
    return FALSE;
1733
 
1734
  indent (info);
1735
  print_vma (val, ab, FALSE, FALSE);
1736
  fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1737
 
1738
  free (t);
1739
 
1740
  return TRUE;
1741
}
1742
 
1743
/* Output a variable.  */
1744
 
1745
static bfd_boolean
1746
pr_variable (void *p, const char *name, enum debug_var_kind kind,
1747
             bfd_vma val)
1748
{
1749
  struct pr_handle *info = (struct pr_handle *) p;
1750
  char *t;
1751
  char ab[20];
1752
 
1753
  if (! substitute_type (info, name))
1754
    return FALSE;
1755
 
1756
  t = pop_type (info);
1757
  if (t == NULL)
1758
    return FALSE;
1759
 
1760
  indent (info);
1761
  switch (kind)
1762
    {
1763
    case DEBUG_STATIC:
1764
    case DEBUG_LOCAL_STATIC:
1765
      fprintf (info->f, "static ");
1766
      break;
1767
    case DEBUG_REGISTER:
1768
      fprintf (info->f, "register ");
1769
      break;
1770
    default:
1771
      break;
1772
    }
1773
  print_vma (val, ab, TRUE, TRUE);
1774
  fprintf (info->f, "%s /* %s */;\n", t, ab);
1775
 
1776
  free (t);
1777
 
1778
  return TRUE;
1779
}
1780
 
1781
/* Start outputting a function.  */
1782
 
1783
static bfd_boolean
1784
pr_start_function (void *p, const char *name, bfd_boolean global)
1785
{
1786
  struct pr_handle *info = (struct pr_handle *) p;
1787
  char *t;
1788
 
1789
  if (! substitute_type (info, name))
1790
    return FALSE;
1791
 
1792
  t = pop_type (info);
1793
  if (t == NULL)
1794
    return FALSE;
1795
 
1796
  indent (info);
1797
  if (! global)
1798
    fprintf (info->f, "static ");
1799
  fprintf (info->f, "%s (", t);
1800
 
1801
  info->parameter = 1;
1802
 
1803
  return TRUE;
1804
}
1805
 
1806
/* Output a function parameter.  */
1807
 
1808
static bfd_boolean
1809
pr_function_parameter (void *p, const char *name,
1810
                       enum debug_parm_kind kind, bfd_vma val)
1811
{
1812
  struct pr_handle *info = (struct pr_handle *) p;
1813
  char *t;
1814
  char ab[20];
1815
 
1816
  if (kind == DEBUG_PARM_REFERENCE
1817
      || kind == DEBUG_PARM_REF_REG)
1818
    {
1819
      if (! pr_reference_type (p))
1820
        return FALSE;
1821
    }
1822
 
1823
  if (! substitute_type (info, name))
1824
    return FALSE;
1825
 
1826
  t = pop_type (info);
1827
  if (t == NULL)
1828
    return FALSE;
1829
 
1830
  if (info->parameter != 1)
1831
    fprintf (info->f, ", ");
1832
 
1833
  if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1834
    fprintf (info->f, "register ");
1835
 
1836
  print_vma (val, ab, TRUE, TRUE);
1837
  fprintf (info->f, "%s /* %s */", t, ab);
1838
 
1839
  free (t);
1840
 
1841
  ++info->parameter;
1842
 
1843
  return TRUE;
1844
}
1845
 
1846
/* Start writing out a block.  */
1847
 
1848
static bfd_boolean
1849
pr_start_block (void *p, bfd_vma addr)
1850
{
1851
  struct pr_handle *info = (struct pr_handle *) p;
1852
  char ab[20];
1853
 
1854
  if (info->parameter > 0)
1855
    {
1856
      fprintf (info->f, ")\n");
1857
      info->parameter = 0;
1858
    }
1859
 
1860
  indent (info);
1861
  print_vma (addr, ab, TRUE, TRUE);
1862
  fprintf (info->f, "{ /* %s */\n", ab);
1863
 
1864
  info->indent += 2;
1865
 
1866
  return TRUE;
1867
}
1868
 
1869
/* Write out line number information.  */
1870
 
1871
static bfd_boolean
1872
pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1873
{
1874
  struct pr_handle *info = (struct pr_handle *) p;
1875
  char ab[20];
1876
 
1877
  indent (info);
1878
  print_vma (addr, ab, TRUE, TRUE);
1879
  fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1880
 
1881
  return TRUE;
1882
}
1883
 
1884
/* Finish writing out a block.  */
1885
 
1886
static bfd_boolean
1887
pr_end_block (void *p, bfd_vma addr)
1888
{
1889
  struct pr_handle *info = (struct pr_handle *) p;
1890
  char ab[20];
1891
 
1892
  info->indent -= 2;
1893
 
1894
  indent (info);
1895
  print_vma (addr, ab, TRUE, TRUE);
1896
  fprintf (info->f, "} /* %s */\n", ab);
1897
 
1898
  return TRUE;
1899
}
1900
 
1901
/* Finish writing out a function.  */
1902
 
1903
static bfd_boolean
1904
pr_end_function (void *p ATTRIBUTE_UNUSED)
1905
{
1906
  return TRUE;
1907
}
1908
 
1909
/* Tags style generation functions start here.  */
1910
 
1911
/* Variables for address to line translation.  */
1912
static bfd_vma pc;
1913
static const char *filename;
1914
static const char *functionname;
1915
static unsigned int line;
1916
static bfd_boolean found;
1917
 
1918
/* Look for an address in a section.  This is called via
1919
   bfd_map_over_sections.  */
1920
 
1921
static void
1922
find_address_in_section (bfd *abfd, asection *section, void *data)
1923
{
1924
  bfd_vma vma;
1925
  bfd_size_type size;
1926
  asymbol **syms = (asymbol **) data;
1927
 
1928
  if (found)
1929
    return;
1930
 
1931
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
1932
    return;
1933
 
1934
  vma = bfd_get_section_vma (abfd, section);
1935
  if (pc < vma)
1936
    return;
1937
 
1938
  size = bfd_get_section_size (section);
1939
  if (pc >= vma + size)
1940
    return;
1941
 
1942
  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
1943
                                 &filename, &functionname, &line);
1944
}
1945
 
1946
static void
1947
translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1948
{
1949
  pc = bfd_scan_vma (addr_hex, NULL, 16);
1950
  found = FALSE;
1951
  bfd_map_over_sections (abfd, find_address_in_section, syms);
1952
 
1953
  if (! found)
1954
    fprintf (f, "??");
1955
  else
1956
    fprintf (f, "%u", line);
1957
}
1958
 
1959
/* Start a new compilation unit.  */
1960
 
1961
static bfd_boolean
1962
tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED)
1963
{
1964
  struct pr_handle *info = (struct pr_handle *) p;
1965
 
1966
  free (info->filename);
1967
  /* Should it be relative? best way to do it here?.  */
1968
  info->filename = strdup (fname);
1969
 
1970
  return TRUE;
1971
}
1972
 
1973
/* Start a source file within a compilation unit.  */
1974
 
1975
static bfd_boolean
1976
tg_start_source (void *p, const char *fname)
1977
{
1978
  struct pr_handle *info = (struct pr_handle *) p;
1979
 
1980
  free (info->filename);
1981
  /* Should it be relative? best way to do it here?.  */
1982
  info->filename = strdup (fname);
1983
 
1984
  return TRUE;
1985
}
1986
 
1987
/* Push an enum type onto the type stack.  */
1988
 
1989
static bfd_boolean
1990
tg_enum_type (void *p, const char *tag, const char **names,
1991
              bfd_signed_vma *values)
1992
{
1993
  struct pr_handle *info = (struct pr_handle *) p;
1994
  unsigned int i;
1995
  const char *name;
1996
  char ab[20];
1997
 
1998
  if (! pr_enum_type (p, tag, names, values))
1999
    return FALSE;
2000
 
2001
  name = tag ? tag : "unknown";
2002
  /* Generate an entry for the enum.  */
2003
  if (tag)
2004
    fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
2005
             info->filename, info->stack->type);
2006
 
2007
  /* Generate entries for the values.  */
2008
  if (names != NULL)
2009
    {
2010
      for (i = 0; names[i] != NULL; i++)
2011
        {
2012
          print_vma (values[i], ab, FALSE, FALSE);
2013
          fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
2014
                   names[i], info->filename, name, ab);
2015
        }
2016
    }
2017
 
2018
  return TRUE;
2019
}
2020
 
2021
/* Start accumulating a struct type.  */
2022
 
2023
static bfd_boolean
2024
tg_start_struct_type (void *p, const char *tag, unsigned int id,
2025
                      bfd_boolean structp,
2026
                      unsigned int size ATTRIBUTE_UNUSED)
2027
{
2028
  struct pr_handle *info = (struct pr_handle *) p;
2029
  const char *name;
2030
  char idbuf[20];
2031
 
2032
  if (tag != NULL)
2033
    name = tag;
2034
  else
2035
    {
2036
      name = idbuf;
2037
      sprintf (idbuf, "%%anon%u", id);
2038
    }
2039
 
2040
  if (! push_type (info, name))
2041
    return FALSE;
2042
 
2043
  info->stack->flavor = structp ? "struct" : "union";
2044
 
2045
  fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
2046
           info->stack->flavor[0]);
2047
 
2048
  info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
2049
 
2050
  return indent_type (info);
2051
}
2052
 
2053
/* Output the visibility of a field in a struct.  */
2054
 
2055
static bfd_boolean
2056
tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2057
{
2058
  assert (info->stack != NULL);
2059
 
2060
  if (info->stack->visibility == visibility)
2061
    return TRUE;
2062
 
2063
  assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
2064
 
2065
  info->stack->visibility = visibility;
2066
 
2067
  return TRUE;
2068
}
2069
 
2070
/* Add a field to a struct type.  */
2071
 
2072
static bfd_boolean
2073
tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
2074
                 bfd_vma bitsize ATTRIBUTE_UNUSED,
2075
                 enum debug_visibility visibility)
2076
{
2077
  struct pr_handle *info = (struct pr_handle *) p;
2078
  char *t;
2079
 
2080
  t = pop_type (info);
2081
  if (t == NULL)
2082
    return FALSE;
2083
 
2084
  if (! tg_fix_visibility (info, visibility))
2085
    return FALSE;
2086
 
2087
  /* It happens, a bug? */
2088
  if (! name[0])
2089
    return TRUE;
2090
 
2091
  fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
2092
           name, info->filename, t, info->stack->flavor, info->stack->type,
2093
           visibility_name (visibility));
2094
 
2095
  return TRUE;
2096
}
2097
 
2098
/* Finish a struct type.  */
2099
 
2100
static bfd_boolean
2101
tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
2102
{
2103
  assert (((struct pr_handle *) p)->stack != NULL);
2104
 
2105
  return TRUE;
2106
}
2107
 
2108
/* Start a class type.  */
2109
 
2110
static bfd_boolean
2111
tg_start_class_type (void *p, const char *tag, unsigned int id,
2112
                     bfd_boolean structp, unsigned int size,
2113
                     bfd_boolean vptr, bfd_boolean ownvptr)
2114
{
2115
  struct pr_handle *info = (struct pr_handle *) p;
2116
  char *tv = NULL;
2117
  const char *name;
2118
 
2119
  info->indent += 2;
2120
 
2121
  if (vptr && ! ownvptr)
2122
    {
2123
      tv = pop_type (info);
2124
      if (tv == NULL)
2125
        return FALSE;
2126
    }
2127
 
2128
  if (tag != NULL)
2129
    name = tag;
2130
  else
2131
    {
2132
      char idbuf[20];
2133
 
2134
      sprintf (idbuf, "%%anon%u", id);
2135
      name = idbuf;
2136
    }
2137
 
2138
  if (! push_type (info, name))
2139
    return FALSE;
2140
 
2141
  info->stack->flavor = structp ? "class" : "union class";
2142
  info->stack->parents = NULL;
2143
  info->stack->num_parents = 0;
2144
 
2145
  if (size != 0 || vptr || ownvptr || tag != NULL)
2146
    {
2147
      if (vptr)
2148
        {
2149
          if (! append_type (info, " vtable "))
2150
            return FALSE;
2151
          if (ownvptr)
2152
            {
2153
              if (! append_type (info, "self "))
2154
                return FALSE;
2155
            }
2156
          else
2157
            {
2158
              if (! append_type (info, tv)
2159
                  || ! append_type (info, " "))
2160
                return FALSE;
2161
            }
2162
        }
2163
    }
2164
 
2165
  info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
2166
 
2167
  return TRUE;
2168
}
2169
 
2170
/* Add a static member to a class.  */
2171
 
2172
static bfd_boolean
2173
tg_class_static_member (void *p, const char *name,
2174
                        const char *physname ATTRIBUTE_UNUSED,
2175
                        enum debug_visibility visibility)
2176
{
2177
  struct pr_handle *info = (struct pr_handle *) p;
2178
  char *t;
2179
  int len_var, len_class;
2180
  char *full_name;
2181
 
2182
  len_var = strlen (name);
2183
  len_class = strlen (info->stack->next->type);
2184
  full_name = (char *) xmalloc (len_var + len_class + 3);
2185
  if (! full_name)
2186
    return FALSE;
2187
  sprintf (full_name, "%s::%s", info->stack->next->type, name);
2188
 
2189
  if (! substitute_type (info, full_name))
2190
    {
2191
      free (full_name);
2192
      return FALSE;
2193
    }
2194
 
2195
  if (! prepend_type (info, "static "))
2196
    {
2197
      free (full_name);
2198
      return FALSE;
2199
    }
2200
 
2201
  t = pop_type (info);
2202
  if (t == NULL)
2203
    {
2204
      free (full_name);
2205
      return FALSE;
2206
    }
2207
 
2208
  if (! tg_fix_visibility (info, visibility))
2209
    {
2210
      free (t);
2211
      free (full_name);
2212
      return FALSE;
2213
    }
2214
 
2215
  fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
2216
           name, info->filename, t, info->stack->type,
2217
           visibility_name (visibility));
2218
  free (t);
2219
  free (full_name);
2220
 
2221
  return TRUE;
2222
}
2223
 
2224
/* Add a base class to a class.  */
2225
 
2226
static bfd_boolean
2227
tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
2228
                    bfd_boolean is_virtual, enum debug_visibility visibility)
2229
{
2230
  struct pr_handle *info = (struct pr_handle *) p;
2231
  char *t;
2232
  const char *prefix;
2233
 
2234
  assert (info->stack != NULL && info->stack->next != NULL);
2235
 
2236
  t = pop_type (info);
2237
  if (t == NULL)
2238
    return FALSE;
2239
 
2240
  if (CONST_STRNEQ (t, "class "))
2241
    t += sizeof "class " - 1;
2242
 
2243
  /* Push it back on to take advantage of the prepend_type and
2244
     append_type routines.  */
2245
  if (! push_type (info, t))
2246
    return FALSE;
2247
 
2248
  if (is_virtual)
2249
    {
2250
      if (! prepend_type (info, "virtual "))
2251
        return FALSE;
2252
    }
2253
 
2254
  switch (visibility)
2255
    {
2256
    case DEBUG_VISIBILITY_PUBLIC:
2257
      prefix = "public ";
2258
      break;
2259
    case DEBUG_VISIBILITY_PROTECTED:
2260
      prefix = "protected ";
2261
      break;
2262
    case DEBUG_VISIBILITY_PRIVATE:
2263
      prefix = "private ";
2264
      break;
2265
    default:
2266
      prefix = "/* unknown visibility */ ";
2267
      break;
2268
    }
2269
 
2270
  if (! prepend_type (info, prefix))
2271
    return FALSE;
2272
 
2273
  t = pop_type (info);
2274
  if (t == NULL)
2275
    return FALSE;
2276
 
2277
  if (info->stack->num_parents && ! append_parent (info, ", "))
2278
    return FALSE;
2279
 
2280
  if (! append_parent (info, t))
2281
    return FALSE;
2282
  info->stack->num_parents++;
2283
 
2284
  free (t);
2285
 
2286
  return TRUE;
2287
}
2288
 
2289
/* Add a variant to a method.  */
2290
 
2291
static bfd_boolean
2292
tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
2293
                         enum debug_visibility visibility,
2294
                         bfd_boolean constp, bfd_boolean volatilep,
2295
                         bfd_vma voffset ATTRIBUTE_UNUSED,
2296
                         bfd_boolean context)
2297
{
2298
  struct pr_handle *info = (struct pr_handle *) p;
2299
  char *method_type;
2300
  char *context_type;
2301
  char *method_name;
2302
 
2303
  assert (info->stack != NULL);
2304
  assert (info->stack->next != NULL);
2305
 
2306
  /* Put the const and volatile qualifiers on the type.  */
2307
  if (volatilep)
2308
    {
2309
      if (! append_type (info, " volatile"))
2310
        return FALSE;
2311
    }
2312
  if (constp)
2313
    {
2314
      if (! append_type (info, " const"))
2315
        return FALSE;
2316
    }
2317
 
2318
  method_name = strdup (context ? info->stack->next->next->method
2319
                        : info->stack->next->method);
2320
 
2321
  /* Stick the name of the method into its type.  */
2322
  if (! substitute_type (info, method_name))
2323
    {
2324
      free (method_name);
2325
      return FALSE;
2326
    }
2327
 
2328
  /* Get the type.  */
2329
  method_type = pop_type (info);
2330
  if (method_type == NULL)
2331
    {
2332
      free (method_name);
2333
      return FALSE;
2334
    }
2335
 
2336
  /* Pull off the context type if there is one.  */
2337
  if (! context)
2338
    context_type = NULL;
2339
  else
2340
    {
2341
      context_type = pop_type (info);
2342
      if (context_type == NULL)
2343
        {
2344
          free (method_type);
2345
          free (method_name);
2346
          return FALSE;
2347
        }
2348
    }
2349
 
2350
  /* Now the top of the stack is the class.  */
2351
  if (! tg_fix_visibility (info, visibility))
2352
    {
2353
      free (method_type);
2354
      free (method_name);
2355
      free (context_type);
2356
      return FALSE;
2357
    }
2358
 
2359
  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
2360
           method_name, info->filename, method_type, info->stack->type);
2361
  free (method_type);
2362
  free (method_name);
2363
  free (context_type);
2364
 
2365
  return TRUE;
2366
}
2367
 
2368
/* Add a static variant to a method.  */
2369
 
2370
static bfd_boolean
2371
tg_class_static_method_variant (void *p,
2372
                                const char *physname ATTRIBUTE_UNUSED,
2373
                                enum debug_visibility visibility,
2374
                                bfd_boolean constp, bfd_boolean volatilep)
2375
{
2376
  struct pr_handle *info = (struct pr_handle *) p;
2377
  char *method_type;
2378
  char *method_name;
2379
 
2380
  assert (info->stack != NULL);
2381
  assert (info->stack->next != NULL);
2382
  assert (info->stack->next->method != NULL);
2383
 
2384
  /* Put the const and volatile qualifiers on the type.  */
2385
  if (volatilep)
2386
    {
2387
      if (! append_type (info, " volatile"))
2388
        return FALSE;
2389
    }
2390
  if (constp)
2391
    {
2392
      if (! append_type (info, " const"))
2393
        return FALSE;
2394
    }
2395
 
2396
  /* Mark it as static.  */
2397
  if (! prepend_type (info, "static "))
2398
    return FALSE;
2399
 
2400
  method_name = strdup (info->stack->next->method);
2401
  /* Stick the name of the method into its type.  */
2402
  if (! substitute_type (info, info->stack->next->method))
2403
    {
2404
      free (method_name);
2405
      return FALSE;
2406
    }
2407
 
2408
  /* Get the type.  */
2409
  method_type = pop_type (info);
2410
  if (method_type == NULL)
2411
    {
2412
      free (method_name);
2413
      return FALSE;
2414
    }
2415
 
2416
  /* Now the top of the stack is the class.  */
2417
  if (! tg_fix_visibility (info, visibility))
2418
    {
2419
      free (method_type);
2420
      free (method_name);
2421
      return FALSE;
2422
    }
2423
 
2424
  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
2425
           method_name, info->filename, method_type, info->stack->type,
2426
           visibility_name (visibility));
2427
  free (method_type);
2428
  free (method_name);
2429
 
2430
  return TRUE;
2431
}
2432
 
2433
/* Finish up a class.  */
2434
 
2435
static bfd_boolean
2436
tg_end_class_type (void *p)
2437
{
2438
  struct pr_handle *info = (struct pr_handle *) p;
2439
 
2440
  fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
2441
           info->filename, info->stack->flavor);
2442
  if (info->stack->num_parents)
2443
    {
2444
      fprintf  (info->f, "\tinherits:%s", info->stack->parents);
2445
      free (info->stack->parents);
2446
    }
2447
  fputc ('\n', info->f);
2448
 
2449
  return tg_end_struct_type (p);
2450
}
2451
 
2452
/* Push a type on the stack using a tag name.  */
2453
 
2454
static bfd_boolean
2455
tg_tag_type (void *p, const char *name, unsigned int id,
2456
             enum debug_type_kind kind)
2457
{
2458
  struct pr_handle *info = (struct pr_handle *) p;
2459
  const char *t, *tag;
2460
  char idbuf[20];
2461
 
2462
  switch (kind)
2463
    {
2464
    case DEBUG_KIND_STRUCT:
2465
      t = "struct ";
2466
      break;
2467
    case DEBUG_KIND_UNION:
2468
      t = "union ";
2469
      break;
2470
    case DEBUG_KIND_ENUM:
2471
      t = "enum ";
2472
      break;
2473
    case DEBUG_KIND_CLASS:
2474
      t = "class ";
2475
      break;
2476
    case DEBUG_KIND_UNION_CLASS:
2477
      t = "union class ";
2478
      break;
2479
    default:
2480
      abort ();
2481
      return FALSE;
2482
    }
2483
 
2484
  if (! push_type (info, t))
2485
    return FALSE;
2486
  if (name != NULL)
2487
    tag = name;
2488
  else
2489
    {
2490
      sprintf (idbuf, "%%anon%u", id);
2491
      tag = idbuf;
2492
    }
2493
 
2494
  if (! append_type (info, tag))
2495
    return FALSE;
2496
 
2497
  return TRUE;
2498
}
2499
 
2500
/* Output a typedef.  */
2501
 
2502
static bfd_boolean
2503
tg_typdef (void *p, const char *name)
2504
{
2505
  struct pr_handle *info = (struct pr_handle *) p;
2506
  char *s;
2507
 
2508
  s = pop_type (info);
2509
  if (s == NULL)
2510
    return FALSE;
2511
 
2512
  fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
2513
           info->filename, s);
2514
 
2515
  free (s);
2516
 
2517
  return TRUE;
2518
}
2519
 
2520
/* Output a tag.  The tag should already be in the string on the
2521
   stack, so all we have to do here is print it out.  */
2522
 
2523
static bfd_boolean
2524
tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
2525
{
2526
  struct pr_handle *info = (struct pr_handle *) p;
2527
  char *t;
2528
 
2529
  t = pop_type (info);
2530
  if (t == NULL)
2531
    return FALSE;
2532
  free (t);
2533
 
2534
  return TRUE;
2535
}
2536
 
2537
/* Output an integer constant.  */
2538
 
2539
static bfd_boolean
2540
tg_int_constant (void *p, const char *name, bfd_vma val)
2541
{
2542
  struct pr_handle *info = (struct pr_handle *) p;
2543
  char ab[20];
2544
 
2545
  indent (info);
2546
  print_vma (val, ab, FALSE, FALSE);
2547
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
2548
           name, info->filename, ab);
2549
  return TRUE;
2550
}
2551
 
2552
/* Output a floating point constant.  */
2553
 
2554
static bfd_boolean
2555
tg_float_constant (void *p, const char *name, double val)
2556
{
2557
  struct pr_handle *info = (struct pr_handle *) p;
2558
 
2559
  indent (info);
2560
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
2561
           name, info->filename, val);
2562
  return TRUE;
2563
}
2564
 
2565
/* Output a typed constant.  */
2566
 
2567
static bfd_boolean
2568
tg_typed_constant (void *p, const char *name, bfd_vma val)
2569
{
2570
  struct pr_handle *info = (struct pr_handle *) p;
2571
  char *t;
2572
  char ab[20];
2573
 
2574
  t = pop_type (info);
2575
  if (t == NULL)
2576
    return FALSE;
2577
 
2578
  indent (info);
2579
  print_vma (val, ab, FALSE, FALSE);
2580
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
2581
           name, info->filename, t, ab);
2582
 
2583
  free (t);
2584
 
2585
  return TRUE;
2586
}
2587
 
2588
/* Output a variable.  */
2589
 
2590
static bfd_boolean
2591
tg_variable (void *p, const char *name, enum debug_var_kind kind,
2592
             bfd_vma val ATTRIBUTE_UNUSED)
2593
{
2594
  struct pr_handle *info = (struct pr_handle *) p;
2595
  char *t, *dname, *from_class;
2596
 
2597
  t = pop_type (info);
2598
  if (t == NULL)
2599
    return FALSE;
2600
 
2601
  dname = NULL;
2602
  if (info->demangler)
2603
    dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2604
 
2605
  from_class = NULL;
2606
  if (dname != NULL)
2607
    {
2608
      char *sep;
2609
      sep = strstr (dname, "::");
2610
      if (sep)
2611
        {
2612
          *sep = 0;
2613
          name = sep + 2;
2614
          from_class = dname;
2615
        }
2616
      else
2617
        /* Obscure types as vts and type_info nodes.  */
2618
        name = dname;
2619
    }
2620
 
2621
  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
2622
 
2623
  switch (kind)
2624
    {
2625
    case DEBUG_STATIC:
2626
    case DEBUG_LOCAL_STATIC:
2627
      fprintf (info->f, "\tfile:");
2628
      break;
2629
    case DEBUG_REGISTER:
2630
      fprintf (info->f, "\tregister:");
2631
      break;
2632
    default:
2633
      break;
2634
    }
2635
 
2636
  if (from_class)
2637
    fprintf (info->f, "\tclass:%s", from_class);
2638
 
2639
  if (dname)
2640
    free (dname);
2641
 
2642
  fprintf (info->f, "\n");
2643
 
2644
  free (t);
2645
 
2646
  return TRUE;
2647
}
2648
 
2649
/* Start outputting a function.  */
2650
 
2651
static bfd_boolean
2652
tg_start_function (void *p, const char *name, bfd_boolean global)
2653
{
2654
  struct pr_handle *info = (struct pr_handle *) p;
2655
  char *dname;
2656
 
2657
  if (! global)
2658
    info->stack->flavor = "static";
2659
  else
2660
    info->stack->flavor = NULL;
2661
 
2662
  dname = NULL;
2663
  if (info->demangler)
2664
    dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS);
2665
 
2666
  if (! substitute_type (info, dname ? dname : name))
2667
    return FALSE;
2668
 
2669
  info->stack->method = NULL;
2670
  if (dname != NULL)
2671
    {
2672
      char *sep;
2673
      sep = strstr (dname, "::");
2674
      if (sep)
2675
        {
2676
          info->stack->method = dname;
2677
          *sep = 0;
2678
          name = sep + 2;
2679
        }
2680
      else
2681
        {
2682
          info->stack->method = "";
2683
          name = dname;
2684
        }
2685
      sep = strchr (name, '(');
2686
      if (sep)
2687
        *sep = 0;
2688
      /* Obscure functions as type_info function.  */
2689
    }
2690
 
2691
  info->stack->parents = strdup (name);
2692
 
2693
  if (! info->stack->method && ! append_type (info, "("))
2694
    return FALSE;
2695
 
2696
  info->parameter = 1;
2697
 
2698
  return TRUE;
2699
}
2700
 
2701
/* Output a function parameter.  */
2702
 
2703
static bfd_boolean
2704
tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
2705
                       bfd_vma val ATTRIBUTE_UNUSED)
2706
{
2707
  struct pr_handle *info = (struct pr_handle *) p;
2708
  char *t;
2709
 
2710
  if (kind == DEBUG_PARM_REFERENCE
2711
      || kind == DEBUG_PARM_REF_REG)
2712
    {
2713
      if (! pr_reference_type (p))
2714
        return FALSE;
2715
    }
2716
 
2717
  if (! substitute_type (info, name))
2718
    return FALSE;
2719
 
2720
  t = pop_type (info);
2721
  if (t == NULL)
2722
    return FALSE;
2723
 
2724
  if (! info->stack->method)
2725
    {
2726
      if (info->parameter != 1 && ! append_type (info, ", "))
2727
        return FALSE;
2728
 
2729
      if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
2730
        if (! append_type (info, "register "))
2731
          return FALSE;
2732
 
2733
      if (! append_type (info, t))
2734
        return FALSE;
2735
    }
2736
 
2737
  free (t);
2738
 
2739
  ++info->parameter;
2740
 
2741
  return TRUE;
2742
}
2743
 
2744
/* Start writing out a block.  */
2745
 
2746
static bfd_boolean
2747
tg_start_block (void *p, bfd_vma addr)
2748
{
2749
  struct pr_handle *info = (struct pr_handle *) p;
2750
  char ab[20], kind, *partof;
2751
  char *t;
2752
  bfd_boolean local;
2753
 
2754
  if (info->parameter > 0)
2755
    {
2756
      info->parameter = 0;
2757
 
2758
      /* Delayed name.  */
2759
      fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
2760
      free (info->stack->parents);
2761
 
2762
      print_vma (addr, ab, TRUE, TRUE);
2763
      translate_addresses (info->abfd, ab, info->f, info->syms);
2764
      local = info->stack->flavor != NULL;
2765
      if (info->stack->method && *info->stack->method)
2766
        {
2767
          kind = 'm';
2768
          partof = (char *) info->stack->method;
2769
        }
2770
      else
2771
        {
2772
          kind = 'f';
2773
          partof = NULL;
2774
          if (! info->stack->method && ! append_type (info, ")"))
2775
            return FALSE;
2776
        }
2777
      t = pop_type (info);
2778
      if (t == NULL)
2779
        return FALSE;
2780
      fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
2781
      if (local)
2782
        fputs ("\tfile:", info->f);
2783
      if (partof)
2784
        {
2785
          fprintf (info->f, "\tclass:%s", partof);
2786
          free (partof);
2787
        }
2788
      fputc ('\n', info->f);
2789
    }
2790
 
2791
  return TRUE;
2792
}
2793
 
2794
/* Write out line number information.  */
2795
 
2796
static bfd_boolean
2797
tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED,
2798
           unsigned long lineno ATTRIBUTE_UNUSED,
2799
           bfd_vma addr ATTRIBUTE_UNUSED)
2800
{
2801
  return TRUE;
2802
}
2803
 
2804
/* Finish writing out a block.  */
2805
 
2806
static bfd_boolean
2807
tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
2808
{
2809
  return TRUE;
2810
}
2811
 
2812
/* Convert the visibility value into a human readable name.  */
2813
 
2814
static const char *
2815
visibility_name (enum debug_visibility visibility)
2816
{
2817
  const char *s;
2818
 
2819
  switch (visibility)
2820
    {
2821
    case DEBUG_VISIBILITY_PUBLIC:
2822
      s = "public";
2823
      break;
2824
    case DEBUG_VISIBILITY_PRIVATE:
2825
      s = "private";
2826
      break;
2827
    case DEBUG_VISIBILITY_PROTECTED:
2828
      s = "protected";
2829
      break;
2830
    case DEBUG_VISIBILITY_IGNORE:
2831
      s = "/* ignore */";
2832
      break;
2833
    default:
2834
      abort ();
2835
      return FALSE;
2836
    }
2837
  return s;
2838
}

powered by: WebSVN 2.1.0

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