binutils/prdbg.c

   1 /* prdbg.c -- Print out generic debugging information.
   2    Copyright 1995, 1996 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@cygnus.com>.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* This file prints out the generic debugging information, by
  23    supplying a set of routines to debug_write.  */
  24
  25 #include <stdio.h>
  26 #include <assert.h>
  27
  28 #include "bfd.h"
  29 #include "bucomm.h"
  30 #include "libiberty.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 };
  47
  48 /* The type stack.  */
  49
  50 struct pr_stack
  51 {
  52   /* Next element on the stack.  */
  53   struct pr_stack *next;
  54   /* This element.  */
  55   char *type;
  56   /* Current visibility of fields if this is a class.  */
  57   enum debug_visibility visibility;
  58   /* Name of the current method we are handling.  */
  59   const char *method;
  60 };
  61
  62 static void indent PARAMS ((struct pr_handle *));
  63 static boolean push_type PARAMS ((struct pr_handle *, const char *));
  64 static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
  65 static boolean append_type PARAMS ((struct pr_handle *, const char *));
  66 static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
  67 static boolean indent_type PARAMS ((struct pr_handle *));
  68 static char *pop_type PARAMS ((struct pr_handle *));
  69 static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
  70 static boolean pr_fix_visibility
  71   PARAMS ((struct pr_handle *, enum debug_visibility));
  72
  73 static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
  74 static boolean pr_start_source PARAMS ((PTR, const char *));
  75 static boolean pr_empty_type PARAMS ((PTR));
  76 static boolean pr_void_type PARAMS ((PTR));
  77 static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
  78 static boolean pr_float_type PARAMS ((PTR, unsigned int));
  79 static boolean pr_complex_type PARAMS ((PTR, unsigned int));
  80 static boolean pr_bool_type PARAMS ((PTR, unsigned int));
  81 static boolean pr_enum_type
  82   PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
  83 static boolean pr_pointer_type PARAMS ((PTR));
  84 static boolean pr_function_type PARAMS ((PTR, int, boolean));
  85 static boolean pr_reference_type PARAMS ((PTR));
  86 static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
  87 static boolean pr_array_type
  88   PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
  89 static boolean pr_set_type PARAMS ((PTR, boolean));
  90 static boolean pr_offset_type PARAMS ((PTR));
  91 static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
  92 static boolean pr_const_type PARAMS ((PTR));
  93 static boolean pr_volatile_type PARAMS ((PTR));
  94 static boolean pr_start_struct_type
  95   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
  96 static boolean pr_struct_field
  97   PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
  98 static boolean pr_end_struct_type PARAMS ((PTR));
  99 static boolean pr_start_class_type
 100   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
 101            boolean));
 102 static boolean pr_class_static_member
 103   PARAMS ((PTR, const char *, const char *, enum debug_visibility));
 104 static boolean pr_class_baseclass
 105   PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
 106 static boolean pr_class_start_method PARAMS ((PTR, const char *));
 107 static boolean pr_class_method_variant
 108   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
 109            bfd_vma, boolean));
 110 static boolean pr_class_static_method_variant
 111   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
 112 static boolean pr_class_end_method PARAMS ((PTR));
 113 static boolean pr_end_class_type PARAMS ((PTR));
 114 static boolean pr_typedef_type PARAMS ((PTR, const char *));
 115 static boolean pr_tag_type
 116   PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
 117 static boolean pr_typdef PARAMS ((PTR, const char *));
 118 static boolean pr_tag PARAMS ((PTR, const char *));
 119 static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
 120 static boolean pr_float_constant PARAMS ((PTR, const char *, double));
 121 static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
 122 static boolean pr_variable
 123   PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
 124 static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
 125 static boolean pr_function_parameter
 126   PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
 127 static boolean pr_start_block PARAMS ((PTR, bfd_vma));
 128 static boolean pr_end_block PARAMS ((PTR, bfd_vma));
 129 static boolean pr_end_function PARAMS ((PTR));
 130 static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
 131
 132 static const struct debug_write_fns pr_fns =
 133 {
 134   pr_start_compilation_unit,
 135   pr_start_source,
 136   pr_empty_type,
 137   pr_void_type,
 138   pr_int_type,
 139   pr_float_type,
 140   pr_complex_type,
 141   pr_bool_type,
 142   pr_enum_type,
 143   pr_pointer_type,
 144   pr_function_type,
 145   pr_reference_type,
 146   pr_range_type,
 147   pr_array_type,
 148   pr_set_type,
 149   pr_offset_type,
 150   pr_method_type,
 151   pr_const_type,
 152   pr_volatile_type,
 153   pr_start_struct_type,
 154   pr_struct_field,
 155   pr_end_struct_type,
 156   pr_start_class_type,
 157   pr_class_static_member,
 158   pr_class_baseclass,
 159   pr_class_start_method,
 160   pr_class_method_variant,
 161   pr_class_static_method_variant,
 162   pr_class_end_method,
 163   pr_end_class_type,
 164   pr_typedef_type,
 165   pr_tag_type,
 166   pr_typdef,
 167   pr_tag,
 168   pr_int_constant,
 169   pr_float_constant,
 170   pr_typed_constant,
 171   pr_variable,
 172   pr_start_function,
 173   pr_function_parameter,
 174   pr_start_block,
 175   pr_end_block,
 176   pr_end_function,
 177   pr_lineno
 178 };
 179 \f
 180 /* Print out the generic debugging information recorded in dhandle.  */
 181
 182 boolean
 183 print_debugging_info (f, dhandle)
 184      FILE *f;
 185      PTR dhandle;
 186 {
 187   struct pr_handle info;
 188
 189   info.f = f;
 190   info.indent = 0;
 191   info.stack = NULL;
 192   info.parameter = 0;
 193
 194   return debug_write (dhandle, &pr_fns, (PTR) &info);
 195 }
 196 \f
 197 /* Indent to the current indentation level.  */
 198
 199 static void
 200 indent (info)
 201      struct pr_handle *info;
 202 {
 203   unsigned int i;
 204
 205   for (i = 0; i < info->indent; i++)
 206     putc (' ', info->f);
 207 }
 208
 209 /* Push a type on the type stack.  */
 210
 211 static boolean
 212 push_type (info, type)
 213      struct pr_handle *info;
 214      const char *type;
 215 {
 216   struct pr_stack *n;
 217
 218   if (type == NULL)
 219     return false;
 220
 221   n = (struct pr_stack *) xmalloc (sizeof *n);
 222   memset (n, 0, sizeof *n);
 223
 224   n->type = xstrdup (type);
 225   n->visibility = DEBUG_VISIBILITY_IGNORE;
 226   n->method = NULL;
 227   n->next = info->stack;
 228   info->stack = n;
 229
 230   return true;
 231 }
 232
 233 /* Prepend a string onto the type on the top of the type stack.  */
 234
 235 static boolean
 236 prepend_type (info, s)
 237      struct pr_handle *info;
 238      const char *s;
 239 {
 240   char *n;
 241
 242   assert (info->stack != NULL);
 243
 244   n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
 245   sprintf (n, "%s%s", s, info->stack->type);
 246   free (info->stack->type);
 247   info->stack->type = n;
 248
 249   return true;
 250 }
 251
 252 /* Append a string to the type on the top of the type stack.  */
 253
 254 static boolean
 255 append_type (info, s)
 256      struct pr_handle *info;
 257      const char *s;
 258 {
 259   unsigned int len;
 260
 261   if (s == NULL)
 262     return false;
 263
 264   assert (info->stack != NULL);
 265
 266   len = strlen (info->stack->type);
 267   info->stack->type = (char *) xrealloc (info->stack->type,
 268                                          len + strlen (s) + 1);
 269   strcpy (info->stack->type + len, s);
 270
 271   return true;
 272 }
 273
 274 /* We use an underscore to indicate where the name should go in a type
 275    string.  This function substitutes a string for the underscore.  If
 276    there is no underscore, the name follows the type.  */
 277
 278 static boolean
 279 substitute_type (info, s)
 280      struct pr_handle *info;
 281      const char *s;
 282 {
 283   char *u;
 284
 285   assert (info->stack != NULL);
 286
 287   u = strchr (info->stack->type, '|');
 288   if (u != NULL)
 289     {
 290       char *n;
 291
 292       n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
 293
 294       memcpy (n, info->stack->type, u - info->stack->type);
 295       strcpy (n + (u - info->stack->type), s);
 296       strcat (n, u + 1);
 297
 298       free (info->stack->type);
 299       info->stack->type = n;
 300
 301       return true;
 302     }
 303
 304   if (strchr (s, '|') != NULL
 305       && (strchr (info->stack->type, '{') != NULL
 306           || strchr (info->stack->type, '(') != NULL))
 307     {
 308       if (! prepend_type (info, "(")
 309           || ! append_type (info, ")"))
 310         return false;
 311     }
 312
 313   if (*s == '\0')
 314     return true;
 315
 316   return (append_type (info, " ")
 317           && append_type (info, s));
 318 }
 319
 320 /* Indent the type at the top of the stack by appending spaces.  */
 321
 322 static boolean
 323 indent_type (info)
 324      struct pr_handle *info;
 325 {
 326   unsigned int i;
 327
 328   for (i = 0; i < info->indent; i++)
 329     {
 330       if (! append_type (info, " "))
 331         return false;
 332     }
 333
 334   return true;
 335 }
 336
 337 /* Pop a type from the type stack.  */
 338
 339 static char *
 340 pop_type (info)
 341      struct pr_handle *info;
 342 {
 343   struct pr_stack *o;
 344   char *ret;
 345
 346   assert (info->stack != NULL);
 347
 348   o = info->stack;
 349   info->stack = o->next;
 350   ret = o->type;
 351   free (o);
 352
 353   return ret;
 354 }
 355
 356 /* Print a VMA value into a string.  */
 357
 358 static void
 359 print_vma (vma, buf, unsignedp, hexp)
 360      bfd_vma vma;
 361      char *buf;
 362      boolean unsignedp;
 363      boolean hexp;
 364 {
 365   if (sizeof (vma) <= sizeof (unsigned long))
 366     {
 367       if (hexp)
 368         sprintf (buf, "0x%lx", (unsigned long) vma);
 369       else if (unsignedp)
 370         sprintf (buf, "%lu", (unsigned long) vma);
 371       else
 372         sprintf (buf, "%ld", (long) vma);
 373     }
 374   else
 375     {
 376       buf[0] = '0';
 377       buf[1] = 'x';
 378       sprintf_vma (buf + 2, vma);
 379     }
 380 }
 381 \f
 382 /* Start a new compilation unit.  */
 383
 384 static boolean
 385 pr_start_compilation_unit (p, filename)
 386      PTR p;
 387      const char *filename;
 388 {
 389   struct pr_handle *info = (struct pr_handle *) p;
 390
 391   assert (info->indent == 0);
 392
 393   fprintf (info->f, "%s:\n", filename);
 394
 395   return true;
 396 }
 397
 398 /* Start a source file within a compilation unit.  */
 399
 400 static boolean
 401 pr_start_source (p, filename)
 402      PTR p;
 403      const char *filename;
 404 {
 405   struct pr_handle *info = (struct pr_handle *) p;
 406
 407   assert (info->indent == 0);
 408
 409   fprintf (info->f, " %s:\n", filename);
 410
 411   return true;
 412 }
 413
 414 /* Push an empty type onto the type stack.  */
 415
 416 static boolean
 417 pr_empty_type (p)
 418      PTR p;
 419 {
 420   struct pr_handle *info = (struct pr_handle *) p;
 421
 422   return push_type (info, "<undefined>");
 423 }
 424
 425 /* Push a void type onto the type stack.  */
 426
 427 static boolean
 428 pr_void_type (p)
 429      PTR p;
 430 {
 431   struct pr_handle *info = (struct pr_handle *) p;
 432
 433   return push_type (info, "void");
 434 }
 435
 436 /* Push an integer type onto the type stack.  */
 437
 438 static boolean
 439 pr_int_type (p, size, unsignedp)
 440      PTR p;
 441      unsigned int size;
 442      boolean unsignedp;
 443 {
 444   struct pr_handle *info = (struct pr_handle *) p;
 445   char ab[10];
 446
 447   sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
 448   return push_type (info, ab);
 449 }
 450
 451 /* Push a floating type onto the type stack.  */
 452
 453 static boolean
 454 pr_float_type (p, size)
 455      PTR p;
 456      unsigned int size;
 457 {
 458   struct pr_handle *info = (struct pr_handle *) p;
 459   char ab[10];
 460
 461   if (size == 4)
 462     return push_type (info, "float");
 463   else if (size == 8)
 464     return push_type (info, "double");
 465
 466   sprintf (ab, "float%d", size * 8);
 467   return push_type (info, ab);
 468 }
 469
 470 /* Push a complex type onto the type stack.  */
 471
 472 static boolean
 473 pr_complex_type (p, size)
 474      PTR p;
 475      unsigned int size;
 476 {
 477   struct pr_handle *info = (struct pr_handle *) p;
 478
 479   if (! pr_float_type (p, size))
 480     return false;
 481
 482   return prepend_type (info, "complex ");
 483 }
 484
 485 /* Push a boolean type onto the type stack.  */
 486
 487 static boolean
 488 pr_bool_type (p, size)
 489      PTR p;
 490      unsigned int size;
 491 {
 492   struct pr_handle *info = (struct pr_handle *) p;
 493   char ab[10];
 494
 495   sprintf (ab, "bool%d", size * 8);
 496
 497   return push_type (info, ab);
 498 }
 499
 500 /* Push an enum type onto the type stack.  */
 501
 502 static boolean
 503 pr_enum_type (p, tag, names, values)
 504      PTR p;
 505      const char *tag;
 506      const char **names;
 507      bfd_signed_vma *values;
 508 {
 509   struct pr_handle *info = (struct pr_handle *) p;
 510   unsigned int i;
 511   bfd_signed_vma val;
 512
 513   if (! push_type (info, "enum "))
 514     return false;
 515   if (tag != NULL)
 516     {
 517       if (! append_type (info, tag)
 518           || ! append_type (info, " "))
 519         return false;
 520     }
 521   if (! append_type (info, "{ "))
 522     return false;
 523
 524   if (names == NULL)
 525     {
 526       if (! append_type (info, "/* undefined */"))
 527         return false;
 528     }
 529   else
 530     {
 531       val = 0;
 532       for (i = 0; names[i] != NULL; i++)
 533         {
 534           if (i > 0)
 535             {
 536               if (! append_type (info, ", "))
 537                 return false;
 538             }
 539
 540           if (! append_type (info, names[i]))
 541             return false;
 542
 543           if (values[i] != val)
 544             {
 545               char ab[20];
 546
 547               print_vma (values[i], ab, false, false);
 548               if (! append_type (info, " = ")
 549                   || ! append_type (info, ab))
 550                 return false;
 551               val = values[i];
 552             }
 553
 554           ++val;
 555         }
 556     }
 557
 558   return append_type (info, " }");
 559 }
 560
 561 /* Turn the top type on the stack into a pointer.  */
 562
 563 static boolean
 564 pr_pointer_type (p)
 565      PTR p;
 566 {
 567   struct pr_handle *info = (struct pr_handle *) p;
 568   char *s;
 569
 570   assert (info->stack != NULL);
 571
 572   s = strchr (info->stack->type, '|');
 573   if (s != NULL && s[1] == '[')
 574     return substitute_type (info, "(*|)");
 575   return substitute_type (info, "*|");
 576 }
 577
 578 /* Turn the top type on the stack into a function returning that type.  */
 579
 580 static boolean
 581 pr_function_type (p, argcount, varargs)
 582      PTR p;
 583      int argcount;
 584      boolean varargs;
 585 {
 586   struct pr_handle *info = (struct pr_handle *) p;
 587   char **arg_types;
 588   unsigned int len;
 589   char *s;
 590
 591   assert (info->stack != NULL);
 592
 593   len = 10;
 594
 595   if (argcount <= 0)
 596     {
 597       arg_types = NULL;
 598       len += 15;
 599     }
 600   else
 601     {
 602       int i;
 603
 604       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
 605       for (i = argcount - 1; i >= 0; i--)
 606         {
 607           if (! substitute_type (info, ""))
 608             return false;
 609           arg_types[i] = pop_type (info);
 610           if (arg_types[i] == NULL)
 611             return false;
 612           len += strlen (arg_types[i]) + 2;
 613         }
 614       if (varargs)
 615         len += 5;
 616     }
 617
 618   /* Now the return type is on the top of the stack.  */
 619
 620   s = (char *) xmalloc (len);
 621   strcpy (s, "(|) (");
 622
 623   if (argcount < 0)
 624     strcat (s, "/* unknown */");
 625   else
 626     {
 627       int i;
 628
 629       for (i = 0; i < argcount; i++)
 630         {
 631           if (i > 0)
 632             strcat (s, ", ");
 633           strcat (s, arg_types[i]);
 634         }
 635       if (varargs)
 636         {
 637           if (i > 0)
 638             strcat (s, ", ");
 639           strcat (s, "...");
 640         }
 641       if (argcount > 0)
 642         free (arg_types);
 643     }
 644
 645   strcat (s, ")");
 646
 647   if (! substitute_type (info, s))
 648     return false;
 649
 650   free (s);
 651
 652   return true;
 653 }
 654
 655 /* Turn the top type on the stack into a reference to that type.  */
 656
 657 static boolean
 658 pr_reference_type (p)
 659      PTR p;
 660 {
 661   struct pr_handle *info = (struct pr_handle *) p;
 662
 663   assert (info->stack != NULL);
 664
 665   return substitute_type (info, "&|");
 666 }
 667
 668 /* Make a range type.  */
 669
 670 static boolean
 671 pr_range_type (p, lower, upper)
 672      PTR p;
 673      bfd_signed_vma lower;
 674      bfd_signed_vma upper;
 675 {
 676   struct pr_handle *info = (struct pr_handle *) p;
 677   char abl[20], abu[20];
 678
 679   assert (info->stack != NULL);
 680
 681   if (! substitute_type (info, ""))
 682     return false;
 683
 684   print_vma (lower, abl, false, false);
 685   print_vma (upper, abu, false, false);
 686
 687   return (prepend_type (info, "range (")
 688           && append_type (info, "):")
 689           && append_type (info, abl)
 690           && append_type (info, ":")
 691           && append_type (info, abu));
 692 }
 693
 694 /* Make an array type.  */
 695
 696 /*ARGSUSED*/
 697 static boolean
 698 pr_array_type (p, lower, upper, stringp)
 699      PTR p;
 700      bfd_signed_vma lower;
 701      bfd_signed_vma upper;
 702      boolean stringp;
 703 {
 704   struct pr_handle *info = (struct pr_handle *) p;
 705   char *range_type;
 706   char abl[20], abu[20], ab[50];
 707
 708   range_type = pop_type (info);
 709   if (range_type == NULL)
 710     return false;
 711
 712   if (lower == 0)
 713     {
 714       if (upper == -1)
 715         sprintf (ab, "|[]");
 716       else
 717         {
 718           print_vma (upper + 1, abu, false, false);
 719           sprintf (ab, "|[%s]", abu);
 720         }
 721     }
 722   else
 723     {
 724       print_vma (lower, abl, false, false);
 725       print_vma (upper, abu, false, false);
 726       sprintf (ab, "|[%s:%s]", abl, abu);
 727     }
 728
 729   if (! substitute_type (info, ab))
 730     return false;
 731
 732   if (strcmp (range_type, "int") != 0)
 733     {
 734       if (! append_type (info, ":")
 735           || ! append_type (info, range_type))
 736         return false;
 737     }
 738
 739   if (stringp)
 740     {
 741       if (! append_type (info, " /* string */"))
 742         return false;
 743     }
 744
 745   return true;
 746 }
 747
 748 /* Make a set type.  */
 749
 750 /*ARGSUSED*/
 751 static boolean
 752 pr_set_type (p, bitstringp)
 753      PTR p;
 754      boolean bitstringp;
 755 {
 756   struct pr_handle *info = (struct pr_handle *) p;
 757
 758   if (! substitute_type (info, ""))
 759     return false;
 760
 761   if (! prepend_type (info, "set { ")
 762       || ! append_type (info, " }"))
 763     return false;
 764
 765   if (bitstringp)
 766     {
 767       if (! append_type (info, "/* bitstring */"))
 768         return false;
 769     }
 770
 771   return true;
 772 }
 773
 774 /* Make an offset type.  */
 775
 776 static boolean
 777 pr_offset_type (p)
 778      PTR p;
 779 {
 780   struct pr_handle *info = (struct pr_handle *) p;
 781   char *t;
 782
 783   if (! substitute_type (info, ""))
 784     return false;
 785
 786   t = pop_type (info);
 787   if (t == NULL)
 788     return false;
 789
 790   return (substitute_type (info, "")
 791           && prepend_type (info, " ")
 792           && prepend_type (info, t)
 793           && append_type (info, "::|"));
 794 }
 795
 796 /* Make a method type.  */
 797
 798 static boolean
 799 pr_method_type (p, domain, argcount, varargs)
 800      PTR p;
 801      boolean domain;
 802      int argcount;
 803      boolean varargs;
 804 {
 805   struct pr_handle *info = (struct pr_handle *) p;
 806   unsigned int len;
 807   char *domain_type;
 808   char **arg_types;
 809   char *s;
 810
 811   len = 10;
 812
 813   if (! domain)
 814     domain_type = NULL;
 815   else
 816     {
 817       if (! substitute_type (info, ""))
 818         return false;
 819       domain_type = pop_type (info);
 820       if (domain_type == NULL)
 821         return false;
 822       if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
 823           && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
 824         domain_type += sizeof "class " - 1;
 825       else if (strncmp (domain_type, "union class ",
 826                         sizeof "union class ") == 0
 827                && (strchr (domain_type + sizeof "union class " - 1, ' ')
 828                    == NULL))
 829         domain_type += sizeof "union class " - 1;
 830       len += strlen (domain_type);
 831     }
 832
 833   if (argcount <= 0)
 834     {
 835       arg_types = NULL;
 836       len += 15;
 837     }
 838   else
 839     {
 840       int i;
 841
 842       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
 843       for (i = argcount - 1; i >= 0; i--)
 844         {
 845           if (! substitute_type (info, ""))
 846             return false;
 847           arg_types[i] = pop_type (info);
 848           if (arg_types[i] == NULL)
 849             return false;
 850           len += strlen (arg_types[i]) + 2;
 851         }
 852       if (varargs)
 853         len += 5;
 854     }
 855
 856   /* Now the return type is on the top of the stack.  */
 857
 858   s = (char *) xmalloc (len);
 859   if (! domain)
 860     *s = '\0';
 861   else
 862     strcpy (s, domain_type);
 863   strcat (s, "::| (");
 864
 865   if (argcount < 0)
 866     strcat (s, "/* unknown */");
 867   else
 868     {
 869       int i;
 870
 871       for (i = 0; i < argcount; i++)
 872         {
 873           if (i > 0)
 874             strcat (s, ", ");
 875           strcat (s, arg_types[i]);
 876         }
 877       if (varargs)
 878         {
 879           if (i > 0)
 880             strcat (s, ", ");
 881           strcat (s, "...");
 882         }
 883       if (argcount > 0)
 884         free (arg_types);
 885     }
 886
 887   strcat (s, ")");
 888
 889   if (! substitute_type (info, s))
 890     return false;
 891
 892   free (s);
 893
 894   return true;
 895 }
 896
 897 /* Make a const qualified type.  */
 898
 899 static boolean
 900 pr_const_type (p)
 901      PTR p;
 902 {
 903   struct pr_handle *info = (struct pr_handle *) p;
 904
 905   return substitute_type (info, "const |");
 906 }
 907
 908 /* Make a volatile qualified type.  */
 909
 910 static boolean
 911 pr_volatile_type (p)
 912      PTR p;
 913 {
 914   struct pr_handle *info = (struct pr_handle *) p;
 915
 916   return substitute_type (info, "volatile |");
 917 }
 918
 919 /* Start accumulating a struct type.  */
 920
 921 static boolean
 922 pr_start_struct_type (p, tag, id, structp, size)
 923      PTR p;
 924      const char *tag;
 925      unsigned int id;
 926      boolean structp;
 927      unsigned int size;
 928 {
 929   struct pr_handle *info = (struct pr_handle *) p;
 930
 931   info->indent += 2;
 932
 933   if (! push_type (info, structp ? "struct " : "union "))
 934     return false;
 935   if (tag != NULL)
 936     {
 937       if (! append_type (info, tag))
 938         return false;
 939     }
 940   else
 941     {
 942       char idbuf[20];
 943
 944       sprintf (idbuf, "%%anon%u", id);
 945       if (! append_type (info, idbuf))
 946         return false;
 947     }
 948
 949   if (! append_type (info, " {"))
 950     return false;
 951   if (size != 0 || tag != NULL)
 952     {
 953       char ab[30];
 954
 955       if (! append_type (info, " /*"))
 956         return false;
 957
 958       if (size != 0)
 959         {
 960           sprintf (ab, " size %u", size);
 961           if (! append_type (info, ab))
 962             return false;
 963         }
 964       if (tag != NULL)
 965         {
 966           sprintf (ab, " id %u", id);
 967           if (! append_type (info, ab))
 968             return false;
 969         }
 970       if (! append_type (info, " */"))
 971         return false;
 972     }
 973   if (! append_type (info, "\n"))
 974     return false;
 975
 976   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
 977
 978   return indent_type (info);
 979 }
 980
 981 /* Output the visibility of a field in a struct.  */
 982
 983 static boolean
 984 pr_fix_visibility (info, visibility)
 985      struct pr_handle *info;
 986      enum debug_visibility visibility;
 987 {
 988   const char *s = NULL;
 989   char *t;
 990   unsigned int len;
 991
 992   assert (info->stack != NULL);
 993
 994   if (info->stack->visibility == visibility)
 995     return true;
 996
 997   assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
 998
 999   switch (visibility)
1000     {
1001     case DEBUG_VISIBILITY_PUBLIC:
1002       s = "public";
1003       break;
1004     case DEBUG_VISIBILITY_PRIVATE:
1005       s = "private";
1006       break;
1007     case DEBUG_VISIBILITY_PROTECTED:
1008       s = "protected";
1009       break;
1010     case DEBUG_VISIBILITY_IGNORE:
1011       s = "/* ignore */";
1012       break;
1013     default:
1014       abort ();
1015       return false;
1016     }
1017
1018   /* Trim off a trailing space in the struct string, to make the
1019      output look a bit better, then stick on the visibility string.  */
1020
1021   t = info->stack->type;
1022   len = strlen (t);
1023   assert (t[len - 1] == ' ');
1024   t[len - 1] = '\0';
1025
1026   if (! append_type (info, s)
1027       || ! append_type (info, ":\n")
1028       || ! indent_type (info))
1029     return false;
1030
1031   info->stack->visibility = visibility;
1032
1033   return true;
1034 }
1035
1036 /* Add a field to a struct type.  */
1037
1038 static boolean
1039 pr_struct_field (p, name, bitpos, bitsize, visibility)
1040      PTR p;
1041      const char *name;
1042      bfd_vma bitpos;
1043      bfd_vma bitsize;
1044      enum debug_visibility visibility;
1045 {
1046   struct pr_handle *info = (struct pr_handle *) p;
1047   char ab[20];
1048   char *t;
1049
1050   if (! substitute_type (info, name))
1051     return false;
1052
1053   if (! append_type (info, "; /* "))
1054     return false;
1055
1056   if (bitsize != 0)
1057     {
1058       print_vma (bitsize, ab, true, false);
1059       if (! append_type (info, "bitsize ")
1060           || ! append_type (info, ab)
1061           || ! append_type (info, ", "))
1062         return false;
1063     }
1064
1065   print_vma (bitpos, ab, true, false);
1066   if (! append_type (info, "bitpos ")
1067       || ! append_type (info, ab)
1068       || ! append_type (info, " */\n")
1069       || ! indent_type (info))
1070     return false;
1071
1072   t = pop_type (info);
1073   if (t == NULL)
1074     return false;
1075
1076   if (! pr_fix_visibility (info, visibility))
1077     return false;
1078
1079   return append_type (info, t);
1080 }
1081
1082 /* Finish a struct type.  */
1083
1084 static boolean
1085 pr_end_struct_type (p)
1086      PTR p;
1087 {
1088   struct pr_handle *info = (struct pr_handle *) p;
1089   char *s;
1090
1091   assert (info->stack != NULL);
1092   assert (info->indent >= 2);
1093
1094   info->indent -= 2;
1095
1096   /* Change the trailing indentation to have a close brace.  */
1097   s = info->stack->type + strlen (info->stack->type) - 2;
1098   assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1099
1100   *s++ = '}';
1101   *s = '\0';
1102
1103   return true;
1104 }
1105
1106 /* Start a class type.  */
1107
1108 static boolean
1109 pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
1110      PTR p;
1111      const char *tag;
1112      unsigned int id;
1113      boolean structp;
1114      unsigned int size;
1115      boolean vptr;
1116      boolean ownvptr;
1117 {
1118   struct pr_handle *info = (struct pr_handle *) p;
1119   char *tv = NULL;
1120
1121   info->indent += 2;
1122
1123   if (vptr && ! ownvptr)
1124     {
1125       tv = pop_type (info);
1126       if (tv == NULL)
1127         return false;
1128     }
1129
1130   if (! push_type (info, structp ? "class " : "union class "))
1131     return false;
1132   if (tag != NULL)
1133     {
1134       if (! append_type (info, tag))
1135         return false;
1136     }
1137   else
1138     {
1139       char idbuf[20];
1140
1141       sprintf (idbuf, "%%anon%u", id);
1142       if (! append_type (info, idbuf))
1143         return false;
1144     }
1145
1146   if (! append_type (info, " {"))
1147     return false;
1148   if (size != 0 || vptr || ownvptr || tag != NULL)
1149     {
1150       if (! append_type (info, " /*"))
1151         return false;
1152
1153       if (size != 0)
1154         {
1155           char ab[20];
1156
1157           sprintf (ab, "%u", size);
1158           if (! append_type (info, " size ")
1159               || ! append_type (info, ab))
1160             return false;
1161         }
1162
1163       if (vptr)
1164         {
1165           if (! append_type (info, " vtable "))
1166             return false;
1167           if (ownvptr)
1168             {
1169               if (! append_type (info, "self "))
1170                 return false;
1171             }
1172           else
1173             {
1174               if (! append_type (info, tv)
1175                   || ! append_type (info, " "))
1176                 return false;
1177             }
1178         }
1179
1180       if (tag != NULL)
1181         {
1182           char ab[30];
1183
1184           sprintf (ab, " id %u", id);
1185           if (! append_type (info, ab))
1186             return false;
1187         }
1188
1189       if (! append_type (info, " */"))
1190         return false;
1191     }
1192
1193   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1194
1195   return (append_type (info, "\n")
1196           && indent_type (info));
1197 }
1198
1199 /* Add a static member to a class.  */
1200
1201 static boolean
1202 pr_class_static_member (p, name, physname, visibility)
1203      PTR p;
1204      const char *name;
1205      const char *physname;
1206      enum debug_visibility visibility;
1207 {
1208   struct pr_handle *info = (struct pr_handle *) p;
1209   char *t;
1210
1211   if (! substitute_type (info, name))
1212     return false;
1213
1214   if (! prepend_type (info, "static ")
1215       || ! append_type (info, "; /* ")
1216       || ! append_type (info, physname)
1217       || ! append_type (info, " */\n")
1218       || ! indent_type (info))
1219     return false;
1220
1221   t = pop_type (info);
1222   if (t == NULL)
1223     return false;
1224
1225   if (! pr_fix_visibility (info, visibility))
1226     return false;
1227
1228   return append_type (info, t);
1229 }
1230
1231 /* Add a base class to a class.  */
1232
1233 static boolean
1234 pr_class_baseclass (p, bitpos, virtual, visibility)
1235      PTR p;
1236      bfd_vma bitpos;
1237      boolean virtual;
1238      enum debug_visibility visibility;
1239 {
1240   struct pr_handle *info = (struct pr_handle *) p;
1241   char *t;
1242   const char *prefix;
1243   char ab[20];
1244   char *s, *l, *n;
1245
1246   assert (info->stack != NULL && info->stack->next != NULL);
1247
1248   if (! substitute_type (info, ""))
1249     return false;
1250
1251   t = pop_type (info);
1252   if (t == NULL)
1253     return false;
1254
1255   if (strncmp (t, "class ", sizeof "class " - 1) == 0)
1256     t += sizeof "class " - 1;
1257
1258   /* Push it back on to take advantage of the prepend_type and
1259      append_type routines.  */
1260   if (! push_type (info, t))
1261     return false;
1262
1263   if (virtual)
1264     {
1265       if (! prepend_type (info, "virtual "))
1266         return false;
1267     }
1268
1269   switch (visibility)
1270     {
1271     case DEBUG_VISIBILITY_PUBLIC:
1272       prefix = "public ";
1273       break;
1274     case DEBUG_VISIBILITY_PROTECTED:
1275       prefix = "protected ";
1276       break;
1277     case DEBUG_VISIBILITY_PRIVATE:
1278       prefix = "private ";
1279       break;
1280     default:
1281       prefix = "/* unknown visibility */ ";
1282       break;
1283     }
1284
1285   if (! prepend_type (info, prefix))
1286     return false;
1287
1288   if (bitpos != 0)
1289     {
1290       print_vma (bitpos, ab, true, false);
1291       if (! append_type (info, " /* bitpos ")
1292           || ! append_type (info, ab)
1293           || ! append_type (info, " */"))
1294         return false;
1295     }
1296
1297   /* Now the top of the stack is something like "public A / * bitpos
1298      10 * /".  The next element on the stack is something like "class
1299      xx { / * size 8 * /\n...".  We want to substitute the top of the
1300      stack in before the {.  */
1301   s = strchr (info->stack->next->type, '{');
1302   assert (s != NULL);
1303   --s;
1304
1305   /* If there is already a ':', then we already have a baseclass, and
1306      we must append this one after a comma.  */
1307   for (l = info->stack->next->type; l != s; l++)
1308     if (*l == ':')
1309       break;
1310   if (! prepend_type (info, l == s ? " : " : ", "))
1311     return false;
1312
1313   t = pop_type (info);
1314   if (t == NULL)
1315     return false;
1316
1317   n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1318   memcpy (n, info->stack->type, s - info->stack->type);
1319   strcpy (n + (s - info->stack->type), t);
1320   strcat (n, s);
1321
1322   free (info->stack->type);
1323   info->stack->type = n;
1324
1325   free (t);
1326
1327   return true;
1328 }
1329
1330 /* Start adding a method to a class.  */
1331
1332 static boolean
1333 pr_class_start_method (p, name)
1334      PTR p;
1335      const char *name;
1336 {
1337   struct pr_handle *info = (struct pr_handle *) p;
1338
1339   assert (info->stack != NULL);
1340   info->stack->method = name;
1341   return true;
1342 }
1343
1344 /* Add a variant to a method.  */
1345
1346 static boolean
1347 pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
1348                          context)
1349      PTR p;
1350      const char *physname;
1351      enum debug_visibility visibility;
1352      boolean constp;
1353      boolean volatilep;
1354      bfd_vma voffset;
1355      boolean context;
1356 {
1357   struct pr_handle *info = (struct pr_handle *) p;
1358   char *method_type;
1359   char *context_type;
1360
1361   assert (info->stack != NULL);
1362   assert (info->stack->next != NULL);
1363
1364   /* Put the const and volatile qualifiers on the type.  */
1365   if (volatilep)
1366     {
1367       if (! append_type (info, " volatile"))
1368         return false;
1369     }
1370   if (constp)
1371     {
1372       if (! append_type (info, " const"))
1373         return false;
1374     }
1375
1376   /* Stick the name of the method into its type.  */
1377   if (! substitute_type (info,
1378                          (context
1379                           ? info->stack->next->next->method
1380                           : info->stack->next->method)))
1381     return false;
1382
1383   /* Get the type.  */
1384   method_type = pop_type (info);
1385   if (method_type == NULL)
1386     return false;
1387
1388   /* Pull off the context type if there is one.  */
1389   if (! context)
1390     context_type = NULL;
1391   else
1392     {
1393       context_type = pop_type (info);
1394       if (context_type == NULL)
1395         return false;
1396     }
1397
1398   /* Now the top of the stack is the class.  */
1399
1400   if (! pr_fix_visibility (info, visibility))
1401     return false;
1402
1403   if (! append_type (info, method_type)
1404       || ! append_type (info, " /* ")
1405       || ! append_type (info, physname)
1406       || ! append_type (info, " "))
1407     return false;
1408   if (context || voffset != 0)
1409     {
1410       char ab[20];
1411
1412       if (context)
1413         {
1414           if (! append_type (info, "context ")
1415               || ! append_type (info, context_type)
1416               || ! append_type (info, " "))
1417             return false;
1418         }
1419       print_vma (voffset, ab, true, false);
1420       if (! append_type (info, "voffset ")
1421           || ! append_type (info, ab))
1422         return false;
1423     }
1424
1425   return (append_type (info, " */;\n")
1426           && indent_type (info));
1427 }
1428
1429 /* Add a static variant to a method.  */
1430
1431 static boolean
1432 pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
1433      PTR p;
1434      const char *physname;
1435      enum debug_visibility visibility;
1436      boolean constp;
1437      boolean volatilep;
1438 {
1439   struct pr_handle *info = (struct pr_handle *) p;
1440   char *method_type;
1441
1442   assert (info->stack != NULL);
1443   assert (info->stack->next != NULL);
1444   assert (info->stack->next->method != NULL);
1445
1446   /* Put the const and volatile qualifiers on the type.  */
1447   if (volatilep)
1448     {
1449       if (! append_type (info, " volatile"))
1450         return false;
1451     }
1452   if (constp)
1453     {
1454       if (! append_type (info, " const"))
1455         return false;
1456     }
1457
1458   /* Mark it as static.  */
1459   if (! prepend_type (info, "static "))
1460     return false;
1461
1462   /* Stick the name of the method into its type.  */
1463   if (! substitute_type (info, info->stack->next->method))
1464     return false;
1465
1466   /* Get the type.  */
1467   method_type = pop_type (info);
1468   if (method_type == NULL)
1469     return false;
1470
1471   /* Now the top of the stack is the class.  */
1472
1473   if (! pr_fix_visibility (info, visibility))
1474     return false;
1475
1476   return (append_type (info, method_type)
1477           && append_type (info, " /* ")
1478           && append_type (info, physname)
1479           && append_type (info, " */;\n")
1480           && indent_type (info));
1481 }
1482
1483 /* Finish up a method.  */
1484
1485 static boolean
1486 pr_class_end_method (p)
1487      PTR p;
1488 {
1489   struct pr_handle *info = (struct pr_handle *) p;
1490
1491   info->stack->method = NULL;
1492   return true;
1493 }
1494
1495 /* Finish up a class.  */
1496
1497 static boolean
1498 pr_end_class_type (p)
1499      PTR p;
1500 {
1501   return pr_end_struct_type (p);
1502 }
1503
1504 /* Push a type on the stack using a typedef name.  */
1505
1506 static boolean
1507 pr_typedef_type (p, name)
1508      PTR p;
1509      const char *name;
1510 {
1511   struct pr_handle *info = (struct pr_handle *) p;
1512
1513   return push_type (info, name);
1514 }
1515
1516 /* Push a type on the stack using a tag name.  */
1517
1518 static boolean
1519 pr_tag_type (p, name, id, kind)
1520      PTR p;
1521      const char *name;
1522      unsigned int id;
1523      enum debug_type_kind kind;
1524 {
1525   struct pr_handle *info = (struct pr_handle *) p;
1526   const char *t, *tag;
1527   char idbuf[20];
1528
1529   switch (kind)
1530     {
1531     case DEBUG_KIND_STRUCT:
1532       t = "struct ";
1533       break;
1534     case DEBUG_KIND_UNION:
1535       t = "union ";
1536       break;
1537     case DEBUG_KIND_ENUM:
1538       t = "enum ";
1539       break;
1540     case DEBUG_KIND_CLASS:
1541       t = "class ";
1542       break;
1543     case DEBUG_KIND_UNION_CLASS:
1544       t = "union class ";
1545       break;
1546     default:
1547       abort ();
1548       return false;
1549     }
1550
1551   if (! push_type (info, t))
1552     return false;
1553   if (name != NULL)
1554     tag = name;
1555   else
1556     {
1557       sprintf (idbuf, "%%anon%u", id);
1558       tag = idbuf;
1559     }
1560
1561   if (! append_type (info, tag))
1562     return false;
1563   if (name != NULL && kind != DEBUG_KIND_ENUM)
1564     {
1565       sprintf (idbuf, " /* id %u */", id);
1566       if (! append_type (info, idbuf))
1567         return false;
1568     }
1569
1570   return true;
1571 }
1572
1573 /* Output a typedef.  */
1574
1575 static boolean
1576 pr_typdef (p, name)
1577      PTR p;
1578      const char *name;
1579 {
1580   struct pr_handle *info = (struct pr_handle *) p;
1581   char *s;
1582
1583   if (! substitute_type (info, name))
1584     return false;
1585
1586   s = pop_type (info);
1587   if (s == NULL)
1588     return false;
1589
1590   indent (info);
1591   fprintf (info->f, "typedef %s;\n", s);
1592
1593   free (s);
1594
1595   return true;
1596 }
1597
1598 /* Output a tag.  The tag should already be in the string on the
1599    stack, so all we have to do here is print it out.  */
1600
1601 /*ARGSUSED*/
1602 static boolean
1603 pr_tag (p, name)
1604      PTR p;
1605      const char *name ATTRIBUTE_UNUSED;
1606 {
1607   struct pr_handle *info = (struct pr_handle *) p;
1608   char *t;
1609
1610   t = pop_type (info);
1611   if (t == NULL)
1612     return false;
1613
1614   indent (info);
1615   fprintf (info->f, "%s;\n", t);
1616
1617   free (t);
1618
1619   return true;
1620 }
1621
1622 /* Output an integer constant.  */
1623
1624 static boolean
1625 pr_int_constant (p, name, val)
1626      PTR p;
1627      const char *name;
1628      bfd_vma val;
1629 {
1630   struct pr_handle *info = (struct pr_handle *) p;
1631   char ab[20];
1632
1633   indent (info);
1634   print_vma (val, ab, false, false);
1635   fprintf (info->f, "const int %s = %s;\n", name, ab);
1636   return true;
1637 }
1638
1639 /* Output a floating point constant.  */
1640
1641 static boolean
1642 pr_float_constant (p, name, val)
1643      PTR p;
1644      const char *name;
1645      double val;
1646 {
1647   struct pr_handle *info = (struct pr_handle *) p;
1648
1649   indent (info);
1650   fprintf (info->f, "const double %s = %g;\n", name, val);
1651   return true;
1652 }
1653
1654 /* Output a typed constant.  */
1655
1656 static boolean
1657 pr_typed_constant (p, name, val)
1658      PTR p;
1659      const char *name;
1660      bfd_vma val;
1661 {
1662   struct pr_handle *info = (struct pr_handle *) p;
1663   char *t;
1664   char ab[20];
1665
1666   t = pop_type (info);
1667   if (t == NULL)
1668     return false;
1669
1670   indent (info);
1671   print_vma (val, ab, false, false);
1672   fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1673
1674   free (t);
1675
1676   return true;
1677 }
1678
1679 /* Output a variable.  */
1680
1681 static boolean
1682 pr_variable (p, name, kind, val)
1683      PTR p;
1684      const char *name;
1685      enum debug_var_kind kind;
1686      bfd_vma val;
1687 {
1688   struct pr_handle *info = (struct pr_handle *) p;
1689   char *t;
1690   char ab[20];
1691
1692   if (! substitute_type (info, name))
1693     return false;
1694
1695   t = pop_type (info);
1696   if (t == NULL)
1697     return false;
1698
1699   indent (info);
1700   switch (kind)
1701     {
1702     case DEBUG_STATIC:
1703     case DEBUG_LOCAL_STATIC:
1704       fprintf (info->f, "static ");
1705       break;
1706     case DEBUG_REGISTER:
1707       fprintf (info->f, "register ");
1708       break;
1709     default:
1710       break;
1711     }
1712   print_vma (val, ab, true, true);
1713   fprintf (info->f, "%s /* %s */;\n", t, ab);
1714
1715   free (t);
1716
1717   return true;
1718 }
1719
1720 /* Start outputting a function.  */
1721
1722 static boolean
1723 pr_start_function (p, name, global)
1724      PTR p;
1725      const char *name;
1726      boolean global;
1727 {
1728   struct pr_handle *info = (struct pr_handle *) p;
1729   char *t;
1730
1731   if (! substitute_type (info, name))
1732     return false;
1733
1734   t = pop_type (info);
1735   if (t == NULL)
1736     return false;
1737
1738   indent (info);
1739   if (! global)
1740     fprintf (info->f, "static ");
1741   fprintf (info->f, "%s (", t);
1742
1743   info->parameter = 1;
1744
1745   return true;
1746 }
1747
1748 /* Output a function parameter.  */
1749
1750 static boolean
1751 pr_function_parameter (p, name, kind, val)
1752      PTR p;
1753      const char *name;
1754      enum debug_parm_kind kind;
1755      bfd_vma val;
1756 {
1757   struct pr_handle *info = (struct pr_handle *) p;
1758   char *t;
1759   char ab[20];
1760
1761   if (kind == DEBUG_PARM_REFERENCE
1762       || kind == DEBUG_PARM_REF_REG)
1763     {
1764       if (! pr_reference_type (p))
1765         return false;
1766     }
1767
1768   if (! substitute_type (info, name))
1769     return false;
1770
1771   t = pop_type (info);
1772   if (t == NULL)
1773     return false;
1774
1775   if (info->parameter != 1)
1776     fprintf (info->f, ", ");
1777
1778   if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1779     fprintf (info->f, "register ");
1780
1781   print_vma (val, ab, true, true);
1782   fprintf (info->f, "%s /* %s */", t, ab);
1783
1784   free (t);
1785
1786   ++info->parameter;
1787
1788   return true;
1789 }
1790
1791 /* Start writing out a block.  */
1792
1793 static boolean
1794 pr_start_block (p, addr)
1795      PTR p;
1796      bfd_vma addr;
1797 {
1798   struct pr_handle *info = (struct pr_handle *) p;
1799   char ab[20];
1800
1801   if (info->parameter > 0)
1802     {
1803       fprintf (info->f, ")\n");
1804       info->parameter = 0;
1805     }
1806
1807   indent (info);
1808   print_vma (addr, ab, true, true);
1809   fprintf (info->f, "{ /* %s */\n", ab);
1810
1811   info->indent += 2;
1812
1813   return true;
1814 }
1815
1816 /* Write out line number information.  */
1817
1818 static boolean
1819 pr_lineno (p, filename, lineno, addr)
1820      PTR p;
1821      const char *filename;
1822      unsigned long lineno;
1823      bfd_vma addr;
1824 {
1825   struct pr_handle *info = (struct pr_handle *) p;
1826   char ab[20];
1827
1828   indent (info);
1829   print_vma (addr, ab, true, true);
1830   fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1831
1832   return true;
1833 }
1834
1835 /* Finish writing out a block.  */
1836
1837 static boolean
1838 pr_end_block (p, addr)
1839      PTR p;
1840      bfd_vma addr;
1841 {
1842   struct pr_handle *info = (struct pr_handle *) p;
1843   char ab[20];
1844
1845   info->indent -= 2;
1846
1847   indent (info);
1848   print_vma (addr, ab, true, true);
1849   fprintf (info->f, "} /* %s */\n", ab);
1850
1851   return true;
1852 }
1853
1854 /* Finish writing out a function.  */
1855
1856 /*ARGSUSED*/
1857 static boolean
1858 pr_end_function (p)
1859      PTR p ATTRIBUTE_UNUSED;
1860 {
1861   return true;
1862 }