/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c
Warning:	line 2355, column 12 Potential leak of memory pointed to by 'method_name'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name prdbg.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/binutils -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/binutils -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/binutils -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../include -I /usr/src/gnu/usr.bin/binutils-2.17/binutils/../intl -I ../intl -D LOCALEDIR="/usr/share/locale" -D bin_dummy_emulation=bin_vanilla_emulation -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/binutils -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c
1/* prdbg.c -- Print out generic debugging information.
 Copyright 1995, 1996, 1999, 2002, 2003, 2004
 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
 (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., 51 Franklin Street - Fifth Floor, Boston, MA
 02110-1301, USA.  */

24/* This file prints out the generic debugging information, by
 supplying a set of routines to debug_write.  */

27#include <stdio.h>
28#include <assert.h>

30#include "bfd.h"
31#include "bucomm.h"
32#include "libiberty.h"
33#include "debug.h"
34#include "budbg.h"

36/* This is the structure we use as a handle for these routines.  */

38struct pr_handle
39{
/* 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 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 *);
57};

59/* The type stack.  */

61struct pr_stack
62{
/* 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;
/* 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;
78};

80static void indent (struct pr_handle *);
81static bfd_boolean push_type (struct pr_handle *, const char *);
82static bfd_boolean prepend_type (struct pr_handle *, const char *);
83static bfd_boolean append_type (struct pr_handle *, const char *);
84static bfd_boolean substitute_type (struct pr_handle *, const char *);
85static bfd_boolean indent_type (struct pr_handle *);
86static char *pop_type (struct pr_handle *);
87static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
88static bfd_boolean pr_fix_visibility
(struct pr_handle *, enum debug_visibility);
90static bfd_boolean pr_start_compilation_unit (void *, const char *);
91static bfd_boolean pr_start_source (void *, const char *);
92static bfd_boolean pr_empty_type (void *);
93static bfd_boolean pr_void_type (void *);
94static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
95static bfd_boolean pr_float_type (void *, unsigned int);
96static bfd_boolean pr_complex_type (void *, unsigned int);
97static bfd_boolean pr_bool_type (void *, unsigned int);
98static bfd_boolean pr_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
100static bfd_boolean pr_pointer_type (void *);
101static bfd_boolean pr_function_type (void *, int, bfd_boolean);
102static bfd_boolean pr_reference_type (void *);
103static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
104static bfd_boolean pr_array_type
(void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
106static bfd_boolean pr_set_type (void *, bfd_boolean);
107static bfd_boolean pr_offset_type (void *);
108static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
109static bfd_boolean pr_const_type (void *);
110static bfd_boolean pr_volatile_type (void *);
111static bfd_boolean pr_start_struct_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int);
113static bfd_boolean pr_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
115static bfd_boolean pr_end_struct_type (void *);
116static bfd_boolean pr_start_class_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int,
 bfd_boolean, bfd_boolean);
119static bfd_boolean pr_class_static_member
(void *, const char *, const char *, enum debug_visibility);
121static bfd_boolean pr_class_baseclass
(void *, bfd_vma, bfd_boolean, enum debug_visibility);
123static bfd_boolean pr_class_start_method (void *, const char *);
124static bfd_boolean pr_class_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
 bfd_vma, bfd_boolean);
127static bfd_boolean pr_class_static_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
129static bfd_boolean pr_class_end_method (void *);
130static bfd_boolean pr_end_class_type (void *);
131static bfd_boolean pr_typedef_type (void *, const char *);
132static bfd_boolean pr_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
134static bfd_boolean pr_typdef (void *, const char *);
135static bfd_boolean pr_tag (void *, const char *);
136static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
137static bfd_boolean pr_float_constant (void *, const char *, double);
138static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
139static bfd_boolean pr_variable
(void *, const char *, enum debug_var_kind, bfd_vma);
141static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
142static bfd_boolean pr_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
144static bfd_boolean pr_start_block (void *, bfd_vma);
145static bfd_boolean pr_end_block (void *, bfd_vma);
146static bfd_boolean pr_end_function (void *);
147static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
148static bfd_boolean append_parent (struct pr_handle *, const char *);
149/* Only used by tg_ code.  */
150static bfd_boolean tg_fix_visibility
(struct pr_handle *, enum debug_visibility);
152static void find_address_in_section (bfd *, asection *, void *);
153static void translate_addresses (bfd *, char *, FILE *, asymbol **);
154static const char *visibility_name (enum debug_visibility);
155/* Tags style replacements.  */
156static bfd_boolean tg_start_compilation_unit (void *, const char *);
157static bfd_boolean tg_start_source (void *, const char *);
158static bfd_boolean tg_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
160static bfd_boolean tg_start_struct_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int);
162static bfd_boolean pr_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
164static bfd_boolean tg_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
166static bfd_boolean tg_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
168static bfd_boolean tg_end_struct_type (void *);
169static bfd_boolean tg_start_class_type
(void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
171static bfd_boolean tg_class_static_member
(void *, const char *, const char *, enum debug_visibility);
173static bfd_boolean tg_class_baseclass
(void *, bfd_vma, bfd_boolean, enum debug_visibility);
175static bfd_boolean tg_class_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
177static bfd_boolean tg_class_static_method_variant
(void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
179static bfd_boolean tg_end_class_type (void *);
180static bfd_boolean tg_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
182static bfd_boolean tg_typdef (void *, const char *);
183static bfd_boolean tg_tag (void *, const char *);
184static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
185static bfd_boolean tg_float_constant (void *, const char *, double);
186static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
187static bfd_boolean tg_variable
(void *, const char *, enum debug_var_kind, bfd_vma);
189static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
190static bfd_boolean tg_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
192static bfd_boolean tg_start_block (void *, bfd_vma);
193static bfd_boolean tg_end_block (void *, bfd_vma);
194static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
195
196static const struct debug_write_fns pr_fns =
197{
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
242};
243
244static const struct debug_write_fns tg_fns =
245{
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
290};
291
292/* Print out the generic debugging information recorded in dhandle.  */

294bfd_boolean
295print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
      void *demangler, bfd_boolean as_tags)
297{
struct pr_handle info;

info.f = f;
info.indent = 0;
info.stack = NULL((void*)0);
info.parameter = 0;
info.filename = NULL((void*)0);
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 as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
  : debug_write (dhandle, &pr_fns, (void *) & info);
319}
320
321/* Indent to the current indentation level.  */

323static void
324indent (struct pr_handle *info)
325{
unsigned int i;

for (i = 0; i < info->indent; i++)
  putc (' ', info->f)(!__isthreaded ? __sputc(' ', info->f) : (putc)(' ', info->
f));
330}

332/* Push a type on the type stack.  */

334static bfd_boolean
335push_type (struct pr_handle *info, const char *type)
336{
struct pr_stack *n;

if (type == NULL((void*)0))
  return FALSE0;

n = (struct pr_stack *) xmalloc (sizeof *n);
memset (n, 0, sizeof *n);

n->type = xstrdup (type);
n->visibility = DEBUG_VISIBILITY_IGNORE;
n->method = NULL((void*)0);
n->next = info->stack;
info->stack = n;

return TRUE1;
352}

354/* Prepend a string onto the type on the top of the type stack.  */

356static bfd_boolean
357prepend_type (struct pr_handle *info, const char *s)
358{
char *n;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 361, __func__, "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 TRUE1;
369}

371/* Append a string to the type on the top of the type stack.  */

373static bfd_boolean
374append_type (struct pr_handle *info, const char *s)
375{
unsigned int len;

if (s == NULL((void*)0))
  return FALSE0;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 381, __func__, "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 TRUE1;
389}

391/* Append a string to the parents on the top of the type stack.  */

393static bfd_boolean
394append_parent (struct pr_handle *info, const char *s)
395{
unsigned int len;

if (s == NULL((void*)0))
  return FALSE0;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 401, __func__, "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 TRUE1;
409}

411/* 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.  */

415static bfd_boolean
416substitute_type (struct pr_handle *info, const char *s)
417{
char *u;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 420, __func__, "info->stack != NULL"));

u = strchr (info->stack->type, '|');
if (u != NULL((void*)0))
  {
    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 TRUE1;
  }

if (strchr (s, '|') != NULL((void*)0)
    && (strchr (info->stack->type, '{') != NULL((void*)0)
 || strchr (info->stack->type, '(') != NULL((void*)0)))
  {
    if (! prepend_type (info, "(")
 || ! append_type (info, ")"))
return FALSE0;
  }

if (*s == '\0')
  return TRUE1;

return (append_type (info, " ")
 && append_type (info, s));
453}

455/* Indent the type at the top of the stack by appending spaces.  */

457static bfd_boolean
458indent_type (struct pr_handle *info)
459{
unsigned int i;

for (i = 0; i < info->indent; i++)
  {
    if (! append_type (info, " "))
return FALSE0;
  }

return TRUE1;
469}

471/* Pop a type from the type stack.  */

473static char *
474pop_type (struct pr_handle *info)
475{
struct pr_stack *o;
char *ret;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 479, __func__, "info->stack != NULL"));

o = info->stack;
info->stack = o->next;
ret = o->type;
free (o);

return ret;
487}

489/* Print a VMA value into a string.  */

491static void
492print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
493{
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)sprintf (buf + 2, "%016lx", vma);
  }
509}
510
511/* Start a new compilation unit.  */

513static bfd_boolean
514pr_start_compilation_unit (void *p, const char *filename)
515{
struct pr_handle *info = (struct pr_handle *) p;

assert (info->indent == 0)((info->indent == 0) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 518, __func__, "info->indent == 0"));

fprintf (info->f, "%s:\n", filename);

return TRUE1;
523}

525/* Start a source file within a compilation unit.  */

527static bfd_boolean
528pr_start_source (void *p, const char *filename)
529{
struct pr_handle *info = (struct pr_handle *) p;

assert (info->indent == 0)((info->indent == 0) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 532, __func__, "info->indent == 0"));

fprintf (info->f, " %s:\n", filename);

return TRUE1;
537}

539/* Push an empty type onto the type stack.  */

541static bfd_boolean
542pr_empty_type (void *p)
543{
struct pr_handle *info = (struct pr_handle *) p;

return push_type (info, "<undefined>");
547}

549/* Push a void type onto the type stack.  */

551static bfd_boolean
552pr_void_type (void *p)
553{
struct pr_handle *info = (struct pr_handle *) p;

return push_type (info, "void");
557}

559/* Push an integer type onto the type stack.  */

561static bfd_boolean
562pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
563{
struct pr_handle *info = (struct pr_handle *) p;
char ab[10];

sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
return push_type (info, ab);
569}

571/* Push a floating type onto the type stack.  */

573static bfd_boolean
574pr_float_type (void *p, unsigned int size)
575{
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);
586}

588/* Push a complex type onto the type stack.  */

590static bfd_boolean
591pr_complex_type (void *p, unsigned int size)
592{
struct pr_handle *info = (struct pr_handle *) p;

if (! pr_float_type (p, size))
  return FALSE0;

return prepend_type (info, "complex ");
599}

601/* Push a bfd_boolean type onto the type stack.  */

603static bfd_boolean
604pr_bool_type (void *p, unsigned int size)
605{
struct pr_handle *info = (struct pr_handle *) p;
char ab[10];

sprintf (ab, "bool%d", size * 8);

return push_type (info, ab);
612}

614/* Push an enum type onto the type stack.  */

616static bfd_boolean
617pr_enum_type (void *p, const char *tag, const char **names,
     bfd_signed_vma *values)
619{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int i;
bfd_signed_vma val;

if (! push_type (info, "enum "))
  return FALSE0;
if (tag != NULL((void*)0))
  {
    if (! append_type (info, tag)
 || ! append_type (info, " "))
return FALSE0;
  }
if (! append_type (info, "{ "))
  return FALSE0;

if (names == NULL((void*)0))
  {
    if (! append_type (info, "/* undefined */"))
return FALSE0;
  }
else
  {
    val = 0;
    for (i = 0; names[i] != NULL((void*)0); i++)
{
 if (i > 0)
   {
     if (! append_type (info, ", "))
return FALSE0;
   }

 if (! append_type (info, names[i]))
   return FALSE0;

 if (values[i] != val)
   {
     char ab[20];

     print_vma (values[i], ab, FALSE0, FALSE0);
     if (! append_type (info, " = ")
  || ! append_type (info, ab))
return FALSE0;
     val = values[i];
   }

 ++val;
}
  }

return append_type (info, " }");
670}

672/* Turn the top type on the stack into a pointer.  */

674static bfd_boolean
675pr_pointer_type (void *p)
676{
struct pr_handle *info = (struct pr_handle *) p;
char *s;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 680, __func__, "info->stack != NULL"));

s = strchr (info->stack->type, '|');
if (s != NULL((void*)0) && s[1] == '[')
  return substitute_type (info, "(*|)");
return substitute_type (info, "*|");
686}

688/* Turn the top type on the stack into a function returning that type.  */

690static bfd_boolean
691pr_function_type (void *p, int argcount, bfd_boolean varargs)
692{
struct pr_handle *info = (struct pr_handle *) p;
char **arg_types;
unsigned int len;
char *s;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 698, __func__, "info->stack != NULL"));

len = 10;

if (argcount <= 0)
  {
    arg_types = NULL((void*)0);
    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 FALSE0;
 arg_types[i] = pop_type (info);
 if (arg_types[i] == NULL((void*)0))
   return FALSE0;
 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 FALSE0;

free (s);

return TRUE1;
760}

762/* Turn the top type on the stack into a reference to that type.  */

764static bfd_boolean
765pr_reference_type (void *p)
766{
struct pr_handle *info = (struct pr_handle *) p;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 769, __func__, "info->stack != NULL"));

return substitute_type (info, "&|");
772}

774/* Make a range type.  */

776static bfd_boolean
777pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
778{
struct pr_handle *info = (struct pr_handle *) p;
char abl[20], abu[20];

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 782, __func__, "info->stack != NULL"));

if (! substitute_type (info, ""))
  return FALSE0;

print_vma (lower, abl, FALSE0, FALSE0);
print_vma (upper, abu, FALSE0, FALSE0);

return (prepend_type (info, "range (")
 && append_type (info, "):")
 && append_type (info, abl)
 && append_type (info, ":")
 && append_type (info, abu));
795}

797/* Make an array type.  */

799static bfd_boolean
800pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
      bfd_boolean stringp)
802{
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((void*)0))
  return FALSE0;

if (lower == 0)
  {
    if (upper == -1)
sprintf (ab, "|[]");
    else
{
 print_vma (upper + 1, abu, FALSE0, FALSE0);
 sprintf (ab, "|[%s]", abu);
}
  }
else
  {
    print_vma (lower, abl, FALSE0, FALSE0);
    print_vma (upper, abu, FALSE0, FALSE0);
    sprintf (ab, "|[%s:%s]", abl, abu);
  }

if (! substitute_type (info, ab))
  return FALSE0;

if (strcmp (range_type, "int") != 0)
  {
    if (! append_type (info, ":")
 || ! append_type (info, range_type))
return FALSE0;
  }

if (stringp)
  {
    if (! append_type (info, " /* string */"))
return FALSE0;
  }

return TRUE1;
845}

847/* Make a set type.  */

849static bfd_boolean
850pr_set_type (void *p, bfd_boolean bitstringp)
851{
struct pr_handle *info = (struct pr_handle *) p;

if (! substitute_type (info, ""))
  return FALSE0;

if (! prepend_type (info, "set { ")
    || ! append_type (info, " }"))
  return FALSE0;

if (bitstringp)
  {
    if (! append_type (info, "/* bitstring */"))
return FALSE0;
  }

return TRUE1;
868}

870/* Make an offset type.  */

872static bfd_boolean
873pr_offset_type (void *p)
874{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

if (! substitute_type (info, ""))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

return (substitute_type (info, "")
 && prepend_type (info, " ")
 && prepend_type (info, t)
 && append_type (info, "::|"));
889}

891/* Make a method type.  */

893static bfd_boolean
894pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
895{
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((void*)0);
else
  {
    if (! substitute_type (info, ""))
return FALSE0;
    domain_type = pop_type (info);
    if (domain_type == NULL((void*)0))
return FALSE0;
    if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL((void*)0))
domain_type += sizeof "class " - 1;
    else if (strncmp (domain_type, "union class ",
	sizeof "union class ") == 0
      && (strchr (domain_type + sizeof "union class " - 1, ' ')
   == NULL((void*)0)))
domain_type += sizeof "union class " - 1;
    len += strlen (domain_type);
  }

if (argcount <= 0)
  {
    arg_types = NULL((void*)0);
    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 FALSE0;
 arg_types[i] = pop_type (info);
 if (arg_types[i] == NULL((void*)0))
   return FALSE0;
 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 FALSE0;

free (s);

return TRUE1;
986}

988/* Make a const qualified type.  */

990static bfd_boolean
991pr_const_type (void *p)
992{
struct pr_handle *info = (struct pr_handle *) p;

return substitute_type (info, "const |");
996}

998/* Make a volatile qualified type.  */

1000static bfd_boolean
1001pr_volatile_type (void *p)
1002{
struct pr_handle *info = (struct pr_handle *) p;

return substitute_type (info, "volatile |");
1006}

1008/* Start accumulating a struct type.  */

1010static bfd_boolean
1011pr_start_struct_type (void *p, const char *tag, unsigned int id,
      bfd_boolean structp, unsigned int size)
1013{
struct pr_handle *info = (struct pr_handle *) p;

info->indent += 2;

if (! push_type (info, structp ? "struct " : "union "))
  return FALSE0;
if (tag != NULL((void*)0))
  {
    if (! append_type (info, tag))
return FALSE0;
  }
else
  {
    char idbuf[20];

    sprintf (idbuf, "%%anon%u", id);
    if (! append_type (info, idbuf))
return FALSE0;
  }

if (! append_type (info, " {"))
  return FALSE0;
if (size != 0 || tag != NULL((void*)0))
  {
    char ab[30];

    if (! append_type (info, " /*"))
return FALSE0;

    if (size != 0)
{
 sprintf (ab, " size %u", size);
 if (! append_type (info, ab))
   return FALSE0;
}
    if (tag != NULL((void*)0))
{
 sprintf (ab, " id %u", id);
 if (! append_type (info, ab))
   return FALSE0;
}
    if (! append_type (info, " */"))
return FALSE0;
  }
if (! append_type (info, "\n"))
  return FALSE0;

info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;

return indent_type (info);
1064}

1066/* Output the visibility of a field in a struct.  */

1068static bfd_boolean
1069pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
1070{
const char *s = NULL((void*)0);
char *t;
unsigned int len;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1075, __func__, "info->stack != NULL"));

if (info->stack->visibility == visibility)
  return TRUE1;

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 FALSE0;
  }

/* 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] == ' ') ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1104, __func__, "t[len - 1] == ' '"));
t[len - 1] = '\0';

if (! append_type (info, s)
    || ! append_type (info, ":\n")
    || ! indent_type (info))
  return FALSE0;

info->stack->visibility = visibility;

return TRUE1;
1115}

1117/* Add a field to a struct type.  */

1119static bfd_boolean
1120pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
 enum debug_visibility visibility)
1122{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
char *t;

if (! substitute_type (info, name))
  return FALSE0;

if (! append_type (info, "; /* "))
  return FALSE0;

if (bitsize != 0)
  {
    print_vma (bitsize, ab, TRUE1, FALSE0);
    if (! append_type (info, "bitsize ")
 || ! append_type (info, ab)
 || ! append_type (info, ", "))
return FALSE0;
  }

print_vma (bitpos, ab, TRUE1, FALSE0);
if (! append_type (info, "bitpos ")
    || ! append_type (info, ab)
    || ! append_type (info, " */\n")
    || ! indent_type (info))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (! pr_fix_visibility (info, visibility))
  return FALSE0;

return append_type (info, t);
1157}

1159/* Finish a struct type.  */

1161static bfd_boolean
1162pr_end_struct_type (void *p)
1163{
struct pr_handle *info = (struct pr_handle *) p;
char *s;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1167, __func__, "info->stack != NULL"));
assert (info->indent >= 2)((info->indent >= 2) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1168, __func__, "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[0] == ' ' && s[1] == ' ' && s[2] == '\0')
 ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1174, __func__, "s[0] == ' ' && s[1] == ' ' && s[2] == '\\0'"
));

*s++ = '}';
*s = '\0';

return TRUE1;
1180}

1182/* Start a class type.  */

1184static bfd_boolean
1185pr_start_class_type (void *p, const char *tag, unsigned int id,
     bfd_boolean structp, unsigned int size,
     bfd_boolean vptr, bfd_boolean ownvptr)
1188{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL((void*)0);

info->indent += 2;

if (vptr && ! ownvptr)
  {
    tv = pop_type (info);
    if (tv == NULL((void*)0))
return FALSE0;
  }

if (! push_type (info, structp ? "class " : "union class "))
  return FALSE0;
if (tag != NULL((void*)0))
  {
    if (! append_type (info, tag))
return FALSE0;
  }
else
  {
    char idbuf[20];

    sprintf (idbuf, "%%anon%u", id);
    if (! append_type (info, idbuf))
return FALSE0;
  }

if (! append_type (info, " {"))
  return FALSE0;
if (size != 0 || vptr || ownvptr || tag != NULL((void*)0))
  {
    if (! append_type (info, " /*"))
return FALSE0;

    if (size != 0)
{
 char ab[20];

 sprintf (ab, "%u", size);
 if (! append_type (info, " size ")
     || ! append_type (info, ab))
   return FALSE0;
}

    if (vptr)
{
 if (! append_type (info, " vtable "))
   return FALSE0;
 if (ownvptr)
   {
     if (! append_type (info, "self "))
return FALSE0;
   }
 else
   {
     if (! append_type (info, tv)
  || ! append_type (info, " "))
return FALSE0;
   }
}

    if (tag != NULL((void*)0))
{
 char ab[30];

 sprintf (ab, " id %u", id);
 if (! append_type (info, ab))
   return FALSE0;
}

    if (! append_type (info, " */"))
return FALSE0;
  }

info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;

return (append_type (info, "\n")
 && indent_type (info));
1268}

1270/* Add a static member to a class.  */

1272static bfd_boolean
1273pr_class_static_member (void *p, const char *name, const char *physname,
	enum debug_visibility visibility)
1275{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

if (! substitute_type (info, name))
  return FALSE0;

if (! prepend_type (info, "static ")
    || ! append_type (info, "; /* ")
    || ! append_type (info, physname)
    || ! append_type (info, " */\n")
    || ! indent_type (info))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (! pr_fix_visibility (info, visibility))
  return FALSE0;

return append_type (info, t);
1297}

1299/* Add a base class to a class.  */

1301static bfd_boolean
1302pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
    enum debug_visibility visibility)
1304{
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)((info->stack != ((void*)0) && info->stack->
next != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1311, __func__, "info->stack != NULL && info->stack->next != NULL"
));

if (! substitute_type (info, ""))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

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 FALSE0;

if (virtual)
  {
    if (! prepend_type (info, "virtual "))
return FALSE0;
  }

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 FALSE0;

if (bitpos != 0)
  {
    print_vma (bitpos, ab, TRUE1, FALSE0);
    if (! append_type (info, " /* bitpos ")
 || ! append_type (info, ab)
 || ! append_type (info, " */"))
return FALSE0;
  }

/* 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 != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1367, __func__, "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 FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

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 TRUE1;
1393}

1395/* Start adding a method to a class.  */

1397static bfd_boolean
1398pr_class_start_method (void *p, const char *name)
1399{
struct pr_handle *info = (struct pr_handle *) p;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1402, __func__, "info->stack != NULL"));
info->stack->method = name;
return TRUE1;
1405}

1407/* Add a variant to a method.  */

1409static bfd_boolean
1410pr_class_method_variant (void *p, const char *physname,
	 enum debug_visibility visibility,
	 bfd_boolean constp, bfd_boolean volatilep,
	 bfd_vma voffset, bfd_boolean context)
1414{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
char *context_type;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1419, __func__, "info->stack != NULL"));
assert (info->stack->next != NULL)((info->stack->next != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c", 1420,
 __func__, "info->stack->next != NULL"));

/* Put the const and volatile qualifiers on the type.  */
if (volatilep)
  {
    if (! append_type (info, " volatile"))
return FALSE0;
  }
if (constp)
  {
    if (! append_type (info, " const"))
return FALSE0;
  }

/* Stick the name of the method into its type.  */
if (! substitute_type (info,
	 (context
	  ? info->stack->next->next->method
	  : info->stack->next->method)))
  return FALSE0;

/* Get the type.  */
method_type = pop_type (info);
if (method_type == NULL((void*)0))
  return FALSE0;

/* Pull off the context type if there is one.  */
if (! context)
  context_type = NULL((void*)0);
else
  {
    context_type = pop_type (info);
    if (context_type == NULL((void*)0))
return FALSE0;
  }

/* Now the top of the stack is the class.  */

if (! pr_fix_visibility (info, visibility))
  return FALSE0;

if (! append_type (info, method_type)
    || ! append_type (info, " /* ")
    || ! append_type (info, physname)
    || ! append_type (info, " "))
  return FALSE0;
if (context || voffset != 0)
  {
    char ab[20];

    if (context)
{
 if (! append_type (info, "context ")
     || ! append_type (info, context_type)
     || ! append_type (info, " "))
   return FALSE0;
}
    print_vma (voffset, ab, TRUE1, FALSE0);
    if (! append_type (info, "voffset ")
 || ! append_type (info, ab))
return FALSE0;
  }

return (append_type (info, " */;\n")
 && indent_type (info));
1485}

1487/* Add a static variant to a method.  */

1489static bfd_boolean
1490pr_class_static_method_variant (void *p, const char *physname,
		enum debug_visibility visibility,
		bfd_boolean constp, bfd_boolean volatilep)
1493{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1497, __func__, "info->stack != NULL"));
assert (info->stack->next != NULL)((info->stack->next != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c", 1498,
 __func__, "info->stack->next != NULL"));
assert (info->stack->next->method != NULL)((info->stack->next->method != ((void*)0)) ? (void)0
 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 1499, __func__, "info->stack->next->method != NULL"
));

/* Put the const and volatile qualifiers on the type.  */
if (volatilep)
  {
    if (! append_type (info, " volatile"))
return FALSE0;
  }
if (constp)
  {
    if (! append_type (info, " const"))
return FALSE0;
  }

/* Mark it as static.  */
if (! prepend_type (info, "static "))
  return FALSE0;

/* Stick the name of the method into its type.  */
if (! substitute_type (info, info->stack->next->method))
  return FALSE0;

/* Get the type.  */
method_type = pop_type (info);
if (method_type == NULL((void*)0))
  return FALSE0;

/* Now the top of the stack is the class.  */

if (! pr_fix_visibility (info, visibility))
  return FALSE0;

return (append_type (info, method_type)
 && append_type (info, " /* ")
 && append_type (info, physname)
 && append_type (info, " */;\n")
 && indent_type (info));
1536}

1538/* Finish up a method.  */

1540static bfd_boolean
1541pr_class_end_method (void *p)
1542{
struct pr_handle *info = (struct pr_handle *) p;

info->stack->method = NULL((void*)0);
return TRUE1;
1547}

1549/* Finish up a class.  */

1551static bfd_boolean
1552pr_end_class_type (void *p)
1553{
return pr_end_struct_type (p);
1555}

1557/* Push a type on the stack using a typedef name.  */

1559static bfd_boolean
1560pr_typedef_type (void *p, const char *name)
1561{
struct pr_handle *info = (struct pr_handle *) p;

return push_type (info, name);
1565}

1567/* Push a type on the stack using a tag name.  */

1569static bfd_boolean
1570pr_tag_type (void *p, const char *name, unsigned int id,
    enum debug_type_kind kind)
1572{
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 FALSE0;
  }

if (! push_type (info, t))
  return FALSE0;
if (name != NULL((void*)0))
  tag = name;
else
  {
    sprintf (idbuf, "%%anon%u", id);
    tag = idbuf;
  }

if (! append_type (info, tag))
  return FALSE0;
if (name != NULL((void*)0) && kind != DEBUG_KIND_ENUM)
  {
    sprintf (idbuf, " /* id %u */", id);
    if (! append_type (info, idbuf))
return FALSE0;
  }

return TRUE1;
1619}

1621/* Output a typedef.  */

1623static bfd_boolean
1624pr_typdef (void *p, const char *name)
1625{
struct pr_handle *info = (struct pr_handle *) p;
char *s;

if (! substitute_type (info, name))
  return FALSE0;

s = pop_type (info);
if (s == NULL((void*)0))
  return FALSE0;

indent (info);
fprintf (info->f, "typedef %s;\n", s);

free (s);

return TRUE1;
1642}

1644/* 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.  */

1647static bfd_boolean
1648pr_tag (void *p, const char *name ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1649{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

indent (info);
fprintf (info->f, "%s;\n", t);

free (t);

return TRUE1;
1663}

1665/* Output an integer constant.  */

1667static bfd_boolean
1668pr_int_constant (void *p, const char *name, bfd_vma val)
1669{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];

indent (info);
print_vma (val, ab, FALSE0, FALSE0);
fprintf (info->f, "const int %s = %s;\n", name, ab);
return TRUE1;
1677}

1679/* Output a floating point constant.  */

1681static bfd_boolean
1682pr_float_constant (void *p, const char *name, double val)
1683{
struct pr_handle *info = (struct pr_handle *) p;

indent (info);
fprintf (info->f, "const double %s = %g;\n", name, val);
return TRUE1;
1689}

1691/* Output a typed constant.  */

1693static bfd_boolean
1694pr_typed_constant (void *p, const char *name, bfd_vma val)
1695{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

indent (info);
print_vma (val, ab, FALSE0, FALSE0);
fprintf (info->f, "const %s %s = %s;\n", t, name, ab);

free (t);

return TRUE1;
1711}

1713/* Output a variable.  */

1715static bfd_boolean
1716pr_variable (void *p, const char *name, enum debug_var_kind kind,
    bfd_vma val)
1718{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];

if (! substitute_type (info, name))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

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, TRUE1, TRUE1);
fprintf (info->f, "%s /* %s */;\n", t, ab);

free (t);

return TRUE1;
1749}

1751/* Start outputting a function.  */

1753static bfd_boolean
1754pr_start_function (void *p, const char *name, bfd_boolean global)
1755{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

if (! substitute_type (info, name))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

indent (info);
if (! global)
  fprintf (info->f, "static ");
fprintf (info->f, "%s (", t);

info->parameter = 1;

return TRUE1;
1774}

1776/* Output a function parameter.  */

1778static bfd_boolean
1779pr_function_parameter (void *p, const char *name,
       enum debug_parm_kind kind, bfd_vma val)
1781{
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 FALSE0;
  }

if (! substitute_type (info, name))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

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, TRUE1, TRUE1);
fprintf (info->f, "%s /* %s */", t, ab);

free (t);

++info->parameter;

return TRUE1;
1814}

1816/* Start writing out a block.  */

1818static bfd_boolean
1819pr_start_block (void *p, bfd_vma addr)
1820{
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, TRUE1, TRUE1);
fprintf (info->f, "{ /* %s */\n", ab);

info->indent += 2;

return TRUE1;
1837}

1839/* Write out line number information.  */

1841static bfd_boolean
1842pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
1843{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];

indent (info);
print_vma (addr, ab, TRUE1, TRUE1);
fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);

return TRUE1;
1852}

1854/* Finish writing out a block.  */

1856static bfd_boolean
1857pr_end_block (void *p, bfd_vma addr)
1858{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];

info->indent -= 2;

indent (info);
print_vma (addr, ab, TRUE1, TRUE1);
fprintf (info->f, "} /* %s */\n", ab);

return TRUE1;
1869}

1871/* Finish writing out a function.  */

1873static bfd_boolean
1874pr_end_function (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1875{
return TRUE1;
1877}
1878
1879/* Tags style generation functions start here.  */

1881/* Variables for address to line translation.  */
1882static bfd_vma pc;
1883static const char *filename;
1884static const char *functionname;
1885static unsigned int line;
1886static bfd_boolean found;

1888/* Look for an address in a section.  This is called via
 bfd_map_over_sections.  */

1891static void
1892find_address_in_section (bfd *abfd, asection *section, void *data)
1893{
bfd_vma vma;
bfd_size_type size;
asymbol **syms = (asymbol **) data;

if (found)
  return;

if ((bfd_get_section_flags (abfd, section)((section)->flags + 0) & SEC_ALLOC0x001) == 0)
  return;

vma = bfd_get_section_vma (abfd, section)((section)->vma + 0);
if (pc < vma)
  return;

size = bfd_get_section_size (section)((section)->size);
if (pc >= vma + size)
  return;

found = bfd_find_nearest_line (abfd, section, syms, pc - vma,((*((abfd)->xvec->_bfd_find_nearest_line)) (abfd, section
, syms, pc - vma, &filename, &functionname, &line
))
		 &filename, &functionname, &line)((*((abfd)->xvec->_bfd_find_nearest_line)) (abfd, section
, syms, pc - vma, &filename, &functionname, &line
));
1914}

1916static void
1917translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
1918{
pc = bfd_scan_vma (addr_hex, NULL((void*)0), 16);
found = FALSE0;
bfd_map_over_sections (abfd, find_address_in_section, syms);

if (! found)
  fprintf (f, "??");
else
  fprintf (f, "%u", line);
1927}

1929/* Start a new compilation unit.  */

1931static bfd_boolean
1932tg_start_compilation_unit (void * p, const char *filename ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1933{
struct pr_handle *info = (struct pr_handle *) p;

fprintf (stderr(&__sF[2]), "New compilation unit: %s\n", filename);

free (info->filename);
/* Should it be relative? best way to do it here?.  */
info->filename = strdup (filename);

return TRUE1;
1943}

1945/* Start a source file within a compilation unit.  */

1947static bfd_boolean
1948tg_start_source (void *p, const char *filename)
1949{
struct pr_handle *info = (struct pr_handle *) p;

free (info->filename);
/* Should it be relative? best way to do it here?.  */
info->filename = strdup (filename);

return TRUE1;
1957}

1959/* Push an enum type onto the type stack.  */

1961static bfd_boolean
1962tg_enum_type (void *p, const char *tag, const char **names,
     bfd_signed_vma *values)
1964{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int i;
const char *name;
char ab[20];

if (! pr_enum_type (p, tag, names, values))
  return FALSE0;

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((void*)0))
  {
    for (i = 0; names[i] != NULL((void*)0); i++)
{
 print_vma (values[i], ab, FALSE0, FALSE0);
 fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
   names[i], info->filename, name, ab);
}
  }

return TRUE1;
1991}

1993/* Start accumulating a struct type.  */

1995static bfd_boolean
1996tg_start_struct_type (void *p, const char *tag, unsigned int id,
      bfd_boolean structp,
      unsigned int size ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1999{
struct pr_handle *info = (struct pr_handle *) p;
const char *name;
char idbuf[20];

if (tag != NULL((void*)0))
  name = tag;
else
  {
    name = idbuf;
    sprintf (idbuf, "%%anon%u", id);
  }

if (! push_type (info, name))
  return FALSE0;

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);
2023}

2025/* Output the visibility of a field in a struct.  */

2027static bfd_boolean
2028tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
2029{
assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2030, __func__, "info->stack != NULL"));

if (info->stack->visibility == visibility)
  return TRUE1;

assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE)((info->stack->visibility != DEBUG_VISIBILITY_IGNORE) ?
 (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2035, __func__, "info->stack->visibility != DEBUG_VISIBILITY_IGNORE"
));

info->stack->visibility = visibility;

return TRUE1;
2040}

2042/* Add a field to a struct type.  */

2044static bfd_boolean
2045tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 bfd_vma bitsize ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 enum debug_visibility visibility)
2048{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (! tg_fix_visibility (info, visibility))
  return FALSE0;

/* It happens, a bug? */
if (! name[0])
  return TRUE1;

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 TRUE1;
2068}

2070/* Finish a struct type.  */

2072static bfd_boolean
2073tg_end_struct_type (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2074{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2076, __func__, "info->stack != NULL"));

return TRUE1;
2079}

2081/* Start a class type.  */

2083static bfd_boolean
2084tg_start_class_type (void *p, const char *tag, unsigned int id,
     bfd_boolean structp, unsigned int size,
     bfd_boolean vptr, bfd_boolean ownvptr)
2087{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL((void*)0);
const char *name;

info->indent += 2;

if (vptr && ! ownvptr)
  {
    tv = pop_type (info);
    if (tv == NULL((void*)0))
return FALSE0;
  }

if (tag != NULL((void*)0))
  name = tag;
else
  {
    char idbuf[20];

    sprintf (idbuf, "%%anon%u", id);
    name = idbuf;
  }

if (! push_type (info, name))
  return FALSE0;

info->stack->flavor = structp ? "class" : "union class";
info->stack->parents = NULL((void*)0);
info->stack->num_parents = 0;

if (size != 0 || vptr || ownvptr || tag != NULL((void*)0))
  {
    if (vptr)
{
 if (! append_type (info, " vtable "))
   return FALSE0;
 if (ownvptr)
   {
     if (! append_type (info, "self "))
return FALSE0;
   }
 else
   {
     if (! append_type (info, tv)
  || ! append_type (info, " "))
return FALSE0;
   }
}
  }

info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;

return TRUE1;
2141}

2143/* Add a static member to a class.  */

2145static bfd_boolean
2146tg_class_static_member (void *p, const char *name,
	const char *physname ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	enum debug_visibility visibility)
2149{
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 FALSE0;
memcpy (full_name, info->stack->next->type, len_class);
memcpy (full_name + len_class, "::", 2);
memcpy (full_name + len_class + 2, name, len_var + 1);

if (! substitute_type (info, full_name))
  return FALSE0;

if (! prepend_type (info, "static "))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (! tg_fix_visibility (info, visibility))
  return FALSE0;

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 TRUE1;
2184}

2186/* Add a base class to a class.  */

2188static bfd_boolean
2189tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
    bfd_boolean virtual, enum debug_visibility visibility)
2191{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
const char *prefix;

assert (info->stack != NULL && info->stack->next != NULL)((info->stack != ((void*)0) && info->stack->
next != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2196, __func__, "info->stack != NULL && info->stack->next != NULL"
));

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

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 FALSE0;

if (virtual)
  {
    if (! prepend_type (info, "virtual "))
return FALSE0;
  }

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 FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (info->stack->num_parents && ! append_parent (info, ", "))
  return FALSE0;

if (! append_parent (info, t))
  return FALSE0;
info->stack->num_parents++;

free (t);

return TRUE1;
2249}

2251/* Add a variant to a method.  */

2253static bfd_boolean
2254tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	 enum debug_visibility visibility,
	 bfd_boolean constp, bfd_boolean volatilep,
	 bfd_vma voffset ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	 bfd_boolean context)
2259{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
char *context_type;
char *method_name;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2265, __func__, "info->stack != NULL"));
assert (info->stack->next != NULL)((info->stack->next != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c", 2266,
 __func__, "info->stack->next != NULL"));

/* Put the const and volatile qualifiers on the type.  */
if (volatilep)
  {
    if (! append_type (info, " volatile"))
return FALSE0;
  }
if (constp)
  {
    if (! append_type (info, " const"))
return FALSE0;
  }

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))
  return FALSE0;

/* Get the type.  */
method_type = pop_type (info);
if (method_type == NULL((void*)0))
  return FALSE0;

/* Pull off the context type if there is one.  */
if (! context)
  context_type = NULL((void*)0);
else
  {
    context_type = pop_type (info);
    if (context_type == NULL((void*)0))
return FALSE0;
  }

/* Now the top of the stack is the class.  */
if (! tg_fix_visibility (info, visibility))
  return FALSE0;

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 TRUE1;
2313}

2315/* Add a static variant to a method.  */

2317static bfd_boolean
2318tg_class_static_method_variant (void *p,
		const char *physname ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
		enum debug_visibility visibility,
		bfd_boolean constp, bfd_boolean volatilep)
2322{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
char *method_name;

assert (info->stack != NULL)((info->stack != ((void*)0)) ? (void)0 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2327, __func__, "info->stack != NULL"));
1
Assuming field 'stack' is not equal to null→
2
←
'?' condition is true→
assert (info->stack->next != NULL)((info->stack->next != ((void*)0)) ? (void)0 : __assert2
("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c", 2328,
 __func__, "info->stack->next != NULL"));
3
←
Assuming field 'next' is not equal to null→
4
←
'?' condition is true→
assert (info->stack->next->method != NULL)((info->stack->next->method != ((void*)0)) ? (void)0
 : __assert2("/usr/src/gnu/usr.bin/binutils-2.17/binutils/prdbg.c"
, 2329, __func__, "info->stack->next->method != NULL"
));
5
←
Assuming field 'method' is not equal to null→
6
←
'?' condition is true→

/* Put the const and volatile qualifiers on the type.  */
if (volatilep)
7
←
Assuming 'volatilep' is 0→
8
←
Taking false branch→
  {
    if (! append_type (info, " volatile"))
return FALSE0;
  }
if (constp)
9
←
Assuming 'constp' is 0→
10
←
Taking false branch→
  {
    if (! append_type (info, " const"))
return FALSE0;
  }

/* Mark it as static.  */
if (! prepend_type (info, "static "))
11
←
Taking false branch→
  return FALSE0;

method_name = strdup (info->stack->next->method);
12
←
Memory is allocated→
/* Stick the name of the method into its type.  */
if (! substitute_type (info, info->stack->next->method))
13
←
Taking false branch→
  return FALSE0;

/* Get the type.  */
method_type = pop_type (info);
if (method_type == NULL((void*)0))
14
←
Assuming 'method_type' is equal to NULL→
15
←
Taking true branch→
  return FALSE0;
16
←
Potential leak of memory pointed to by 'method_name'

/* Now the top of the stack is the class.  */
if (! tg_fix_visibility (info, visibility))
  return FALSE0;

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 TRUE1;
2368}

2370/* Finish up a class.  */

2372static bfd_boolean
2373tg_end_class_type (void *p)
2374{
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);
2387}

2389/* Push a type on the stack using a tag name.  */

2391static bfd_boolean
2392tg_tag_type (void *p, const char *name, unsigned int id,
    enum debug_type_kind kind)
2394{
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 FALSE0;
  }

if (! push_type (info, t))
  return FALSE0;
if (name != NULL((void*)0))
  tag = name;
else
  {
    sprintf (idbuf, "%%anon%u", id);
    tag = idbuf;
  }

if (! append_type (info, tag))
  return FALSE0;

return TRUE1;
2435}

2437/* Output a typedef.  */

2439static bfd_boolean
2440tg_typdef (void *p, const char *name)
2441{
struct pr_handle *info = (struct pr_handle *) p;
char *s;

s = pop_type (info);
if (s == NULL((void*)0))
  return FALSE0;

fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
  info->filename, s);

free (s);

return TRUE1;
2455}

2457/* 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.  */

2460static bfd_boolean
2461tg_tag (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)), const char *name ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2462{
struct pr_handle *info = (struct pr_handle *) p;
char *t;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;
free (t);

return TRUE1;
2472}

2474/* Output an integer constant.  */

2476static bfd_boolean
2477tg_int_constant (void *p, const char *name, bfd_vma val)
2478{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];

indent (info);
print_vma (val, ab, FALSE0, FALSE0);
fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
  name, info->filename, ab);
return TRUE1;
2487}

2489/* Output a floating point constant.  */

2491static bfd_boolean
2492tg_float_constant (void *p, const char *name, double val)
2493{
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 TRUE1;
2500}

2502/* Output a typed constant.  */

2504static bfd_boolean
2505tg_typed_constant (void *p, const char *name, bfd_vma val)
2506{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

indent (info);
print_vma (val, ab, FALSE0, FALSE0);
fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
  name, info->filename, t, ab);

free (t);

return TRUE1;
2523}

2525/* Output a variable.  */

2527static bfd_boolean
2528tg_variable (void *p, const char *name, enum debug_var_kind kind,
    bfd_vma val ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2530{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
const char *dname, *from_class;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

dname = name;
if (info->demangler)
  {
    dname = info->demangler (info->abfd, name);
    if (strcmp (name, dname) == 0)
{
 free ((char *) dname);
 dname = name;
}
  }

if (dname != name)
  {
    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;
 from_class = NULL((void*)0);
}
  }
else
  from_class = NULL((void*)0);

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);
    free ((char *) dname);
  }

fprintf (info->f, "\n");

free (t);

return TRUE1;
2596}

2598/* Start outputting a function.  */

2600static bfd_boolean
2601tg_start_function (void *p, const char *name, bfd_boolean global)
2602{
struct pr_handle *info = (struct pr_handle *) p;
const char *dname;

if (! global)
  info->stack->flavor = "static";
else
  info->stack->flavor = NULL((void*)0);

dname = name;
if (info->demangler)
  {
    dname = info->demangler (info->abfd, name);
    if (strcmp (name, dname) == 0)
{
 free ((char *) dname);
 dname = name;
}
  }

if (! substitute_type (info, dname))
  return FALSE0;

if (dname != name)
  {
    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.  */
  }
else
  info->stack->method = NULL((void*)0);

info->stack->parents = strdup (name);

if (! info->stack->method && ! append_type (info, "("))
  return FALSE0;

info->parameter = 1;

return TRUE1;
2656}

2658/* Output a function parameter.  */

2660static bfd_boolean
2661tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
       bfd_vma val ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2663{
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 FALSE0;
  }

if (! substitute_type (info, name))
  return FALSE0;

t = pop_type (info);
if (t == NULL((void*)0))
  return FALSE0;

if (! info->stack->method)
  {
    if (info->parameter != 1 && ! append_type (info, ", "))
return FALSE0;

    if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
if (! append_type (info, "register "))
 return FALSE0;

    if (! append_type (info, t))
return FALSE0;
  }

free (t);

++info->parameter;

return TRUE1;
2699}

2701/* Start writing out a block.  */

2703static bfd_boolean
2704tg_start_block (void *p, bfd_vma addr)
2705{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20], 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, TRUE1, TRUE1);
    translate_addresses (info->abfd, ab, info->f, info->syms);
    local = info->stack->flavor != NULL((void*)0);
    if (info->stack->method && *info->stack->method)
{
 kind = 'm';
 partof = (char *) info->stack->method;
}
    else
{
 kind = 'f';
 partof = NULL((void*)0);
 if (! info->stack->method && ! append_type (info, ")"))
   return FALSE0;
}
    t = pop_type (info);
    if (t == NULL((void*)0))
return FALSE0;
    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 TRUE1;
2749}

2751/* Write out line number information.  */

2753static bfd_boolean
2754tg_lineno (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)), const char *filename ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  unsigned long lineno ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  bfd_vma addr ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2757{
return TRUE1;
2759}

2761/* Finish writing out a block.  */

2763static bfd_boolean
2764tg_end_block (void *p ATTRIBUTE_UNUSED__attribute__ ((__unused__)), bfd_vma addr ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2765{
return TRUE1;
2767}

2769/* Convert the visibility value into a human readable name.  */

2771static const char *
2772visibility_name (enum debug_visibility visibility)
2773{
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 FALSE0;
  }
return s;
2795}