X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fprdbg.c;h=1b376f485fecf04303d39b6240c1475e65e8dfa9;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=e846029de2e2b124d55c4073bbfdfe39d9455613;hpb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;p=deliverable%2Fbinutils-gdb.git

diff --git a/binutils/prdbg.c b/binutils/prdbg.c
index e846029de2..1b376f485f 100644
--- a/binutils/prdbg.c
+++ b/binutils/prdbg.c
@@ -1,12 +1,13 @@
 /* prdbg.c -- Print out generic debugging information.
-   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1995-2020 Free Software Foundation, Inc.
    Written by Ian Lance Taylor <ian@cygnus.com>.
+   Tags style generation written by Salvador E. Tropea <set@computer.org>.
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,18 +17,17 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 /* This file prints out the generic debugging information, by
    supplying a set of routines to debug_write.  */
 
-#include <stdio.h>
+#include "sysdep.h"
 #include <assert.h>
-
 #include "bfd.h"
-#include "bucomm.h"
 #include "libiberty.h"
+#include "demangle.h"
 #include "debug.h"
 #include "budbg.h"
 
@@ -43,6 +43,15 @@ struct pr_handle
   struct pr_stack *stack;
   /* Parameter number we are about to output.  */
   int parameter;
+  /* The following are used only by the tags code (tg_).  */
+  /* Name of the file we are using.  */
+  char *filename;
+  /* The BFD.  */
+  bfd *abfd;
+  /* The symbols table for this BFD.  */
+  asymbol **syms;
+  /* Pointer to a function to demangle symbols.  */
+  char *(*demangler) (bfd *, const char *, int);
 };
 
 /* The type stack.  */
@@ -57,78 +66,131 @@ struct pr_stack
   enum debug_visibility visibility;
   /* Name of the current method we are handling.  */
   const char *method;
+  /* The following are used only by the tags code (tg_).  */
+  /* Type for the container (struct, union, class, union class).  */
+  const char *flavor;
+  /* A comma separated list of parent classes.  */
+  char *parents;
+  /* How many parents contains parents.  */
+  int num_parents;
 };
 
-static void indent PARAMS ((struct pr_handle *));
-static boolean push_type PARAMS ((struct pr_handle *, const char *));
-static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
-static boolean append_type PARAMS ((struct pr_handle *, const char *));
-static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
-static boolean indent_type PARAMS ((struct pr_handle *));
-static char *pop_type PARAMS ((struct pr_handle *));
-static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
-static boolean pr_fix_visibility
-  PARAMS ((struct pr_handle *, enum debug_visibility));
-
-static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
-static boolean pr_start_source PARAMS ((PTR, const char *));
-static boolean pr_empty_type PARAMS ((PTR));
-static boolean pr_void_type PARAMS ((PTR));
-static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
-static boolean pr_float_type PARAMS ((PTR, unsigned int));
-static boolean pr_complex_type PARAMS ((PTR, unsigned int));
-static boolean pr_bool_type PARAMS ((PTR, unsigned int));
-static boolean pr_enum_type
-  PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
-static boolean pr_pointer_type PARAMS ((PTR));
-static boolean pr_function_type PARAMS ((PTR, int, boolean));
-static boolean pr_reference_type PARAMS ((PTR));
-static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
-static boolean pr_array_type
-  PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
-static boolean pr_set_type PARAMS ((PTR, boolean));
-static boolean pr_offset_type PARAMS ((PTR));
-static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
-static boolean pr_const_type PARAMS ((PTR));
-static boolean pr_volatile_type PARAMS ((PTR));
-static boolean pr_start_struct_type
-  PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
-static boolean pr_struct_field
-  PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
-static boolean pr_end_struct_type PARAMS ((PTR));
-static boolean pr_start_class_type
-  PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
-	   boolean));
-static boolean pr_class_static_member
-  PARAMS ((PTR, const char *, const char *, enum debug_visibility));
-static boolean pr_class_baseclass
-  PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
-static boolean pr_class_start_method PARAMS ((PTR, const char *));
-static boolean pr_class_method_variant
-  PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
-	   bfd_vma, boolean));
-static boolean pr_class_static_method_variant
-  PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
-static boolean pr_class_end_method PARAMS ((PTR));
-static boolean pr_end_class_type PARAMS ((PTR));
-static boolean pr_typedef_type PARAMS ((PTR, const char *));
-static boolean pr_tag_type
-  PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
-static boolean pr_typdef PARAMS ((PTR, const char *));
-static boolean pr_tag PARAMS ((PTR, const char *));
-static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_float_constant PARAMS ((PTR, const char *, double));
-static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_variable
-  PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
-static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
-static boolean pr_function_parameter
-  PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
-static boolean pr_start_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_function PARAMS ((PTR));
-static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
-
+static void indent (struct pr_handle *);
+static bfd_boolean push_type (struct pr_handle *, const char *);
+static bfd_boolean prepend_type (struct pr_handle *, const char *);
+static bfd_boolean append_type (struct pr_handle *, const char *);
+static bfd_boolean substitute_type (struct pr_handle *, const char *);
+static bfd_boolean indent_type (struct pr_handle *);
+static char *pop_type (struct pr_handle *);
+static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
+static bfd_boolean pr_fix_visibility
+  (struct pr_handle *, enum debug_visibility);
+static bfd_boolean pr_start_compilation_unit (void *, const char *);
+static bfd_boolean pr_start_source (void *, const char *);
+static bfd_boolean pr_empty_type (void *);
+static bfd_boolean pr_void_type (void *);
+static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
+static bfd_boolean pr_float_type (void *, unsigned int);
+static bfd_boolean pr_complex_type (void *, unsigned int);
+static bfd_boolean pr_bool_type (void *, unsigned int);
+static bfd_boolean pr_enum_type
+  (void *, const char *, const char **, bfd_signed_vma *);
+static bfd_boolean pr_pointer_type (void *);
+static bfd_boolean pr_function_type (void *, int, bfd_boolean);
+static bfd_boolean pr_reference_type (void *);
+static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
+static bfd_boolean pr_array_type
+  (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
+static bfd_boolean pr_set_type (void *, bfd_boolean);
+static bfd_boolean pr_offset_type (void *);
+static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
+static bfd_boolean pr_const_type (void *);
+static bfd_boolean pr_volatile_type (void *);
+static bfd_boolean pr_start_struct_type
+  (void *, const char *, unsigned int, bfd_boolean, unsigned int);
+static bfd_boolean pr_struct_field
+  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bfd_boolean pr_end_struct_type (void *);
+static bfd_boolean pr_start_class_type
+  (void *, const char *, unsigned int, bfd_boolean, unsigned int,
+   bfd_boolean, bfd_boolean);
+static bfd_boolean pr_class_static_member
+  (void *, const char *, const char *, enum debug_visibility);
+static bfd_boolean pr_class_baseclass
+  (void *, bfd_vma, bfd_boolean, enum debug_visibility);
+static bfd_boolean pr_class_start_method (void *, const char *);
+static bfd_boolean pr_class_method_variant
+  (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
+   bfd_vma, bfd_boolean);
+static bfd_boolean pr_class_static_method_variant
+  (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
+static bfd_boolean pr_class_end_method (void *);
+static bfd_boolean pr_end_class_type (void *);
+static bfd_boolean pr_typedef_type (void *, const char *);
+static bfd_boolean pr_tag_type
+  (void *, const char *, unsigned int, enum debug_type_kind);
+static bfd_boolean pr_typdef (void *, const char *);
+static bfd_boolean pr_tag (void *, const char *);
+static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
+static bfd_boolean pr_float_constant (void *, const char *, double);
+static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
+static bfd_boolean pr_variable
+  (void *, const char *, enum debug_var_kind, bfd_vma);
+static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
+static bfd_boolean pr_function_parameter
+  (void *, const char *, enum debug_parm_kind, bfd_vma);
+static bfd_boolean pr_start_block (void *, bfd_vma);
+static bfd_boolean pr_end_block (void *, bfd_vma);
+static bfd_boolean pr_end_function (void *);
+static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
+static bfd_boolean append_parent (struct pr_handle *, const char *);
+/* Only used by tg_ code.  */
+static bfd_boolean tg_fix_visibility
+  (struct pr_handle *, enum debug_visibility);
+static void find_address_in_section (bfd *, asection *, void *);
+static void translate_addresses (bfd *, char *, FILE *, asymbol **);
+static const char *visibility_name (enum debug_visibility);
+/* Tags style replacements.  */
+static bfd_boolean tg_start_compilation_unit (void *, const char *);
+static bfd_boolean tg_start_source (void *, const char *);
+static bfd_boolean tg_enum_type
+  (void *, const char *, const char **, bfd_signed_vma *);
+static bfd_boolean tg_start_struct_type
+  (void *, const char *, unsigned int, bfd_boolean, unsigned int);
+static bfd_boolean pr_struct_field
+  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bfd_boolean tg_struct_field
+  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bfd_boolean tg_struct_field
+  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bfd_boolean tg_end_struct_type (void *);
+static bfd_boolean tg_start_class_type
+  (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
+static bfd_boolean tg_class_static_member
+  (void *, const char *, const char *, enum debug_visibility);
+static bfd_boolean tg_class_baseclass
+  (void *, bfd_vma, bfd_boolean, enum debug_visibility);
+static bfd_boolean tg_class_method_variant
+  (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
+static bfd_boolean tg_class_static_method_variant
+  (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
+static bfd_boolean tg_end_class_type (void *);
+static bfd_boolean tg_tag_type
+  (void *, const char *, unsigned int, enum debug_type_kind);
+static bfd_boolean tg_typdef (void *, const char *);
+static bfd_boolean tg_tag (void *, const char *);
+static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
+static bfd_boolean tg_float_constant (void *, const char *, double);
+static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
+static bfd_boolean tg_variable
+  (void *, const char *, enum debug_var_kind, bfd_vma);
+static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
+static bfd_boolean tg_function_parameter
+  (void *, const char *, enum debug_parm_kind, bfd_vma);
+static bfd_boolean tg_start_block (void *, bfd_vma);
+static bfd_boolean tg_end_block (void *, bfd_vma);
+static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
+
 static const struct debug_write_fns pr_fns =
 {
   pr_start_compilation_unit,
@@ -177,12 +239,62 @@ static const struct debug_write_fns pr_fns =
   pr_lineno
 };
 
+static const struct debug_write_fns tg_fns =
+{
+  tg_start_compilation_unit,
+  tg_start_source,
+  pr_empty_type,		/* Same, push_type.  */
+  pr_void_type,			/* Same, push_type.  */
+  pr_int_type,			/* Same, push_type.  */
+  pr_float_type,		/* Same, push_type.  */
+  pr_complex_type,		/* Same, push_type.  */
+  pr_bool_type,			/* Same, push_type.  */
+  tg_enum_type,
+  pr_pointer_type,		/* Same, changes to pointer.  */
+  pr_function_type,		/* Same, push_type.  */
+  pr_reference_type,		/* Same, changes to reference.  */
+  pr_range_type,		/* FIXME: What's that?.  */
+  pr_array_type,		/* Same, push_type.  */
+  pr_set_type,			/* FIXME: What's that?.  */
+  pr_offset_type,		/* FIXME: What's that?.  */
+  pr_method_type,		/* Same.  */
+  pr_const_type,		/* Same, changes to const.  */
+  pr_volatile_type,		/* Same, changes to volatile.  */
+  tg_start_struct_type,
+  tg_struct_field,
+  tg_end_struct_type,
+  tg_start_class_type,
+  tg_class_static_member,
+  tg_class_baseclass,
+  pr_class_start_method,	/* Same, remembers that's a method.  */
+  tg_class_method_variant,
+  tg_class_static_method_variant,
+  pr_class_end_method,		/* Same, forgets that's a method.  */
+  tg_end_class_type,
+  pr_typedef_type,		/* Same, just push type.  */
+  tg_tag_type,
+  tg_typdef,
+  tg_tag,
+  tg_int_constant,		/* Untested.  */
+  tg_float_constant,		/* Untested.  */
+  tg_typed_constant,		/* Untested.  */
+  tg_variable,
+  tg_start_function,
+  tg_function_parameter,
+  tg_start_block,
+  tg_end_block,
+  pr_end_function,		/* Same, does nothing.  */
+  tg_lineno
+};
+
+static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
+
 /* Print out the generic debugging information recorded in dhandle.  */
 
-boolean
-print_debugging_info (f, dhandle)
-     FILE *f;
-     PTR dhandle;
+bfd_boolean
+print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
+		      char * (*demangler) (struct bfd *, const char *, int),
+		      bfd_boolean as_tags)
 {
   struct pr_handle info;
 
@@ -190,15 +302,27 @@ print_debugging_info (f, dhandle)
   info.indent = 0;
   info.stack = NULL;
   info.parameter = 0;
+  info.filename = NULL;
+  info.abfd = abfd;
+  info.syms = syms;
+  info.demangler = demangler;
+
+  if (as_tags)
+    {
+      fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);
+      fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);
+      fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);
+      fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);
+    }
 
-  return debug_write (dhandle, &pr_fns, (PTR) &info);
+  return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
+    : debug_write (dhandle, &pr_fns, (void *) & info);
 }
 
 /* Indent to the current indentation level.  */
 
 static void
-indent (info)
-     struct pr_handle *info;
+indent (struct pr_handle *info)
 {
   unsigned int i;
 
@@ -208,15 +332,13 @@ indent (info)
 
 /* Push a type on the type stack.  */
 
-static boolean
-push_type (info, type)
-     struct pr_handle *info;
-     const char *type;
+static bfd_boolean
+push_type (struct pr_handle *info, const char *type)
 {
   struct pr_stack *n;
 
   if (type == NULL)
-    return false;
+    return FALSE;
 
   n = (struct pr_stack *) xmalloc (sizeof *n);
   memset (n, 0, sizeof *n);
@@ -227,15 +349,13 @@ push_type (info, type)
   n->next = info->stack;
   info->stack = n;
 
-  return true;
+  return TRUE;
 }
 
 /* Prepend a string onto the type on the top of the type stack.  */
 
-static boolean
-prepend_type (info, s)
-     struct pr_handle *info;
-     const char *s;
+static bfd_boolean
+prepend_type (struct pr_handle *info, const char *s)
 {
   char *n;
 
@@ -246,20 +366,18 @@ prepend_type (info, s)
   free (info->stack->type);
   info->stack->type = n;
 
-  return true;
+  return TRUE;
 }
 
 /* Append a string to the type on the top of the type stack.  */
 
-static boolean
-append_type (info, s)
-     struct pr_handle *info;
-     const char *s;
+static bfd_boolean
+append_type (struct pr_handle *info, const char *s)
 {
   unsigned int len;
 
   if (s == NULL)
-    return false;
+    return FALSE;
 
   assert (info->stack != NULL);
 
@@ -268,17 +386,35 @@ append_type (info, s)
 					 len + strlen (s) + 1);
   strcpy (info->stack->type + len, s);
 
-  return true;
+  return TRUE;
+}
+
+/* Append a string to the parents on the top of the type stack.  */
+
+static bfd_boolean
+append_parent (struct pr_handle *info, const char *s)
+{
+  unsigned int len;
+
+  if (s == NULL)
+    return FALSE;
+
+  assert (info->stack != NULL);
+
+  len = info->stack->parents ? strlen (info->stack->parents) : 0;
+  info->stack->parents = (char *) xrealloc (info->stack->parents,
+					    len + strlen (s) + 1);
+  strcpy (info->stack->parents + len, s);
+
+  return TRUE;
 }
 
 /* We use an underscore to indicate where the name should go in a type
    string.  This function substitutes a string for the underscore.  If
    there is no underscore, the name follows the type.  */
 
-static boolean
-substitute_type (info, s)
-     struct pr_handle *info;
-     const char *s;
+static bfd_boolean
+substitute_type (struct pr_handle *info, const char *s)
 {
   char *u;
 
@@ -298,7 +434,7 @@ substitute_type (info, s)
       free (info->stack->type);
       info->stack->type = n;
 
-      return true;
+      return TRUE;
     }
 
   if (strchr (s, '|') != NULL
@@ -307,11 +443,11 @@ substitute_type (info, s)
     {
       if (! prepend_type (info, "(")
 	  || ! append_type (info, ")"))
-	return false;
+	return FALSE;
     }
 
   if (*s == '\0')
-    return true;
+    return TRUE;
 
   return (append_type (info, " ")
 	  && append_type (info, s));
@@ -319,26 +455,24 @@ substitute_type (info, s)
 
 /* Indent the type at the top of the stack by appending spaces.  */
 
-static boolean
-indent_type (info)
-     struct pr_handle *info;
+static bfd_boolean
+indent_type (struct pr_handle *info)
 {
   unsigned int i;
 
   for (i = 0; i < info->indent; i++)
     {
       if (! append_type (info, " "))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Pop a type from the type stack.  */
 
 static char *
-pop_type (info)
-     struct pr_handle *info;
+pop_type (struct pr_handle *info)
 {
   struct pr_stack *o;
   char *ret;
@@ -356,11 +490,7 @@ pop_type (info)
 /* Print a VMA value into a string.  */
 
 static void
-print_vma (vma, buf, unsignedp, hexp)
-     bfd_vma vma;
-     char *buf;
-     boolean unsignedp;
-     boolean hexp;
+print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
 {
   if (sizeof (vma) <= sizeof (unsigned long))
     {
@@ -371,6 +501,26 @@ print_vma (vma, buf, unsignedp, hexp)
       else
 	sprintf (buf, "%ld", (long) vma);
     }
+#if BFD_HOST_64BIT_LONG_LONG
+  else if (sizeof (vma) <= sizeof (unsigned long long))
+    {
+#ifndef __MSVCRT__
+      if (hexp)
+	sprintf (buf, "0x%llx", (unsigned long long) vma);
+      else if (unsignedp)
+	sprintf (buf, "%llu", (unsigned long long) vma);
+      else
+	sprintf (buf, "%lld", (long long) vma);
+#else
+      if (hexp)
+	sprintf (buf, "0x%I64x", (unsigned long long) vma);
+      else if (unsignedp)
+	sprintf (buf, "%I64u", (unsigned long long) vma);
+      else
+	sprintf (buf, "%I64d", (long long) vma);
+#endif
+    }
+#endif
   else
     {
       buf[0] = '0';
@@ -381,10 +531,8 @@ print_vma (vma, buf, unsignedp, hexp)
 
 /* Start a new compilation unit.  */
 
-static boolean
-pr_start_compilation_unit (p, filename)
-     PTR p;
-     const char *filename;
+static bfd_boolean
+pr_start_compilation_unit (void *p, const char *filename)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -392,15 +540,13 @@ pr_start_compilation_unit (p, filename)
 
   fprintf (info->f, "%s:\n", filename);
 
-  return true;
+  return TRUE;
 }
 
 /* Start a source file within a compilation unit.  */
 
-static boolean
-pr_start_source (p, filename)
-     PTR p;
-     const char *filename;
+static bfd_boolean
+pr_start_source (void *p, const char *filename)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -408,14 +554,13 @@ pr_start_source (p, filename)
 
   fprintf (info->f, " %s:\n", filename);
 
-  return true;
+  return TRUE;
 }
 
 /* Push an empty type onto the type stack.  */
 
-static boolean
-pr_empty_type (p)
-     PTR p;
+static bfd_boolean
+pr_empty_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -424,9 +569,8 @@ pr_empty_type (p)
 
 /* Push a void type onto the type stack.  */
 
-static boolean
-pr_void_type (p)
-     PTR p;
+static bfd_boolean
+pr_void_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -435,14 +579,11 @@ pr_void_type (p)
 
 /* Push an integer type onto the type stack.  */
 
-static boolean
-pr_int_type (p, size, unsignedp)
-     PTR p;
-     unsigned int size;
-     boolean unsignedp;
+static bfd_boolean
+pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[10];
+  char ab[40];
 
   sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
   return push_type (info, ab);
@@ -450,13 +591,11 @@ pr_int_type (p, size, unsignedp)
 
 /* Push a floating type onto the type stack.  */
 
-static boolean
-pr_float_type (p, size)
-     PTR p;
-     unsigned int size;
+static bfd_boolean
+pr_float_type (void *p, unsigned int size)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[10];
+  char ab[40];
 
   if (size == 4)
     return push_type (info, "float");
@@ -469,28 +608,24 @@ pr_float_type (p, size)
 
 /* Push a complex type onto the type stack.  */
 
-static boolean
-pr_complex_type (p, size)
-     PTR p;
-     unsigned int size;
+static bfd_boolean
+pr_complex_type (void *p, unsigned int size)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   if (! pr_float_type (p, size))
-    return false;
+    return FALSE;
 
   return prepend_type (info, "complex ");
 }
 
-/* Push a boolean type onto the type stack.  */
+/* Push a bfd_boolean type onto the type stack.  */
 
-static boolean
-pr_bool_type (p, size)
-     PTR p;
-     unsigned int size;
+static bfd_boolean
+pr_bool_type (void *p, unsigned int size)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[10];
+  char ab[40];
 
   sprintf (ab, "bool%d", size * 8);
 
@@ -499,32 +634,29 @@ pr_bool_type (p, size)
 
 /* Push an enum type onto the type stack.  */
 
-static boolean
-pr_enum_type (p, tag, names, values)
-     PTR p;
-     const char *tag;
-     const char **names;
-     bfd_signed_vma *values;
+static bfd_boolean
+pr_enum_type (void *p, const char *tag, const char **names,
+	      bfd_signed_vma *values)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   unsigned int i;
   bfd_signed_vma val;
 
   if (! push_type (info, "enum "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag)
 	  || ! append_type (info, " "))
-	return false;
+	return FALSE;
     }
   if (! append_type (info, "{ "))
-    return false;
+    return FALSE;
 
   if (names == NULL)
     {
       if (! append_type (info, "/* undefined */"))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -534,20 +666,20 @@ pr_enum_type (p, tag, names, values)
 	  if (i > 0)
 	    {
 	      if (! append_type (info, ", "))
-		return false;
+		return FALSE;
 	    }
 
 	  if (! append_type (info, names[i]))
-	    return false;
+	    return FALSE;
 
 	  if (values[i] != val)
 	    {
-	      char ab[20];
+	      char ab[22];
 
-	      print_vma (values[i], ab, false, false);
+	      print_vma (values[i], ab, FALSE, FALSE);
 	      if (! append_type (info, " = ")
 		  || ! append_type (info, ab))
-		return false;
+		return FALSE;
 	      val = values[i];
 	    }
 
@@ -560,9 +692,8 @@ pr_enum_type (p, tag, names, values)
 
 /* Turn the top type on the stack into a pointer.  */
 
-static boolean
-pr_pointer_type (p)
-     PTR p;
+static bfd_boolean
+pr_pointer_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *s;
@@ -577,11 +708,8 @@ pr_pointer_type (p)
 
 /* Turn the top type on the stack into a function returning that type.  */
 
-static boolean
-pr_function_type (p, argcount, varargs)
-     PTR p;
-     int argcount;
-     boolean varargs;
+static bfd_boolean
+pr_function_type (void *p, int argcount, bfd_boolean varargs)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char **arg_types;
@@ -605,10 +733,16 @@ pr_function_type (p, argcount, varargs)
       for (i = argcount - 1; i >= 0; i--)
 	{
 	  if (! substitute_type (info, ""))
-	    return false;
+	    {
+	      free (arg_types);
+	      return FALSE;
+	    }
 	  arg_types[i] = pop_type (info);
 	  if (arg_types[i] == NULL)
-	    return false;
+	    {
+	      free (arg_types);
+	      return FALSE;
+	    }
 	  len += strlen (arg_types[i]) + 2;
 	}
       if (varargs)
@@ -618,7 +752,7 @@ pr_function_type (p, argcount, varargs)
   /* Now the return type is on the top of the stack.  */
 
   s = (char *) xmalloc (len);
-  strcpy (s, "(|) (");
+  LITSTRCPY (s, "(|) (");
 
   if (argcount < 0)
     strcat (s, "/* unknown */");
@@ -645,18 +779,17 @@ pr_function_type (p, argcount, varargs)
   strcat (s, ")");
 
   if (! substitute_type (info, s))
-    return false;
+    return FALSE;
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Turn the top type on the stack into a reference to that type.  */
 
-static boolean
-pr_reference_type (p)
-     PTR p;
+static bfd_boolean
+pr_reference_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -667,22 +800,19 @@ pr_reference_type (p)
 
 /* Make a range type.  */
 
-static boolean
-pr_range_type (p, lower, upper)
-     PTR p;
-     bfd_signed_vma lower;
-     bfd_signed_vma upper;
+static bfd_boolean
+pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char abl[20], abu[20];
+  char abl[22], abu[22];
 
   assert (info->stack != NULL);
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
-  print_vma (lower, abl, false, false);
-  print_vma (upper, abu, false, false);
+  print_vma (lower, abl, FALSE, FALSE);
+  print_vma (upper, abu, FALSE, FALSE);
 
   return (prepend_type (info, "range (")
 	  && append_type (info, "):")
@@ -693,21 +823,17 @@ pr_range_type (p, lower, upper)
 
 /* Make an array type.  */
 
-/*ARGSUSED*/
-static boolean
-pr_array_type (p, lower, upper, stringp)
-     PTR p;
-     bfd_signed_vma lower;
-     bfd_signed_vma upper;
-     boolean stringp;
+static bfd_boolean
+pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
+	       bfd_boolean stringp)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *range_type;
-  char abl[20], abu[20], ab[50];
+  char abl[22], abu[22], ab[50];
 
   range_type = pop_type (info);
   if (range_type == NULL)
-    return false;
+    return FALSE;
 
   if (lower == 0)
     {
@@ -715,77 +841,73 @@ pr_array_type (p, lower, upper, stringp)
 	sprintf (ab, "|[]");
       else
 	{
-	  print_vma (upper + 1, abu, false, false);
+	  print_vma (upper + 1, abu, FALSE, FALSE);
 	  sprintf (ab, "|[%s]", abu);
 	}
     }
   else
     {
-      print_vma (lower, abl, false, false);
-      print_vma (upper, abu, false, false);
+      print_vma (lower, abl, FALSE, FALSE);
+      print_vma (upper, abu, FALSE, FALSE);
       sprintf (ab, "|[%s:%s]", abl, abu);
     }
 
   if (! substitute_type (info, ab))
-    return false;
+    return FALSE;
 
   if (strcmp (range_type, "int") != 0)
     {
       if (! append_type (info, ":")
 	  || ! append_type (info, range_type))
-	return false;
+	return FALSE;
     }
 
   if (stringp)
     {
       if (! append_type (info, " /* string */"))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Make a set type.  */
 
-/*ARGSUSED*/
-static boolean
-pr_set_type (p, bitstringp)
-     PTR p;
-     boolean bitstringp;
+static bfd_boolean
+pr_set_type (void *p, bfd_boolean bitstringp)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   if (! prepend_type (info, "set { ")
       || ! append_type (info, " }"))
-    return false;
+    return FALSE;
 
   if (bitstringp)
     {
       if (! append_type (info, "/* bitstring */"))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Make an offset type.  */
 
-static boolean
-pr_offset_type (p)
-     PTR p;
+static bfd_boolean
+pr_offset_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   return (substitute_type (info, "")
 	  && prepend_type (info, " ")
@@ -795,12 +917,8 @@ pr_offset_type (p)
 
 /* Make a method type.  */
 
-static boolean
-pr_method_type (p, domain, argcount, varargs)
-     PTR p;
-     boolean domain;
-     int argcount;
-     boolean varargs;
+static bfd_boolean
+pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   unsigned int len;
@@ -815,15 +933,14 @@ pr_method_type (p, domain, argcount, varargs)
   else
     {
       if (! substitute_type (info, ""))
-	return false;
+	return FALSE;
       domain_type = pop_type (info);
       if (domain_type == NULL)
-	return false;
-      if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
+	return FALSE;
+      if (CONST_STRNEQ (domain_type, "class ")
 	  && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
 	domain_type += sizeof "class " - 1;
-      else if (strncmp (domain_type, "union class ",
-			sizeof "union class ") == 0
+      else if (CONST_STRNEQ (domain_type, "union class ")
 	       && (strchr (domain_type + sizeof "union class " - 1, ' ')
 		   == NULL))
 	domain_type += sizeof "union class " - 1;
@@ -843,10 +960,16 @@ pr_method_type (p, domain, argcount, varargs)
       for (i = argcount - 1; i >= 0; i--)
 	{
 	  if (! substitute_type (info, ""))
-	    return false;
+	    {
+	      free (arg_types);
+	      return FALSE;
+	    }
 	  arg_types[i] = pop_type (info);
 	  if (arg_types[i] == NULL)
-	    return false;
+	    {
+	      free (arg_types);
+	      return FALSE;
+	    }
 	  len += strlen (arg_types[i]) + 2;
 	}
       if (varargs)
@@ -887,18 +1010,17 @@ pr_method_type (p, domain, argcount, varargs)
   strcat (s, ")");
 
   if (! substitute_type (info, s))
-    return false;
+    return FALSE;
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Make a const qualified type.  */
 
-static boolean
-pr_const_type (p)
-     PTR p;
+static bfd_boolean
+pr_const_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -907,9 +1029,8 @@ pr_const_type (p)
 
 /* Make a volatile qualified type.  */
 
-static boolean
-pr_volatile_type (p)
-     PTR p;
+static bfd_boolean
+pr_volatile_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -918,24 +1039,20 @@ pr_volatile_type (p)
 
 /* Start accumulating a struct type.  */
 
-static boolean
-pr_start_struct_type (p, tag, id, structp, size)
-     PTR p;
-     const char *tag;
-     unsigned int id;
-     boolean structp;
-     unsigned int size;
+static bfd_boolean
+pr_start_struct_type (void *p, const char *tag, unsigned int id,
+		      bfd_boolean structp, unsigned int size)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   info->indent += 2;
 
   if (! push_type (info, structp ? "struct " : "union "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -943,35 +1060,35 @@ pr_start_struct_type (p, tag, id, structp, size)
 
       sprintf (idbuf, "%%anon%u", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
   if (! append_type (info, " {"))
-    return false;
+    return FALSE;
   if (size != 0 || tag != NULL)
     {
       char ab[30];
 
       if (! append_type (info, " /*"))
-	return false;
+	return FALSE;
 
       if (size != 0)
 	{
 	  sprintf (ab, " size %u", size);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
       if (tag != NULL)
 	{
 	  sprintf (ab, " id %u", id);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
       if (! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
   if (! append_type (info, "\n"))
-    return false;
+    return FALSE;
 
   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
 
@@ -980,21 +1097,17 @@ pr_start_struct_type (p, tag, id, structp, size)
 
 /* Output the visibility of a field in a struct.  */
 
-static boolean
-pr_fix_visibility (info, visibility)
-     struct pr_handle *info;
-     enum debug_visibility visibility;
+static bfd_boolean
+pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
 {
-  const char *s;
+  const char *s = NULL;
   char *t;
   unsigned int len;
 
   assert (info->stack != NULL);
 
   if (info->stack->visibility == visibility)
-    return true;
-
-  assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
+    return TRUE;
 
   switch (visibility)
     {
@@ -1007,9 +1120,12 @@ pr_fix_visibility (info, visibility)
     case DEBUG_VISIBILITY_PROTECTED:
       s = "protected";
       break;
+    case DEBUG_VISIBILITY_IGNORE:
+      s = "/* ignore */";
+      break;
     default:
       abort ();
-      return false;
+      return FALSE;
     }
 
   /* Trim off a trailing space in the struct string, to make the
@@ -1023,64 +1139,59 @@ pr_fix_visibility (info, visibility)
   if (! append_type (info, s)
       || ! append_type (info, ":\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   info->stack->visibility = visibility;
 
-  return true;
+  return TRUE;
 }
 
 /* Add a field to a struct type.  */
 
-static boolean
-pr_struct_field (p, name, bitpos, bitsize, visibility)
-     PTR p;
-     const char *name;
-     bfd_vma bitpos;
-     bfd_vma bitsize;
-     enum debug_visibility visibility;
+static bfd_boolean
+pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
+		 enum debug_visibility visibility)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[20];
+  char ab[22];
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   if (! append_type (info, "; /* "))
-    return false;
+    return FALSE;
 
   if (bitsize != 0)
     {
-      print_vma (bitsize, ab, true, false);
+      print_vma (bitsize, ab, TRUE, FALSE);
       if (! append_type (info, "bitsize ")
 	  || ! append_type (info, ab)
 	  || ! append_type (info, ", "))
-	return false;
+	return FALSE;
     }
 
-  print_vma (bitpos, ab, true, false);
+  print_vma (bitpos, ab, TRUE, FALSE);
   if (! append_type (info, "bitpos ")
       || ! append_type (info, ab)
       || ! append_type (info, " */\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return append_type (info, t);
 }
 
 /* Finish a struct type.  */
 
-static boolean
-pr_end_struct_type (p)
-     PTR p;
+static bfd_boolean
+pr_end_struct_type (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *s;
@@ -1092,25 +1203,20 @@ pr_end_struct_type (p)
 
   /* Change the trailing indentation to have a close brace.  */
   s = info->stack->type + strlen (info->stack->type) - 2;
-  assert (strcmp (s, "  ") == 0);
+  assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
 
   *s++ = '}';
   *s = '\0';
 
-  return true;
+  return TRUE;
 }
 
 /* Start a class type.  */
 
-static boolean
-pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
-     PTR p;
-     const char *tag;
-     unsigned int id;
-     boolean structp;
-     unsigned int size;
-     boolean vptr;
-     boolean ownvptr;
+static bfd_boolean
+pr_start_class_type (void *p, const char *tag, unsigned int id,
+		     bfd_boolean structp, unsigned int size,
+		     bfd_boolean vptr, bfd_boolean ownvptr)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *tv = NULL;
@@ -1121,15 +1227,15 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
     {
       tv = pop_type (info);
       if (tv == NULL)
-	return false;
+	return FALSE;
     }
 
   if (! push_type (info, structp ? "class " : "union class "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -1137,15 +1243,15 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
       sprintf (idbuf, "%%anon%u", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
   if (! append_type (info, " {"))
-    return false;
+    return FALSE;
   if (size != 0 || vptr || ownvptr || tag != NULL)
     {
       if (! append_type (info, " /*"))
-	return false;
+	return FALSE;
 
       if (size != 0)
 	{
@@ -1154,23 +1260,23 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 	  sprintf (ab, "%u", size);
 	  if (! append_type (info, " size ")
 	      || ! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
 
       if (vptr)
 	{
 	  if (! append_type (info, " vtable "))
-	    return false;
+	    return FALSE;
 	  if (ownvptr)
 	    {
 	      if (! append_type (info, "self "))
-		return false;
+		return FALSE;
 	    }
 	  else
 	    {
 	      if (! append_type (info, tv)
 		  || ! append_type (info, " "))
-		return false;
+		return FALSE;
 	    }
 	}
 
@@ -1180,11 +1286,11 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
 	  sprintf (ab, " id %u", id);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
 
       if (! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
 
   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
@@ -1195,72 +1301,66 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
 /* Add a static member to a class.  */
 
-static boolean
-pr_class_static_member (p, name, physname, visibility)
-     PTR p;
-     const char *name;
-     const char *physname;
-     enum debug_visibility visibility;
+static bfd_boolean
+pr_class_static_member (void *p, const char *name, const char *physname,
+			enum debug_visibility visibility)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   if (! prepend_type (info, "static ")
       || ! append_type (info, "; /* ")
       || ! append_type (info, physname)
       || ! append_type (info, " */\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return append_type (info, t);
 }
 
 /* Add a base class to a class.  */
 
-static boolean
-pr_class_baseclass (p, bitpos, virtual, visibility)
-     PTR p;
-     bfd_vma bitpos;
-     boolean virtual;
-     enum debug_visibility visibility;
+static bfd_boolean
+pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
+		    enum debug_visibility visibility)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
   const char *prefix;
-  char ab[20];
+  char ab[22];
   char *s, *l, *n;
 
   assert (info->stack != NULL && info->stack->next != NULL);
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
-  if (strncmp (t, "class ", sizeof "class " - 1) == 0)
+  if (CONST_STRNEQ (t, "class "))
     t += sizeof "class " - 1;
 
   /* Push it back on to take advantage of the prepend_type and
      append_type routines.  */
   if (! push_type (info, t))
-    return false;
+    return FALSE;
 
-  if (virtual)
+  if (is_virtual)
     {
       if (! prepend_type (info, "virtual "))
-	return false;
+	return FALSE;
     }
 
   switch (visibility)
@@ -1280,15 +1380,15 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
     }
 
   if (! prepend_type (info, prefix))
-    return false;
+    return FALSE;
 
   if (bitpos != 0)
     {
-      print_vma (bitpos, ab, true, false);
+      print_vma (bitpos, ab, TRUE, FALSE);
       if (! append_type (info, " /* bitpos ")
 	  || ! append_type (info, ab)
 	  || ! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
 
   /* Now the top of the stack is something like "public A / * bitpos
@@ -1305,11 +1405,11 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
     if (*l == ':')
       break;
   if (! prepend_type (info, l == s ? " : " : ", "))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
   memcpy (n, info->stack->type, s - info->stack->type);
@@ -1321,35 +1421,28 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Start adding a method to a class.  */
 
-static boolean
-pr_class_start_method (p, name)
-     PTR p;
-     const char *name;
+static bfd_boolean
+pr_class_start_method (void *p, const char *name)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   assert (info->stack != NULL);
   info->stack->method = name;
-  return true;
+  return TRUE;
 }
 
 /* Add a variant to a method.  */
 
-static boolean
-pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
-			 context)
-     PTR p;
-     const char *physname;
-     enum debug_visibility visibility;
-     boolean constp;
-     boolean volatilep;
-     bfd_vma voffset;
-     boolean context;
+static bfd_boolean
+pr_class_method_variant (void *p, const char *physname,
+			 enum debug_visibility visibility,
+			 bfd_boolean constp, bfd_boolean volatilep,
+			 bfd_vma voffset, bfd_boolean context)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *method_type;
@@ -1362,12 +1455,12 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
   if (volatilep)
     {
       if (! append_type (info, " volatile"))
-	return false;
+	return FALSE;
     }
   if (constp)
     {
       if (! append_type (info, " const"))
-	return false;
+	return FALSE;
     }
 
   /* Stick the name of the method into its type.  */
@@ -1375,12 +1468,12 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 			 (context
 			  ? info->stack->next->next->method
 			  : info->stack->next->method)))
-    return false;
+    return FALSE;
 
   /* Get the type.  */
   method_type = pop_type (info);
   if (method_type == NULL)
-    return false;
+    return FALSE;
 
   /* Pull off the context type if there is one.  */
   if (! context)
@@ -1389,34 +1482,34 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
     {
       context_type = pop_type (info);
       if (context_type == NULL)
-	return false;
+	return FALSE;
     }
 
   /* Now the top of the stack is the class.  */
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   if (! append_type (info, method_type)
       || ! append_type (info, " /* ")
       || ! append_type (info, physname)
       || ! append_type (info, " "))
-    return false;
+    return FALSE;
   if (context || voffset != 0)
     {
-      char ab[20];
+      char ab[22];
 
       if (context)
 	{
 	  if (! append_type (info, "context ")
 	      || ! append_type (info, context_type)
 	      || ! append_type (info, " "))
-	    return false;
+	    return FALSE;
 	}
-      print_vma (voffset, ab, true, false);
+      print_vma (voffset, ab, TRUE, FALSE);
       if (! append_type (info, "voffset ")
 	  || ! append_type (info, ab))
-	return false;
+	return FALSE;
     }
 
   return (append_type (info, " */;\n")
@@ -1425,13 +1518,10 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 
 /* Add a static variant to a method.  */
 
-static boolean
-pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
-     PTR p;
-     const char *physname;
-     enum debug_visibility visibility;
-     boolean constp;
-     boolean volatilep;
+static bfd_boolean
+pr_class_static_method_variant (void *p, const char *physname,
+				enum debug_visibility visibility,
+				bfd_boolean constp, bfd_boolean volatilep)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *method_type;
@@ -1444,31 +1534,31 @@ pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
   if (volatilep)
     {
       if (! append_type (info, " volatile"))
-	return false;
+	return FALSE;
     }
   if (constp)
     {
       if (! append_type (info, " const"))
-	return false;
+	return FALSE;
     }
 
   /* Mark it as static.  */
   if (! prepend_type (info, "static "))
-    return false;
+    return FALSE;
 
   /* Stick the name of the method into its type.  */
   if (! substitute_type (info, info->stack->next->method))
-    return false;
+    return FALSE;
 
   /* Get the type.  */
   method_type = pop_type (info);
   if (method_type == NULL)
-    return false;
+    return FALSE;
 
   /* Now the top of the stack is the class.  */
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return (append_type (info, method_type)
 	  && append_type (info, " /* ")
@@ -1479,31 +1569,27 @@ pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
 
 /* Finish up a method.  */
 
-static boolean
-pr_class_end_method (p)
-     PTR p;
+static bfd_boolean
+pr_class_end_method (void *p)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   info->stack->method = NULL;
-  return true;
+  return TRUE;
 }
 
 /* Finish up a class.  */
 
-static boolean
-pr_end_class_type (p)
-     PTR p;
+static bfd_boolean
+pr_end_class_type (void *p)
 {
   return pr_end_struct_type (p);
 }
 
 /* Push a type on the stack using a typedef name.  */
 
-static boolean
-pr_typedef_type (p, name)
-     PTR p;
-     const char *name;
+static bfd_boolean
+pr_typedef_type (void *p, const char *name)
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
@@ -1512,16 +1598,13 @@ pr_typedef_type (p, name)
 
 /* Push a type on the stack using a tag name.  */
 
-static boolean
-pr_tag_type (p, name, id, kind)
-     PTR p;
-     const char *name;
-     unsigned int id;
-     enum debug_type_kind kind;
+static bfd_boolean
+pr_tag_type (void *p, const char *name, unsigned int id,
+	     enum debug_type_kind kind)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   const char *t, *tag;
-  char idbuf[20];
+  char idbuf[22];
 
   switch (kind)
     {
@@ -1541,12 +1624,12 @@ pr_tag_type (p, name, id, kind)
       t = "union class ";
       break;
     default:
-      abort ();
-      return false;
+      /* PR 25625: Corrupt input can trigger this case.  */
+      return FALSE;
     }
 
   if (! push_type (info, t))
-    return false;
+    return FALSE;
   if (name != NULL)
     tag = name;
   else
@@ -1556,142 +1639,125 @@ pr_tag_type (p, name, id, kind)
     }
 
   if (! append_type (info, tag))
-    return false;
+    return FALSE;
   if (name != NULL && kind != DEBUG_KIND_ENUM)
     {
       sprintf (idbuf, " /* id %u */", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Output a typedef.  */
 
-static boolean
-pr_typdef (p, name)
-     PTR p;
-     const char *name;
+static bfd_boolean
+pr_typdef (void *p, const char *name)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *s;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   s = pop_type (info);
   if (s == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   fprintf (info->f, "typedef %s;\n", s);
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Output a tag.  The tag should already be in the string on the
    stack, so all we have to do here is print it out.  */
 
-/*ARGSUSED*/
-static boolean
-pr_tag (p, name)
-     PTR p;
-     const char *name;
+static bfd_boolean
+pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   fprintf (info->f, "%s;\n", t);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Output an integer constant.  */
 
-static boolean
-pr_int_constant (p, name, val)
-     PTR p;
-     const char *name;
-     bfd_vma val;
+static bfd_boolean
+pr_int_constant (void *p, const char *name, bfd_vma val)
 {
-  struct pr_handle *info = (struct pr_handle *) info;
-  char ab[20];
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[22];
 
   indent (info);
-  print_vma (val, ab, false, false);
+  print_vma (val, ab, FALSE, FALSE);
   fprintf (info->f, "const int %s = %s;\n", name, ab);
-  return true;
+  return TRUE;
 }
 
 /* Output a floating point constant.  */
 
-static boolean
-pr_float_constant (p, name, val)
-     PTR p;
-     const char *name;
-     double val;
+static bfd_boolean
+pr_float_constant (void *p, const char *name, double val)
 {
-  struct pr_handle *info = (struct pr_handle *) info;
+  struct pr_handle *info = (struct pr_handle *) p;
 
   indent (info);
   fprintf (info->f, "const double %s = %g;\n", name, val);
-  return true;
+  return TRUE;
 }
 
 /* Output a typed constant.  */
 
-static boolean
-pr_typed_constant (p, name, val)
-     PTR p;
-     const char *name;
-     bfd_vma val;
+static bfd_boolean
+pr_typed_constant (void *p, const char *name, bfd_vma val)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
-  char ab[20];
+  char ab[22];
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
-  print_vma (val, ab, false, false);
+  print_vma (val, ab, FALSE, FALSE);
   fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Output a variable.  */
 
-static boolean
-pr_variable (p, name, kind, val)
-     PTR p;
-     const char *name;
-     enum debug_var_kind kind;
-     bfd_vma val;
+static bfd_boolean
+pr_variable (void *p, const char *name, enum debug_var_kind kind,
+	     bfd_vma val)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
-  char ab[20];
+  char ab[22];
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   switch (kind)
@@ -1706,31 +1772,28 @@ pr_variable (p, name, kind, val)
     default:
       break;
     }
-  print_vma (val, ab, true, true);
+  print_vma (val, ab, TRUE, TRUE);
   fprintf (info->f, "%s /* %s */;\n", t, ab);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Start outputting a function.  */
 
-static boolean
-pr_start_function (p, name, global)
-     PTR p;
-     const char *name;
-     boolean global;
+static bfd_boolean
+pr_start_function (void *p, const char *name, bfd_boolean global)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   if (! global)
@@ -1739,35 +1802,32 @@ pr_start_function (p, name, global)
 
   info->parameter = 1;
 
-  return true;
+  return TRUE;
 }
 
 /* Output a function parameter.  */
 
-static boolean
-pr_function_parameter (p, name, kind, val)
-     PTR p;
-     const char *name;
-     enum debug_parm_kind kind;
-     bfd_vma val;
+static bfd_boolean
+pr_function_parameter (void *p, const char *name,
+		       enum debug_parm_kind kind, bfd_vma val)
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
-  char ab[20];
+  char ab[22];
 
   if (kind == DEBUG_PARM_REFERENCE
       || kind == DEBUG_PARM_REF_REG)
     {
       if (! pr_reference_type (p))
-	return false;
+	return FALSE;
     }
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (info->parameter != 1)
     fprintf (info->f, ", ");
@@ -1775,25 +1835,23 @@ pr_function_parameter (p, name, kind, val)
   if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
     fprintf (info->f, "register ");
 
-  print_vma (val, ab, true, true);
+  print_vma (val, ab, TRUE, TRUE);
   fprintf (info->f, "%s /* %s */", t, ab);
 
   free (t);
 
   ++info->parameter;
 
-  return true;
+  return TRUE;
 }
 
 /* Start writing out a block.  */
 
-static boolean
-pr_start_block (p, addr)
-     PTR p;
-     bfd_vma addr;
+static bfd_boolean
+pr_start_block (void *p, bfd_vma addr)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[20];
+  char ab[22];
 
   if (info->parameter > 0)
     {
@@ -1802,58 +1860,980 @@ pr_start_block (p, addr)
     }
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "{ /* %s */\n", ab);
 
   info->indent += 2;
 
-  return true;
+  return TRUE;
 }
 
 /* Write out line number information.  */
 
-static boolean
-pr_lineno (p, filename, lineno, addr)
-     PTR p;
-     const char *filename;
-     unsigned long lineno;
-     bfd_vma addr;
+static bfd_boolean
+pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[20];
+  char ab[22];
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
 
-  return true;
+  return TRUE;
 }
 
 /* Finish writing out a block.  */
 
-static boolean
-pr_end_block (p, addr)
-     PTR p;
-     bfd_vma addr;
+static bfd_boolean
+pr_end_block (void *p, bfd_vma addr)
 {
   struct pr_handle *info = (struct pr_handle *) p;
-  char ab[20];
+  char ab[22];
 
   info->indent -= 2;
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "} /* %s */\n", ab);
 
-  return true;
+  return TRUE;
 }
 
 /* Finish writing out a function.  */
 
-/*ARGSUSED*/
-static boolean
-pr_end_function (p)
-     PTR p;
+static bfd_boolean
+pr_end_function (void *p ATTRIBUTE_UNUSED)
+{
+  return TRUE;
+}
+
+/* Tags style generation functions start here.  */
+
+/* Variables for address to line translation.  */
+static bfd_vma pc;
+static const char *filename;
+static const char *functionname;
+static unsigned int line;
+static bfd_boolean found;
+
+/* Look for an address in a section.  This is called via
+   bfd_map_over_sections.  */
+
+static void
+find_address_in_section (bfd *abfd, asection *section, void *data)
+{
+  bfd_vma vma;
+  bfd_size_type size;
+  asymbol **syms = (asymbol **) data;
+
+  if (found)
+    return;
+
+  if ((bfd_section_flags (section) & SEC_ALLOC) == 0)
+    return;
+
+  vma = bfd_section_vma (section);
+  if (pc < vma)
+    return;
+
+  size = bfd_section_size (section);
+  if (pc >= vma + size)
+    return;
+
+  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
+				 &filename, &functionname, &line);
+}
+
+static void
+translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
+{
+  pc = bfd_scan_vma (addr_hex, NULL, 16);
+  found = FALSE;
+  bfd_map_over_sections (abfd, find_address_in_section, syms);
+
+  if (! found)
+    fprintf (f, "??");
+  else
+    fprintf (f, "%u", line);
+}
+
+/* Start a new compilation unit.  */
+
+static bfd_boolean
+tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  free (info->filename);
+  /* Should it be relative? best way to do it here?.  */
+  info->filename = strdup (fname);
+
+  return TRUE;
+}
+
+/* Start a source file within a compilation unit.  */
+
+static bfd_boolean
+tg_start_source (void *p, const char *fname)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  free (info->filename);
+  /* Should it be relative? best way to do it here?.  */
+  info->filename = strdup (fname);
+
+  return TRUE;
+}
+
+/* Push an enum type onto the type stack.  */
+
+static bfd_boolean
+tg_enum_type (void *p, const char *tag, const char **names,
+	      bfd_signed_vma *values)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  unsigned int i;
+  const char *name;
+  char ab[22];
+
+  if (! pr_enum_type (p, tag, names, values))
+    return FALSE;
+
+  name = tag ? tag : "unknown";
+  /* Generate an entry for the enum.  */
+  if (tag)
+    fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
+	     info->filename, info->stack->type);
+
+  /* Generate entries for the values.  */
+  if (names != NULL)
+    {
+      for (i = 0; names[i] != NULL; i++)
+	{
+	  print_vma (values[i], ab, FALSE, FALSE);
+	  fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
+		   names[i], info->filename, name, ab);
+	}
+    }
+
+  return TRUE;
+}
+
+/* Start accumulating a struct type.  */
+
+static bfd_boolean
+tg_start_struct_type (void *p, const char *tag, unsigned int id,
+		      bfd_boolean structp,
+		      unsigned int size ATTRIBUTE_UNUSED)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  const char *name;
+  char idbuf[20];
+
+  if (tag != NULL)
+    name = tag;
+  else
+    {
+      name = idbuf;
+      sprintf (idbuf, "%%anon%u", id);
+    }
+
+  if (! push_type (info, name))
+    return FALSE;
+
+  info->stack->flavor = structp ? "struct" : "union";
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
+	   info->stack->flavor[0]);
+
+  info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
+
+  return indent_type (info);
+}
+
+/* Output the visibility of a field in a struct.  */
+
+static bfd_boolean
+tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
+{
+  assert (info->stack != NULL);
+
+  if (info->stack->visibility == visibility)
+    return TRUE;
+
+  assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
+
+  info->stack->visibility = visibility;
+
+  return TRUE;
+}
+
+/* Add a field to a struct type.  */
+
+static bfd_boolean
+tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
+		 bfd_vma bitsize ATTRIBUTE_UNUSED,
+		 enum debug_visibility visibility)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  if (! tg_fix_visibility (info, visibility))
+    return FALSE;
+
+  /* It happens, a bug? */
+  if (! name[0])
+    return TRUE;
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
+	   name, info->filename, t, info->stack->flavor, info->stack->type,
+	   visibility_name (visibility));
+
+  return TRUE;
+}
+
+/* Finish a struct type.  */
+
+static bfd_boolean
+tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
+{
+  assert (((struct pr_handle *) p)->stack != NULL);
+
+  return TRUE;
+}
+
+/* Start a class type.  */
+
+static bfd_boolean
+tg_start_class_type (void *p, const char *tag, unsigned int id,
+		     bfd_boolean structp, unsigned int size,
+		     bfd_boolean vptr, bfd_boolean ownvptr)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *tv = NULL;
+  const char *name;
+  char idbuf[20];
+
+  info->indent += 2;
+
+  if (vptr && ! ownvptr)
+    {
+      tv = pop_type (info);
+      if (tv == NULL)
+	return FALSE;
+    }
+
+  if (tag != NULL)
+    name = tag;
+  else
+    {
+      sprintf (idbuf, "%%anon%u", id);
+      name = idbuf;
+    }
+
+  if (! push_type (info, name))
+    return FALSE;
+
+  info->stack->flavor = structp ? "class" : "union class";
+  info->stack->parents = NULL;
+  info->stack->num_parents = 0;
+
+  if (size != 0 || vptr || ownvptr || tag != NULL)
+    {
+      if (vptr)
+	{
+	  if (! append_type (info, " vtable "))
+	    return FALSE;
+	  if (ownvptr)
+	    {
+	      if (! append_type (info, "self "))
+		return FALSE;
+	    }
+	  else
+	    {
+	      if (! append_type (info, tv)
+		  || ! append_type (info, " "))
+		return FALSE;
+	    }
+	}
+    }
+
+  info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
+
+  return TRUE;
+}
+
+/* Add a static member to a class.  */
+
+static bfd_boolean
+tg_class_static_member (void *p, const char *name,
+			const char *physname ATTRIBUTE_UNUSED,
+			enum debug_visibility visibility)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  int len_var, len_class;
+  char *full_name;
+
+  len_var = strlen (name);
+  len_class = strlen (info->stack->next->type);
+  full_name = (char *) xmalloc (len_var + len_class + 3);
+  if (! full_name)
+    return FALSE;
+  sprintf (full_name, "%s::%s", info->stack->next->type, name);
+
+  if (! substitute_type (info, full_name))
+    {
+      free (full_name);
+      return FALSE;
+    }
+
+  if (! prepend_type (info, "static "))
+    {
+      free (full_name);
+      return FALSE;
+    }
+
+  t = pop_type (info);
+  if (t == NULL)
+    {
+      free (full_name);
+      return FALSE;
+    }
+
+  if (! tg_fix_visibility (info, visibility))
+    {
+      free (t);
+      free (full_name);
+      return FALSE;
+    }
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
+	   name, info->filename, t, info->stack->type,
+	   visibility_name (visibility));
+  free (t);
+  free (full_name);
+
+  return TRUE;
+}
+
+/* Add a base class to a class.  */
+
+static bfd_boolean
+tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
+		    bfd_boolean is_virtual, enum debug_visibility visibility)
 {
-  return true;
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  const char *prefix;
+
+  assert (info->stack != NULL && info->stack->next != NULL);
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  if (CONST_STRNEQ (t, "class "))
+    t += sizeof "class " - 1;
+
+  /* Push it back on to take advantage of the prepend_type and
+     append_type routines.  */
+  if (! push_type (info, t))
+    return FALSE;
+
+  if (is_virtual)
+    {
+      if (! prepend_type (info, "virtual "))
+	return FALSE;
+    }
+
+  switch (visibility)
+    {
+    case DEBUG_VISIBILITY_PUBLIC:
+      prefix = "public ";
+      break;
+    case DEBUG_VISIBILITY_PROTECTED:
+      prefix = "protected ";
+      break;
+    case DEBUG_VISIBILITY_PRIVATE:
+      prefix = "private ";
+      break;
+    default:
+      prefix = "/* unknown visibility */ ";
+      break;
+    }
+
+  if (! prepend_type (info, prefix))
+    return FALSE;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  if (info->stack->num_parents && ! append_parent (info, ", "))
+    return FALSE;
+
+  if (! append_parent (info, t))
+    return FALSE;
+  info->stack->num_parents++;
+
+  free (t);
+
+  return TRUE;
+}
+
+/* Add a variant to a method.  */
+
+static bfd_boolean
+tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
+			 enum debug_visibility visibility,
+			 bfd_boolean constp, bfd_boolean volatilep,
+			 bfd_vma voffset ATTRIBUTE_UNUSED,
+			 bfd_boolean context)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *method_type;
+  char *context_type;
+  char *method_name;
+
+  assert (info->stack != NULL);
+  assert (info->stack->next != NULL);
+
+  /* Put the const and volatile qualifiers on the type.  */
+  if (volatilep)
+    {
+      if (! append_type (info, " volatile"))
+	return FALSE;
+    }
+  if (constp)
+    {
+      if (! append_type (info, " const"))
+	return FALSE;
+    }
+
+  method_name = strdup (context ? info->stack->next->next->method
+			: info->stack->next->method);
+
+  /* Stick the name of the method into its type.  */
+  if (! substitute_type (info, method_name))
+    {
+      free (method_name);
+      return FALSE;
+    }
+
+  /* Get the type.  */
+  method_type = pop_type (info);
+  if (method_type == NULL)
+    {
+      free (method_name);
+      return FALSE;
+    }
+
+  /* Pull off the context type if there is one.  */
+  if (! context)
+    context_type = NULL;
+  else
+    {
+      context_type = pop_type (info);
+      if (context_type == NULL)
+	{
+	  free (method_type);
+	  free (method_name);
+	  return FALSE;
+	}
+    }
+
+  /* Now the top of the stack is the class.  */
+  if (! tg_fix_visibility (info, visibility))
+    {
+      free (method_type);
+      free (method_name);
+      free (context_type);
+      return FALSE;
+    }
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
+	   method_name, info->filename, method_type, info->stack->type);
+  free (method_type);
+  free (method_name);
+  free (context_type);
+
+  return TRUE;
+}
+
+/* Add a static variant to a method.  */
+
+static bfd_boolean
+tg_class_static_method_variant (void *p,
+				const char *physname ATTRIBUTE_UNUSED,
+				enum debug_visibility visibility,
+				bfd_boolean constp, bfd_boolean volatilep)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *method_type;
+  char *method_name;
+
+  assert (info->stack != NULL);
+  assert (info->stack->next != NULL);
+  assert (info->stack->next->method != NULL);
+
+  /* Put the const and volatile qualifiers on the type.  */
+  if (volatilep)
+    {
+      if (! append_type (info, " volatile"))
+	return FALSE;
+    }
+  if (constp)
+    {
+      if (! append_type (info, " const"))
+	return FALSE;
+    }
+
+  /* Mark it as static.  */
+  if (! prepend_type (info, "static "))
+    return FALSE;
+
+  method_name = strdup (info->stack->next->method);
+  /* Stick the name of the method into its type.  */
+  if (! substitute_type (info, info->stack->next->method))
+    {
+      free (method_name);
+      return FALSE;
+    }
+
+  /* Get the type.  */
+  method_type = pop_type (info);
+  if (method_type == NULL)
+    {
+      free (method_name);
+      return FALSE;
+    }
+
+  /* Now the top of the stack is the class.  */
+  if (! tg_fix_visibility (info, visibility))
+    {
+      free (method_type);
+      free (method_name);
+      return FALSE;
+    }
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
+	   method_name, info->filename, method_type, info->stack->type,
+	   visibility_name (visibility));
+  free (method_type);
+  free (method_name);
+
+  return TRUE;
+}
+
+/* Finish up a class.  */
+
+static bfd_boolean
+tg_end_class_type (void *p)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
+	   info->filename, info->stack->flavor);
+  if (info->stack->num_parents)
+    {
+      fprintf  (info->f, "\tinherits:%s", info->stack->parents);
+      free (info->stack->parents);
+    }
+  fputc ('\n', info->f);
+
+  return tg_end_struct_type (p);
+}
+
+/* Push a type on the stack using a tag name.  */
+
+static bfd_boolean
+tg_tag_type (void *p, const char *name, unsigned int id,
+	     enum debug_type_kind kind)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  const char *t, *tag;
+  char idbuf[20];
+
+  switch (kind)
+    {
+    case DEBUG_KIND_STRUCT:
+      t = "struct ";
+      break;
+    case DEBUG_KIND_UNION:
+      t = "union ";
+      break;
+    case DEBUG_KIND_ENUM:
+      t = "enum ";
+      break;
+    case DEBUG_KIND_CLASS:
+      t = "class ";
+      break;
+    case DEBUG_KIND_UNION_CLASS:
+      t = "union class ";
+      break;
+    default:
+      abort ();
+      return FALSE;
+    }
+
+  if (! push_type (info, t))
+    return FALSE;
+  if (name != NULL)
+    tag = name;
+  else
+    {
+      sprintf (idbuf, "%%anon%u", id);
+      tag = idbuf;
+    }
+
+  if (! append_type (info, tag))
+    return FALSE;
+
+  return TRUE;
+}
+
+/* Output a typedef.  */
+
+static bfd_boolean
+tg_typdef (void *p, const char *name)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *s;
+
+  s = pop_type (info);
+  if (s == NULL)
+    return FALSE;
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
+	   info->filename, s);
+
+  free (s);
+
+  return TRUE;
+}
+
+/* Output a tag.  The tag should already be in the string on the
+   stack, so all we have to do here is print it out.  */
+
+static bfd_boolean
+tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+  free (t);
+
+  return TRUE;
+}
+
+/* Output an integer constant.  */
+
+static bfd_boolean
+tg_int_constant (void *p, const char *name, bfd_vma val)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[22];
+
+  indent (info);
+  print_vma (val, ab, FALSE, FALSE);
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
+	   name, info->filename, ab);
+  return TRUE;
+}
+
+/* Output a floating point constant.  */
+
+static bfd_boolean
+tg_float_constant (void *p, const char *name, double val)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  indent (info);
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
+	   name, info->filename, val);
+  return TRUE;
+}
+
+/* Output a typed constant.  */
+
+static bfd_boolean
+tg_typed_constant (void *p, const char *name, bfd_vma val)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  char ab[22];
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  indent (info);
+  print_vma (val, ab, FALSE, FALSE);
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
+	   name, info->filename, t, ab);
+
+  free (t);
+
+  return TRUE;
+}
+
+/* Output a variable.  */
+
+static bfd_boolean
+tg_variable (void *p, const char *name, enum debug_var_kind kind,
+	     bfd_vma val ATTRIBUTE_UNUSED)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t, *dname, *from_class;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  dname = NULL;
+  if (info->demangler)
+    dname = info->demangler (info->abfd, name, demangle_flags);
+
+  from_class = NULL;
+  if (dname != NULL)
+    {
+      char *sep;
+      sep = strstr (dname, "::");
+      if (sep)
+	{
+	  *sep = 0;
+	  name = sep + 2;
+	  from_class = dname;
+	}
+      else
+	/* Obscure types as vts and type_info nodes.  */
+	name = dname;
+    }
+
+  fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
+
+  switch (kind)
+    {
+    case DEBUG_STATIC:
+    case DEBUG_LOCAL_STATIC:
+      fprintf (info->f, "\tfile:");
+      break;
+    case DEBUG_REGISTER:
+      fprintf (info->f, "\tregister:");
+      break;
+    default:
+      break;
+    }
+
+  if (from_class)
+    fprintf (info->f, "\tclass:%s", from_class);
+
+  if (dname)
+    free (dname);
+
+  fprintf (info->f, "\n");
+
+  free (t);
+
+  return TRUE;
+}
+
+/* Start outputting a function.  */
+
+static bfd_boolean
+tg_start_function (void *p, const char *name, bfd_boolean global)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *dname;
+
+  if (! global)
+    info->stack->flavor = "static";
+  else
+    info->stack->flavor = NULL;
+
+  dname = NULL;
+  if (info->demangler)
+    dname = info->demangler (info->abfd, name, demangle_flags);
+
+  if (! substitute_type (info, dname ? dname : name))
+    return FALSE;
+
+  info->stack->method = NULL;
+  if (dname != NULL)
+    {
+      char *sep;
+      sep = strstr (dname, "::");
+      if (sep)
+	{
+	  info->stack->method = dname;
+	  *sep = 0;
+	  name = sep + 2;
+	}
+      else
+	{
+	  info->stack->method = "";
+	  name = dname;
+	}
+      sep = strchr (name, '(');
+      if (sep)
+	*sep = 0;
+      /* Obscure functions as type_info function.  */
+    }
+
+  info->stack->parents = strdup (name);
+
+  if (! info->stack->method && ! append_type (info, "("))
+    return FALSE;
+
+  info->parameter = 1;
+
+  return TRUE;
+}
+
+/* Output a function parameter.  */
+
+static bfd_boolean
+tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
+		       bfd_vma val ATTRIBUTE_UNUSED)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  if (kind == DEBUG_PARM_REFERENCE
+      || kind == DEBUG_PARM_REF_REG)
+    {
+      if (! pr_reference_type (p))
+	return FALSE;
+    }
+
+  if (! substitute_type (info, name))
+    return FALSE;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return FALSE;
+
+  if (! info->stack->method)
+    {
+      if (info->parameter != 1 && ! append_type (info, ", "))
+	return FALSE;
+
+      if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
+	if (! append_type (info, "register "))
+	  return FALSE;
+
+      if (! append_type (info, t))
+	return FALSE;
+    }
+
+  free (t);
+
+  ++info->parameter;
+
+  return TRUE;
+}
+
+/* Start writing out a block.  */
+
+static bfd_boolean
+tg_start_block (void *p, bfd_vma addr)
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[22], kind, *partof;
+  char *t;
+  bfd_boolean local;
+
+  if (info->parameter > 0)
+    {
+      info->parameter = 0;
+
+      /* Delayed name.  */
+      fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
+      free (info->stack->parents);
+
+      print_vma (addr, ab, TRUE, TRUE);
+      translate_addresses (info->abfd, ab, info->f, info->syms);
+      local = info->stack->flavor != NULL;
+      if (info->stack->method && *info->stack->method)
+	{
+	  kind = 'm';
+	  partof = (char *) info->stack->method;
+	}
+      else
+	{
+	  kind = 'f';
+	  partof = NULL;
+	  if (! info->stack->method && ! append_type (info, ")"))
+	    return FALSE;
+	}
+      t = pop_type (info);
+      if (t == NULL)
+	return FALSE;
+      fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
+      if (local)
+	fputs ("\tfile:", info->f);
+      if (partof)
+	{
+	  fprintf (info->f, "\tclass:%s", partof);
+	  free (partof);
+	}
+      fputc ('\n', info->f);
+    }
+
+  return TRUE;
+}
+
+/* Write out line number information.  */
+
+static bfd_boolean
+tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED,
+	   unsigned long lineno ATTRIBUTE_UNUSED,
+	   bfd_vma addr ATTRIBUTE_UNUSED)
+{
+  return TRUE;
+}
+
+/* Finish writing out a block.  */
+
+static bfd_boolean
+tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
+{
+  return TRUE;
+}
+
+/* Convert the visibility value into a human readable name.  */
+
+static const char *
+visibility_name (enum debug_visibility visibility)
+{
+  const char *s;
+
+  switch (visibility)
+    {
+    case DEBUG_VISIBILITY_PUBLIC:
+      s = "public";
+      break;
+    case DEBUG_VISIBILITY_PRIVATE:
+      s = "private";
+      break;
+    case DEBUG_VISIBILITY_PROTECTED:
+      s = "protected";
+      break;
+    case DEBUG_VISIBILITY_IGNORE:
+      s = "/* ignore */";
+      break;
+    default:
+      abort ();
+      return FALSE;
+    }
+  return s;
 }