binutils/prdbg.c

   1 /* prdbg.c -- Print out generic debugging information.
   2    Copyright (C) 1995-2016 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@cygnus.com>.
   4    Tags style generation written by Salvador E. Tropea <set@computer.org>.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* This file prints out the generic debugging information, by
  24    supplying a set of routines to debug_write.  */
  25
  26 #include "sysdep.h"
  27 #include <assert.h>
  28 #include "bfd.h"
  29 #include "libiberty.h"
  30 #include "demangle.h"
  31 #include "debug.h"
  32 #include "budbg.h"
  33
  34 /* This is the structure we use as a handle for these routines.  */
  35
  36 struct pr_handle
  37 {
  38   /* File to print information to.  */
  39   FILE *f;
  40   /* Current indentation level.  */
  41   unsigned int indent;
  42   /* Type stack.  */
  43   struct pr_stack *stack;
  44   /* Parameter number we are about to output.  */
  45   int parameter;
  46   /* The following are used only by the tags code (tg_).  */
  47   /* Name of the file we are using.  */
  48   char *filename;
  49   /* The BFD.  */
  50   bfd *abfd;
  51   /* The symbols table for this BFD.  */
  52   asymbol **syms;
  53   /* Pointer to a function to demangle symbols.  */
  54   char *(*demangler) (bfd *, const char *, int);
  55 };
  56
  57 /* The type stack.  */
  58
  59 struct pr_stack
  60 {
  61   /* Next element on the stack.  */
  62   struct pr_stack *next;
  63   /* This element.  */
  64   char *type;
  65   /* Current visibility of fields if this is a class.  */
  66   enum debug_visibility visibility;
  67   /* Name of the current method we are handling.  */
  68   const char *method;
  69   /* The following are used only by the tags code (tg_).  */
  70   /* Type for the container (struct, union, class, union class).  */
  71   const char *flavor;
  72   /* A comma separated list of parent classes.  */
  73   char *parents;
  74   /* How many parents contains parents.  */
  75   int num_parents;
  76 };
  77
  78 static void indent (struct pr_handle *);
  79 static bfd_boolean push_type (struct pr_handle *, const char *);
  80 static bfd_boolean prepend_type (struct pr_handle *, const char *);
  81 static bfd_boolean append_type (struct pr_handle *, const char *);
  82 static bfd_boolean substitute_type (struct pr_handle *, const char *);
  83 static bfd_boolean indent_type (struct pr_handle *);
  84 static char *pop_type (struct pr_handle *);
  85 static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
  86 static bfd_boolean pr_fix_visibility
  87   (struct pr_handle *, enum debug_visibility);
  88 static bfd_boolean pr_start_compilation_unit (void *, const char *);
  89 static bfd_boolean pr_start_source (void *, const char *);
  90 static bfd_boolean pr_empty_type (void *);
  91 static bfd_boolean pr_void_type (void *);
  92 static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
  93 static bfd_boolean pr_float_type (void *, unsigned int);
  94 static bfd_boolean pr_complex_type (void *, unsigned int);
  95 static bfd_boolean pr_bool_type (void *, unsigned int);
  96 static bfd_boolean pr_enum_type
  97   (void *, const char *, const char **, bfd_signed_vma *);
  98 static bfd_boolean pr_pointer_type (void *);
  99 static bfd_boolean pr_function_type (void *, int, bfd_boolean);
 100 static bfd_boolean pr_reference_type (void *);
 101 static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
 102 static bfd_boolean pr_array_type
 103   (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
 104 static bfd_boolean pr_set_type (void *, bfd_boolean);
 105 static bfd_boolean pr_offset_type (void *);
 106 static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
 107 static bfd_boolean pr_const_type (void *);
 108 static bfd_boolean pr_volatile_type (void *);
 109 static bfd_boolean pr_start_struct_type
 110   (void *, const char *, unsigned int, bfd_boolean, unsigned int);
 111 static bfd_boolean pr_struct_field
 112   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
 113 static bfd_boolean pr_end_struct_type (void *);
 114 static bfd_boolean pr_start_class_type
 115   (void *, const char *, unsigned int, bfd_boolean, unsigned int,
 116    bfd_boolean, bfd_boolean);
 117 static bfd_boolean pr_class_static_member
 118   (void *, const char *, const char *, enum debug_visibility);
 119 static bfd_boolean pr_class_baseclass
 120   (void *, bfd_vma, bfd_boolean, enum debug_visibility);
 121 static bfd_boolean pr_class_start_method (void *, const char *);
 122 static bfd_boolean pr_class_method_variant
 123   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
 124    bfd_vma, bfd_boolean);
 125 static bfd_boolean pr_class_static_method_variant
 126   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
 127 static bfd_boolean pr_class_end_method (void *);
 128 static bfd_boolean pr_end_class_type (void *);
 129 static bfd_boolean pr_typedef_type (void *, const char *);
 130 static bfd_boolean pr_tag_type
 131   (void *, const char *, unsigned int, enum debug_type_kind);
 132 static bfd_boolean pr_typdef (void *, const char *);
 133 static bfd_boolean pr_tag (void *, const char *);
 134 static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
 135 static bfd_boolean pr_float_constant (void *, const char *, double);
 136 static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
 137 static bfd_boolean pr_variable
 138   (void *, const char *, enum debug_var_kind, bfd_vma);
 139 static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
 140 static bfd_boolean pr_function_parameter
 141   (void *, const char *, enum debug_parm_kind, bfd_vma);
 142 static bfd_boolean pr_start_block (void *, bfd_vma);
 143 static bfd_boolean pr_end_block (void *, bfd_vma);
 144 static bfd_boolean pr_end_function (void *);
 145 static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
 146 static bfd_boolean append_parent (struct pr_handle *, const char *);
 147 /* Only used by tg_ code.  */
 148 static bfd_boolean tg_fix_visibility
 149   (struct pr_handle *, enum debug_visibility);
 150 static void find_address_in_section (bfd *, asection *, void *);
 151 static void translate_addresses (bfd *, char *, FILE *, asymbol **);
 152 static const char *visibility_name (enum debug_visibility);
 153 /* Tags style replacements.  */
 154 static bfd_boolean tg_start_compilation_unit (void *, const char *);
 155 static bfd_boolean tg_start_source (void *, const char *);
 156 static bfd_boolean tg_enum_type
 157   (void *, const char *, const char **, bfd_signed_vma *);
 158 static bfd_boolean tg_start_struct_type
 159   (void *, const char *, unsigned int, bfd_boolean, unsigned int);
 160 static bfd_boolean pr_struct_field
 161   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
 162 static bfd_boolean tg_struct_field
 163   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
 164 static bfd_boolean tg_struct_field
 165   (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
 166 static bfd_boolean tg_end_struct_type (void *);
 167 static bfd_boolean tg_start_class_type
 168   (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
 169 static bfd_boolean tg_class_static_member
 170   (void *, const char *, const char *, enum debug_visibility);
 171 static bfd_boolean tg_class_baseclass
 172   (void *, bfd_vma, bfd_boolean, enum debug_visibility);
 173 static bfd_boolean tg_class_method_variant
 174   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
 175 static bfd_boolean tg_class_static_method_variant
 176   (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
 177 static bfd_boolean tg_end_class_type (void *);
 178 static bfd_boolean tg_tag_type
 179   (void *, const char *, unsigned int, enum debug_type_kind);
 180 static bfd_boolean tg_typdef (void *, const char *);
 181 static bfd_boolean tg_tag (void *, const char *);
 182 static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
 183 static bfd_boolean tg_float_constant (void *, const char *, double);
 184 static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
 185 static bfd_boolean tg_variable
 186   (void *, const char *, enum debug_var_kind, bfd_vma);
 187 static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
 188 static bfd_boolean tg_function_parameter
 189   (void *, const char *, enum debug_parm_kind, bfd_vma);
 190 static bfd_boolean tg_start_block (void *, bfd_vma);
 191 static bfd_boolean tg_end_block (void *, bfd_vma);
 192 static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
 193 \f
 194 static const struct debug_write_fns pr_fns =
 195 {
 196   pr_start_compilation_unit,
 197   pr_start_source,
 198   pr_empty_type,
 199   pr_void_type,
 200   pr_int_type,
 201   pr_float_type,
 202   pr_complex_type,
 203   pr_bool_type,
 204   pr_enum_type,
 205   pr_pointer_type,
 206   pr_function_type,
 207   pr_reference_type,
 208   pr_range_type,
 209   pr_array_type,
 210   pr_set_type,
 211   pr_offset_type,
 212   pr_method_type,
 213   pr_const_type,
 214   pr_volatile_type,
 215   pr_start_struct_type,
 216   pr_struct_field,
 217   pr_end_struct_type,
 218   pr_start_class_type,
 219   pr_class_static_member,
 220   pr_class_baseclass,
 221   pr_class_start_method,
 222   pr_class_method_variant,
 223   pr_class_static_method_variant,
 224   pr_class_end_method,
 225   pr_end_class_type,
 226   pr_typedef_type,
 227   pr_tag_type,
 228   pr_typdef,
 229   pr_tag,
 230   pr_int_constant,
 231   pr_float_constant,
 232   pr_typed_constant,
 233   pr_variable,
 234   pr_start_function,
 235   pr_function_parameter,
 236   pr_start_block,
 237   pr_end_block,
 238   pr_end_function,
 239   pr_lineno
 240 };
 241 \f
 242 static const struct debug_write_fns tg_fns =
 243 {
 244   tg_start_compilation_unit,
 245   tg_start_source,
 246   pr_empty_type,                /* Same, push_type.  */
 247   pr_void_type,                 /* Same, push_type.  */
 248   pr_int_type,                  /* Same, push_type.  */
 249   pr_float_type,                /* Same, push_type.  */
 250   pr_complex_type,              /* Same, push_type.  */
 251   pr_bool_type,                 /* Same, push_type.  */
 252   tg_enum_type,
 253   pr_pointer_type,              /* Same, changes to pointer.  */
 254   pr_function_type,             /* Same, push_type.  */
 255   pr_reference_type,            /* Same, changes to reference.  */
 256   pr_range_type,                /* FIXME: What's that?.  */
 257   pr_array_type,                /* Same, push_type.  */
 258   pr_set_type,                  /* FIXME: What's that?.  */
 259   pr_offset_type,               /* FIXME: What's that?.  */
 260   pr_method_type,               /* Same.  */
 261   pr_const_type,                /* Same, changes to const.  */
 262   pr_volatile_type,             /* Same, changes to volatile.  */
 263   tg_start_struct_type,
 264   tg_struct_field,
 265   tg_end_struct_type,
 266   tg_start_class_type,
 267   tg_class_static_member,
 268   tg_class_baseclass,
 269   pr_class_start_method,        /* Same, remembers that's a method.  */
 270   tg_class_method_variant,
 271   tg_class_static_method_variant,
 272   pr_class_end_method,          /* Same, forgets that's a method.  */
 273   tg_end_class_type,
 274   pr_typedef_type,              /* Same, just push type.  */
 275   tg_tag_type,
 276   tg_typdef,
 277   tg_tag,
 278   tg_int_constant,              /* Untested.  */
 279   tg_float_constant,            /* Untested.  */
 280   tg_typed_constant,            /* Untested.  */
 281   tg_variable,
 282   tg_start_function,
 283   tg_function_parameter,
 284   tg_start_block,
 285   tg_end_block,
 286   pr_end_function,              /* Same, does nothing.  */
 287   tg_lineno
 288 };
 289 \f
 290 /* Print out the generic debugging information recorded in dhandle.  */
 291
 292 bfd_boolean
 293 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
 294                       char * (*demangler) (struct bfd *, const char *, int),
 295                       bfd_boolean as_tags)
 296 {
 297   struct pr_handle info;
 298
 299   info.f = f;
 300   info.indent = 0;
 301   info.stack = NULL;
 302   info.parameter = 0;
 303   info.filename = NULL;
 304   info.abfd = abfd;
 305   info.syms = syms;
 306   info.demangler = demangler;
 307
 308   if (as_tags)
 309     {
 310       fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);
 311       fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);
 312       fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);
 313       fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);
 314     }
 315
 316   return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
 317     : debug_write (dhandle, &pr_fns, (void *) & info);
 318 }
 319 \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[22];
 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[22], abu[22];
 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[22], abu[22], 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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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[22];
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 \f
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[22];
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[22];
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[22];
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[22], 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 }