19990502 sourceware importbinu_ss_19990502

1 files changed, 1862 insertions, 0 deletions

diff --git a/binutils/prdbg.c b/binutils/prdbg.c
new file mode 100644
index 0000000..958cbd2
--- /dev/null
+++ b/binutils/prdbg.c
@@ -0,0 +1,1862 @@
+/* prdbg.c -- Print out generic debugging information.
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+   Written by Ian Lance Taylor <ian@cygnus.com>.
+
+   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
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   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.  */
+
+/* This file prints out the generic debugging information, by
+   supplying a set of routines to debug_write.  */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "bfd.h"
+#include "bucomm.h"
+#include "libiberty.h"
+#include "debug.h"
+#include "budbg.h"
+
+/* This is the structure we use as a handle for these routines.  */
+
+struct pr_handle
+{
+  /* File to print information to.  */
+  FILE *f;
+  /* Current indentation level.  */
+  unsigned int indent;
+  /* Type stack.  */
+  struct pr_stack *stack;
+  /* Parameter number we are about to output.  */
+  int parameter;
+};
+
+/* The type stack.  */
+
+struct pr_stack
+{
+  /* Next element on the stack.  */
+  struct pr_stack *next;
+  /* This element.  */
+  char *type;
+  /* Current visibility of fields if this is a class.  */
+  enum debug_visibility visibility;
+  /* Name of the current method we are handling.  */
+  const char *method;
+};
+
+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 const struct debug_write_fns pr_fns =
+{
+  pr_start_compilation_unit,
+  pr_start_source,
+  pr_empty_type,
+  pr_void_type,
+  pr_int_type,
+  pr_float_type,
+  pr_complex_type,
+  pr_bool_type,
+  pr_enum_type,
+  pr_pointer_type,
+  pr_function_type,
+  pr_reference_type,
+  pr_range_type,
+  pr_array_type,
+  pr_set_type,
+  pr_offset_type,
+  pr_method_type,
+  pr_const_type,
+  pr_volatile_type,
+  pr_start_struct_type,
+  pr_struct_field,
+  pr_end_struct_type,
+  pr_start_class_type,
+  pr_class_static_member,
+  pr_class_baseclass,
+  pr_class_start_method,
+  pr_class_method_variant,
+  pr_class_static_method_variant,
+  pr_class_end_method,
+  pr_end_class_type,
+  pr_typedef_type,
+  pr_tag_type,
+  pr_typdef,
+  pr_tag,
+  pr_int_constant,
+  pr_float_constant,
+  pr_typed_constant,
+  pr_variable,
+  pr_start_function,
+  pr_function_parameter,
+  pr_start_block,
+  pr_end_block,
+  pr_end_function,
+  pr_lineno
+};
+
+/* Print out the generic debugging information recorded in dhandle.  */
+
+boolean
+print_debugging_info (f, dhandle)
+     FILE *f;
+     PTR dhandle;
+{
+  struct pr_handle info;
+
+  info.f = f;
+  info.indent = 0;
+  info.stack = NULL;
+  info.parameter = 0;
+
+  return debug_write (dhandle, &pr_fns, (PTR) &info);
+}
+
+/* Indent to the current indentation level.  */
+
+static void
+indent (info)
+     struct pr_handle *info;
+{
+  unsigned int i;
+
+  for (i = 0; i < info->indent; i++)
+    putc (' ', info->f);
+}
+
+/* Push a type on the type stack.  */
+
+static boolean
+push_type (info, type)
+     struct pr_handle *info;
+     const char *type;
+{
+  struct pr_stack *n;
+
+  if (type == NULL)
+    return false;
+
+  n = (struct pr_stack *) xmalloc (sizeof *n);
+  memset (n, 0, sizeof *n);
+
+  n->type = xstrdup (type);
+  n->visibility = DEBUG_VISIBILITY_IGNORE;
+  n->method = NULL;
+  n->next = info->stack;
+  info->stack = n;
+
+  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;
+{
+  char *n;
+
+  assert (info->stack != NULL);
+
+  n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
+  sprintf (n, "%s%s", s, info->stack->type);
+  free (info->stack->type);
+  info->stack->type = n;
+
+  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;
+{
+  unsigned int len;
+
+  if (s == NULL)
+    return false;
+
+  assert (info->stack != NULL);
+
+  len = strlen (info->stack->type);
+  info->stack->type = (char *) xrealloc (info->stack->type,
+					 len + strlen (s) + 1);
+  strcpy (info->stack->type + 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;
+{
+  char *u;
+
+  assert (info->stack != NULL);
+
+  u = strchr (info->stack->type, '|');
+  if (u != NULL)
+    {
+      char *n;
+
+      n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
+
+      memcpy (n, info->stack->type, u - info->stack->type);
+      strcpy (n + (u - info->stack->type), s);
+      strcat (n, u + 1);
+
+      free (info->stack->type);
+      info->stack->type = n;
+
+      return true;
+    }
+
+  if (strchr (s, '|') != NULL
+      && (strchr (info->stack->type, '{') != NULL
+	  || strchr (info->stack->type, '(') != NULL))
+    {
+      if (! prepend_type (info, "(")
+	  || ! append_type (info, ")"))
+	return false;
+    }
+
+  if (*s == '\0')
+    return true;
+
+  return (append_type (info, " ")
+	  && append_type (info, s));
+}
+
+/* Indent the type at the top of the stack by appending spaces.  */
+
+static boolean
+indent_type (info)
+     struct pr_handle *info;
+{
+  unsigned int i;
+
+  for (i = 0; i < info->indent; i++)
+    {
+      if (! append_type (info, " "))
+	return false;
+    }
+
+  return true;
+}
+
+/* Pop a type from the type stack.  */
+
+static char *
+pop_type (info)
+     struct pr_handle *info;
+{
+  struct pr_stack *o;
+  char *ret;
+
+  assert (info->stack != NULL);
+
+  o = info->stack;
+  info->stack = o->next;
+  ret = o->type;
+  free (o);
+
+  return ret;
+}
+
+/* Print a VMA value into a string.  */
+
+static void
+print_vma (vma, buf, unsignedp, hexp)
+     bfd_vma vma;
+     char *buf;
+     boolean unsignedp;
+     boolean hexp;
+{
+  if (sizeof (vma) <= sizeof (unsigned long))
+    {
+      if (hexp)
+	sprintf (buf, "0x%lx", (unsigned long) vma);
+      else if (unsignedp)
+	sprintf (buf, "%lu", (unsigned long) vma);
+      else
+	sprintf (buf, "%ld", (long) vma);
+    }
+  else
+    {
+      buf[0] = '0';
+      buf[1] = 'x';
+      sprintf_vma (buf + 2, vma);
+    }
+}
+
+/* Start a new compilation unit.  */
+
+static boolean
+pr_start_compilation_unit (p, filename)
+     PTR p;
+     const char *filename;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  assert (info->indent == 0);
+
+  fprintf (info->f, "%s:\n", filename);
+
+  return true;
+}
+
+/* Start a source file within a compilation unit.  */
+
+static boolean
+pr_start_source (p, filename)
+     PTR p;
+     const char *filename;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  assert (info->indent == 0);
+
+  fprintf (info->f, " %s:\n", filename);
+
+  return true;
+}
+
+/* Push an empty type onto the type stack.  */
+
+static boolean
+pr_empty_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  return push_type (info, "<undefined>");
+}
+
+/* Push a void type onto the type stack.  */
+
+static boolean
+pr_void_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  return push_type (info, "void");
+}
+
+/* Push an integer type onto the type stack.  */
+
+static boolean
+pr_int_type (p, size, unsignedp)
+     PTR p;
+     unsigned int size;
+     boolean unsignedp;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[10];
+
+  sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
+  return push_type (info, ab);
+}
+
+/* Push a floating type onto the type stack.  */
+
+static boolean
+pr_float_type (p, size)
+     PTR p;
+     unsigned int size;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[10];
+
+  if (size == 4)
+    return push_type (info, "float");
+  else if (size == 8)
+    return push_type (info, "double");
+
+  sprintf (ab, "float%d", size * 8);
+  return push_type (info, ab);
+}
+
+/* Push a complex type onto the type stack.  */
+
+static boolean
+pr_complex_type (p, size)
+     PTR p;
+     unsigned int size;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  if (! pr_float_type (p, size))
+    return false;
+
+  return prepend_type (info, "complex ");
+}
+
+/* Push a boolean type onto the type stack.  */
+
+static boolean
+pr_bool_type (p, size)
+     PTR p;
+     unsigned int size;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[10];
+
+  sprintf (ab, "bool%d", size * 8);
+
+  return push_type (info, ab);
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  unsigned int i;
+  bfd_signed_vma val;
+
+  if (! push_type (info, "enum "))
+    return false;
+  if (tag != NULL)
+    {
+      if (! append_type (info, tag)
+	  || ! append_type (info, " "))
+	return false;
+    }
+  if (! append_type (info, "{ "))
+    return false;
+
+  if (names == NULL)
+    {
+      if (! append_type (info, "/* undefined */"))
+	return false;
+    }
+  else
+    {
+      val = 0;
+      for (i = 0; names[i] != NULL; i++)
+	{
+	  if (i > 0)
+	    {
+	      if (! append_type (info, ", "))
+		return false;
+	    }
+
+	  if (! append_type (info, names[i]))
+	    return false;
+
+	  if (values[i] != val)
+	    {
+	      char ab[20];
+
+	      print_vma (values[i], ab, false, false);
+	      if (! append_type (info, " = ")
+		  || ! append_type (info, ab))
+		return false;
+	      val = values[i];
+	    }
+
+	  ++val;
+	}
+    }
+
+  return append_type (info, " }");
+}
+
+/* Turn the top type on the stack into a pointer.  */
+
+static boolean
+pr_pointer_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *s;
+
+  assert (info->stack != NULL);
+
+  s = strchr (info->stack->type, '|');
+  if (s != NULL && s[1] == '[')
+    return substitute_type (info, "(*|)");
+  return substitute_type (info, "*|");
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char **arg_types;
+  unsigned int len;
+  char *s;
+
+  assert (info->stack != NULL);
+
+  len = 10;
+
+  if (argcount <= 0)
+    {
+      arg_types = NULL;
+      len += 15;
+    }
+  else
+    {
+      int i;
+
+      arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
+      for (i = argcount - 1; i >= 0; i--)
+	{
+	  if (! substitute_type (info, ""))
+	    return false;
+	  arg_types[i] = pop_type (info);
+	  if (arg_types[i] == NULL)
+	    return false;
+	  len += strlen (arg_types[i]) + 2;
+	}
+      if (varargs)
+	len += 5;
+    }
+
+  /* Now the return type is on the top of the stack.  */
+
+  s = (char *) xmalloc (len);
+  strcpy (s, "(|) (");
+
+  if (argcount < 0)
+    strcat (s, "/* unknown */");
+  else
+    {
+      int i;
+
+      for (i = 0; i < argcount; i++)
+	{
+	  if (i > 0)
+	    strcat (s, ", ");
+	  strcat (s, arg_types[i]);
+	}
+      if (varargs)
+	{
+	  if (i > 0)
+	    strcat (s, ", ");
+	  strcat (s, "...");
+	}
+      if (argcount > 0)
+	free (arg_types);
+    }
+
+  strcat (s, ")");
+
+  if (! substitute_type (info, s))
+    return false;
+
+  free (s);
+
+  return true;
+}
+
+/* Turn the top type on the stack into a reference to that type.  */
+
+static boolean
+pr_reference_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  assert (info->stack != NULL);
+
+  return substitute_type (info, "&|");
+}
+
+/* Make a range type.  */
+
+static boolean
+pr_range_type (p, lower, upper)
+     PTR p;
+     bfd_signed_vma lower;
+     bfd_signed_vma upper;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char abl[20], abu[20];
+
+  assert (info->stack != NULL);
+
+  if (! substitute_type (info, ""))
+    return false;
+
+  print_vma (lower, abl, false, false);
+  print_vma (upper, abu, false, false);
+
+  return (prepend_type (info, "range (")
+	  && append_type (info, "):")
+	  && append_type (info, abl)
+	  && append_type (info, ":")
+	  && append_type (info, abu));
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *range_type;
+  char abl[20], abu[20], ab[50];
+
+  range_type = pop_type (info);
+  if (range_type == NULL)
+    return false;
+
+  if (lower == 0)
+    {
+      if (upper == -1)
+	sprintf (ab, "|[]");
+      else
+	{
+	  print_vma (upper + 1, abu, false, false);
+	  sprintf (ab, "|[%s]", abu);
+	}
+    }
+  else
+    {
+      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;
+
+  if (strcmp (range_type, "int") != 0)
+    {
+      if (! append_type (info, ":")
+	  || ! append_type (info, range_type))
+	return false;
+    }
+
+  if (stringp)
+    {
+      if (! append_type (info, " /* string */"))
+	return false;
+    }
+
+  return true;
+}
+
+/* Make a set type.  */
+
+/*ARGSUSED*/
+static boolean
+pr_set_type (p, bitstringp)
+     PTR p;
+     boolean bitstringp;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  if (! substitute_type (info, ""))
+    return false;
+
+  if (! prepend_type (info, "set { ")
+      || ! append_type (info, " }"))
+    return false;
+
+  if (bitstringp)
+    {
+      if (! append_type (info, "/* bitstring */"))
+	return false;
+    }
+
+  return true;
+}
+
+/* Make an offset type.  */
+
+static boolean
+pr_offset_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  if (! substitute_type (info, ""))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  return (substitute_type (info, "")
+	  && prepend_type (info, " ")
+	  && prepend_type (info, t)
+	  && append_type (info, "::|"));
+}
+
+/* Make a method type.  */
+
+static boolean
+pr_method_type (p, domain, argcount, varargs)
+     PTR p;
+     boolean domain;
+     int argcount;
+     boolean varargs;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  unsigned int len;
+  char *domain_type;
+  char **arg_types;
+  char *s;
+
+  len = 10;
+
+  if (! domain)
+    domain_type = NULL;
+  else
+    {
+      if (! substitute_type (info, ""))
+	return false;
+      domain_type = pop_type (info);
+      if (domain_type == NULL)
+	return false;
+      if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
+	  && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
+	domain_type += sizeof "class " - 1;
+      else if (strncmp (domain_type, "union class ",
+			sizeof "union class ") == 0
+	       && (strchr (domain_type + sizeof "union class " - 1, ' ')
+		   == NULL))
+	domain_type += sizeof "union class " - 1;
+      len += strlen (domain_type);
+    }
+
+  if (argcount <= 0)
+    {
+      arg_types = NULL;
+      len += 15;
+    }
+  else
+    {
+      int i;
+
+      arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
+      for (i = argcount - 1; i >= 0; i--)
+	{
+	  if (! substitute_type (info, ""))
+	    return false;
+	  arg_types[i] = pop_type (info);
+	  if (arg_types[i] == NULL)
+	    return false;
+	  len += strlen (arg_types[i]) + 2;
+	}
+      if (varargs)
+	len += 5;
+    }
+
+  /* Now the return type is on the top of the stack.  */
+
+  s = (char *) xmalloc (len);
+  if (! domain)
+    *s = '\0';
+  else
+    strcpy (s, domain_type);
+  strcat (s, "::| (");
+
+  if (argcount < 0)
+    strcat (s, "/* unknown */");
+  else
+    {
+      int i;
+
+      for (i = 0; i < argcount; i++)
+	{
+	  if (i > 0)
+	    strcat (s, ", ");
+	  strcat (s, arg_types[i]);
+	}
+      if (varargs)
+	{
+	  if (i > 0)
+	    strcat (s, ", ");
+	  strcat (s, "...");
+	}
+      if (argcount > 0)
+	free (arg_types);
+    }
+
+  strcat (s, ")");
+
+  if (! substitute_type (info, s))
+    return false;
+
+  free (s);
+
+  return true;
+}
+
+/* Make a const qualified type.  */
+
+static boolean
+pr_const_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  return substitute_type (info, "const |");
+}
+
+/* Make a volatile qualified type.  */
+
+static boolean
+pr_volatile_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  return substitute_type (info, "volatile |");
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  info->indent += 2;
+
+  if (! push_type (info, structp ? "struct " : "union "))
+    return false;
+  if (tag != NULL)
+    {
+      if (! append_type (info, tag))
+	return false;
+    }
+  else
+    {
+      char idbuf[20];
+
+      sprintf (idbuf, "%%anon%u", id);
+      if (! append_type (info, idbuf))
+	return false;
+    }
+
+  if (! append_type (info, " {"))
+    return false;
+  if (size != 0 || tag != NULL)
+    {
+      char ab[30];
+
+      if (! append_type (info, " /*"))
+	return false;
+
+      if (size != 0)
+	{
+	  sprintf (ab, " size %u", size);
+	  if (! append_type (info, ab))
+	    return false;
+	}
+      if (tag != NULL)
+	{
+	  sprintf (ab, " id %u", id);
+	  if (! append_type (info, ab))
+	    return false;
+	}
+      if (! append_type (info, " */"))
+	return false;
+    }
+  if (! append_type (info, "\n"))
+    return false;
+
+  info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
+
+  return indent_type (info);
+}
+
+/* Output the visibility of a field in a struct.  */
+
+static boolean
+pr_fix_visibility (info, visibility)
+     struct pr_handle *info;
+     enum debug_visibility visibility;
+{
+  const char *s;
+  char *t;
+  unsigned int len;
+
+  assert (info->stack != NULL);
+
+  if (info->stack->visibility == visibility)
+    return true;
+
+  assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
+
+  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;
+    }
+
+  /* Trim off a trailing space in the struct string, to make the
+     output look a bit better, then stick on the visibility string.  */
+
+  t = info->stack->type;
+  len = strlen (t);
+  assert (t[len - 1] == ' ');
+  t[len - 1] = '\0';
+
+  if (! append_type (info, s)
+      || ! append_type (info, ":\n")
+      || ! indent_type (info))
+    return false;
+
+  info->stack->visibility = visibility;
+
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[20];
+  char *t;
+
+  if (! substitute_type (info, name))
+    return false;
+
+  if (! append_type (info, "; /* "))
+    return false;
+
+  if (bitsize != 0)
+    {
+      print_vma (bitsize, ab, true, false);
+      if (! append_type (info, "bitsize ")
+	  || ! append_type (info, ab)
+	  || ! append_type (info, ", "))
+	return 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;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  if (! pr_fix_visibility (info, visibility))
+    return false;
+
+  return append_type (info, t);
+}
+
+/* Finish a struct type.  */
+
+static boolean
+pr_end_struct_type (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *s;
+
+  assert (info->stack != NULL);
+  assert (info->indent >= 2);
+
+  info->indent -= 2;
+
+  /* Change the trailing indentation to have a close brace.  */
+  s = info->stack->type + strlen (info->stack->type) - 2;
+  assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
+
+  *s++ = '}';
+  *s = '\0';
+
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *tv = NULL;
+
+  info->indent += 2;
+
+  if (vptr && ! ownvptr)
+    {
+      tv = pop_type (info);
+      if (tv == NULL)
+	return false;
+    }
+
+  if (! push_type (info, structp ? "class " : "union class "))
+    return false;
+  if (tag != NULL)
+    {
+      if (! append_type (info, tag))
+	return false;
+    }
+  else
+    {
+      char idbuf[20];
+
+      sprintf (idbuf, "%%anon%u", id);
+      if (! append_type (info, idbuf))
+	return false;
+    }
+
+  if (! append_type (info, " {"))
+    return false;
+  if (size != 0 || vptr || ownvptr || tag != NULL)
+    {
+      if (! append_type (info, " /*"))
+	return false;
+
+      if (size != 0)
+	{
+	  char ab[20];
+
+	  sprintf (ab, "%u", size);
+	  if (! append_type (info, " size ")
+	      || ! append_type (info, ab))
+	    return false;
+	}
+
+      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;
+	    }
+	}
+
+      if (tag != NULL)
+	{
+	  char ab[30];
+
+	  sprintf (ab, " id %u", id);
+	  if (! append_type (info, ab))
+	    return false;
+	}
+
+      if (! append_type (info, " */"))
+	return false;
+    }
+
+  info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
+
+  return (append_type (info, "\n")
+	  && indent_type (info));
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  if (! substitute_type (info, name))
+    return false;
+
+  if (! prepend_type (info, "static ")
+      || ! append_type (info, "; /* ")
+      || ! append_type (info, physname)
+      || ! append_type (info, " */\n")
+      || ! indent_type (info))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  if (! pr_fix_visibility (info, visibility))
+    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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  const char *prefix;
+  char ab[20];
+  char *s, *l, *n;
+
+  assert (info->stack != NULL && info->stack->next != NULL);
+
+  if (! substitute_type (info, ""))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  if (strncmp (t, "class ", sizeof "class " - 1) == 0)
+    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 (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;
+
+  if (bitpos != 0)
+    {
+      print_vma (bitpos, ab, true, false);
+      if (! append_type (info, " /* bitpos ")
+	  || ! append_type (info, ab)
+	  || ! append_type (info, " */"))
+	return false;
+    }
+
+  /* Now the top of the stack is something like "public A / * bitpos
+     10 * /".  The next element on the stack is something like "class
+     xx { / * size 8 * /\n...".  We want to substitute the top of the
+     stack in before the {.  */
+  s = strchr (info->stack->next->type, '{');
+  assert (s != NULL);
+  --s;
+
+  /* If there is already a ':', then we already have a baseclass, and
+     we must append this one after a comma.  */
+  for (l = info->stack->next->type; l != s; l++)
+    if (*l == ':')
+      break;
+  if (! prepend_type (info, l == s ? " : " : ", "))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
+  memcpy (n, info->stack->type, s - info->stack->type);
+  strcpy (n + (s - info->stack->type), t);
+  strcat (n, s);
+
+  free (info->stack->type);
+  info->stack->type = n;
+
+  free (t);
+
+  return true;
+}
+
+/* Start adding a method to a class.  */
+
+static boolean
+pr_class_start_method (p, name)
+     PTR p;
+     const char *name;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  assert (info->stack != NULL);
+  info->stack->method = name;
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *method_type;
+  char *context_type;
+
+  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;
+    }
+
+  /* Stick the name of the method into its type.  */
+  if (! substitute_type (info,
+			 (context
+			  ? info->stack->next->next->method
+			  : info->stack->next->method)))
+    return false;
+
+  /* Get the type.  */
+  method_type = pop_type (info);
+  if (method_type == NULL)
+    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)
+	return false;
+    }
+
+  /* Now the top of the stack is the class.  */
+
+  if (! pr_fix_visibility (info, visibility))
+    return false;
+
+  if (! append_type (info, method_type)
+      || ! append_type (info, " /* ")
+      || ! append_type (info, physname)
+      || ! append_type (info, " "))
+    return false;
+  if (context || voffset != 0)
+    {
+      char ab[20];
+
+      if (context)
+	{
+	  if (! append_type (info, "context ")
+	      || ! append_type (info, context_type)
+	      || ! append_type (info, " "))
+	    return false;
+	}
+      print_vma (voffset, ab, true, false);
+      if (! append_type (info, "voffset ")
+	  || ! append_type (info, ab))
+	return false;
+    }
+
+  return (append_type (info, " */;\n")
+	  && indent_type (info));
+}
+
+/* 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *method_type;
+
+  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;
+
+  /* Stick the name of the method into its type.  */
+  if (! substitute_type (info, info->stack->next->method))
+    return false;
+
+  /* Get the type.  */
+  method_type = pop_type (info);
+  if (method_type == NULL)
+    return false;
+
+  /* Now the top of the stack is the class.  */
+
+  if (! pr_fix_visibility (info, visibility))
+    return false;
+
+  return (append_type (info, method_type)
+	  && append_type (info, " /* ")
+	  && append_type (info, physname)
+	  && append_type (info, " */;\n")
+	  && indent_type (info));
+}
+
+/* Finish up a method.  */
+
+static boolean
+pr_class_end_method (p)
+     PTR p;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  info->stack->method = NULL;
+  return true;
+}
+
+/* Finish up a class.  */
+
+static boolean
+pr_end_class_type (p)
+     PTR 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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  return push_type (info, 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;
+{
+  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;
+  if (name != NULL && kind != DEBUG_KIND_ENUM)
+    {
+      sprintf (idbuf, " /* id %u */", id);
+      if (! append_type (info, idbuf))
+	return false;
+    }
+
+  return true;
+}
+
+/* Output a typedef.  */
+
+static boolean
+pr_typdef (p, name)
+     PTR p;
+     const char *name;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *s;
+
+  if (! substitute_type (info, name))
+    return false;
+
+  s = pop_type (info);
+  if (s == NULL)
+    return false;
+
+  indent (info);
+  fprintf (info->f, "typedef %s;\n", 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.  */
+
+/*ARGSUSED*/
+static boolean
+pr_tag (p, name)
+     PTR p;
+     const char *name;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  indent (info);
+  fprintf (info->f, "%s;\n", t);
+
+  free (t);
+
+  return true;
+}
+
+/* Output an integer constant.  */
+
+static boolean
+pr_int_constant (p, name, val)
+     PTR p;
+     const char *name;
+     bfd_vma val;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[20];
+
+  indent (info);
+  print_vma (val, ab, false, false);
+  fprintf (info->f, "const int %s = %s;\n", name, ab);
+  return true;
+}
+
+/* Output a floating point constant.  */
+
+static boolean
+pr_float_constant (p, name, val)
+     PTR p;
+     const char *name;
+     double val;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+
+  indent (info);
+  fprintf (info->f, "const double %s = %g;\n", name, val);
+  return true;
+}
+
+/* Output a typed constant.  */
+
+static boolean
+pr_typed_constant (p, name, val)
+     PTR p;
+     const char *name;
+     bfd_vma val;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  char ab[20];
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  indent (info);
+  print_vma (val, ab, false, false);
+  fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
+
+  free (t);
+
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  char ab[20];
+
+  if (! substitute_type (info, name))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  indent (info);
+  switch (kind)
+    {
+    case DEBUG_STATIC:
+    case DEBUG_LOCAL_STATIC:
+      fprintf (info->f, "static ");
+      break;
+    case DEBUG_REGISTER:
+      fprintf (info->f, "register ");
+      break;
+    default:
+      break;
+    }
+  print_vma (val, ab, true, true);
+  fprintf (info->f, "%s /* %s */;\n", t, ab);
+
+  free (t);
+
+  return true;
+}
+
+/* Start outputting a function.  */
+
+static boolean
+pr_start_function (p, name, global)
+     PTR p;
+     const char *name;
+     boolean global;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+
+  if (! substitute_type (info, name))
+    return false;
+
+  t = pop_type (info);
+  if (t == NULL)
+    return false;
+
+  indent (info);
+  if (! global)
+    fprintf (info->f, "static ");
+  fprintf (info->f, "%s (", t);
+
+  info->parameter = 1;
+
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char *t;
+  char ab[20];
+
+  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->parameter != 1)
+    fprintf (info->f, ", ");
+
+  if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
+    fprintf (info->f, "register ");
+
+  print_vma (val, ab, true, true);
+  fprintf (info->f, "%s /* %s */", t, ab);
+
+  free (t);
+
+  ++info->parameter;
+
+  return true;
+}
+
+/* Start writing out a block.  */
+
+static boolean
+pr_start_block (p, addr)
+     PTR p;
+     bfd_vma addr;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[20];
+
+  if (info->parameter > 0)
+    {
+      fprintf (info->f, ")\n");
+      info->parameter = 0;
+    }
+
+  indent (info);
+  print_vma (addr, ab, true, true);
+  fprintf (info->f, "{ /* %s */\n", ab);
+
+  info->indent += 2;
+
+  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;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[20];
+
+  indent (info);
+  print_vma (addr, ab, true, true);
+  fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
+
+  return true;
+}
+
+/* Finish writing out a block.  */
+
+static boolean
+pr_end_block (p, addr)
+     PTR p;
+     bfd_vma addr;
+{
+  struct pr_handle *info = (struct pr_handle *) p;
+  char ab[20];
+
+  info->indent -= 2;
+
+  indent (info);
+  print_vma (addr, ab, true, true);
+  fprintf (info->f, "} /* %s */\n", ab);
+
+  return true;
+}
+
+/* Finish writing out a function.  */
+
+/*ARGSUSED*/
+static boolean
+pr_end_function (p)
+     PTR p;
+{
+  return true;
+}