binutils/prdbg.c

   1 /* prdbg.c -- Print out generic debugging information.
   2    Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009  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 \f
 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 \f
 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 \f
 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 \f
 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 \f
 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 \f
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 *fname 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 (fname);
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 *fname)
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 (fname);
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 *fname 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 }