/* prdbg.c -- Print out generic debugging information.
- Copyright (C) 1995, 1996, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1995-2021 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
+ Tags style generation written by Salvador E. Tropea <set@computer.org>.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
/* This file prints out the generic debugging information, by
supplying a set of routines to debug_write. */
-#include <stdio.h>
+#include "sysdep.h"
#include <assert.h>
-
#include "bfd.h"
-#include "bucomm.h"
#include "libiberty.h"
+#include "demangle.h"
#include "debug.h"
#include "budbg.h"
struct pr_stack *stack;
/* Parameter number we are about to output. */
int parameter;
+ /* The following are used only by the tags code (tg_). */
+ /* Name of the file we are using. */
+ char *filename;
+ /* The BFD. */
+ bfd *abfd;
+ /* The symbols table for this BFD. */
+ asymbol **syms;
+ /* Pointer to a function to demangle symbols. */
+ char *(*demangler) (bfd *, const char *, int);
};
/* The type stack. */
enum debug_visibility visibility;
/* Name of the current method we are handling. */
const char *method;
+ /* The following are used only by the tags code (tg_). */
+ /* Type for the container (struct, union, class, union class). */
+ const char *flavor;
+ /* A comma separated list of parent classes. */
+ char *parents;
+ /* How many parents contains parents. */
+ int num_parents;
};
-static void indent PARAMS ((struct pr_handle *));
-static boolean push_type PARAMS ((struct pr_handle *, const char *));
-static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
-static boolean append_type PARAMS ((struct pr_handle *, const char *));
-static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
-static boolean indent_type PARAMS ((struct pr_handle *));
-static char *pop_type PARAMS ((struct pr_handle *));
-static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
-static boolean pr_fix_visibility
- PARAMS ((struct pr_handle *, enum debug_visibility));
-
-static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
-static boolean pr_start_source PARAMS ((PTR, const char *));
-static boolean pr_empty_type PARAMS ((PTR));
-static boolean pr_void_type PARAMS ((PTR));
-static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
-static boolean pr_float_type PARAMS ((PTR, unsigned int));
-static boolean pr_complex_type PARAMS ((PTR, unsigned int));
-static boolean pr_bool_type PARAMS ((PTR, unsigned int));
-static boolean pr_enum_type
- PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
-static boolean pr_pointer_type PARAMS ((PTR));
-static boolean pr_function_type PARAMS ((PTR, int, boolean));
-static boolean pr_reference_type PARAMS ((PTR));
-static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
-static boolean pr_array_type
- PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
-static boolean pr_set_type PARAMS ((PTR, boolean));
-static boolean pr_offset_type PARAMS ((PTR));
-static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
-static boolean pr_const_type PARAMS ((PTR));
-static boolean pr_volatile_type PARAMS ((PTR));
-static boolean pr_start_struct_type
- PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
-static boolean pr_struct_field
- PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
-static boolean pr_end_struct_type PARAMS ((PTR));
-static boolean pr_start_class_type
- PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
- boolean));
-static boolean pr_class_static_member
- PARAMS ((PTR, const char *, const char *, enum debug_visibility));
-static boolean pr_class_baseclass
- PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
-static boolean pr_class_start_method PARAMS ((PTR, const char *));
-static boolean pr_class_method_variant
- PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
- bfd_vma, boolean));
-static boolean pr_class_static_method_variant
- PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
-static boolean pr_class_end_method PARAMS ((PTR));
-static boolean pr_end_class_type PARAMS ((PTR));
-static boolean pr_typedef_type PARAMS ((PTR, const char *));
-static boolean pr_tag_type
- PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
-static boolean pr_typdef PARAMS ((PTR, const char *));
-static boolean pr_tag PARAMS ((PTR, const char *));
-static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_float_constant PARAMS ((PTR, const char *, double));
-static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_variable
- PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
-static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
-static boolean pr_function_parameter
- PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
-static boolean pr_start_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_function PARAMS ((PTR));
-static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
-
+static void indent (struct pr_handle *);
+static bool push_type (struct pr_handle *, const char *);
+static bool prepend_type (struct pr_handle *, const char *);
+static bool append_type (struct pr_handle *, const char *);
+static bool substitute_type (struct pr_handle *, const char *);
+static bool indent_type (struct pr_handle *);
+static char *pop_type (struct pr_handle *);
+static void print_vma (bfd_vma, char *, bool, bool);
+static bool pr_fix_visibility (struct pr_handle *, enum debug_visibility);
+static bool pr_start_compilation_unit (void *, const char *);
+static bool pr_start_source (void *, const char *);
+static bool pr_empty_type (void *);
+static bool pr_void_type (void *);
+static bool pr_int_type (void *, unsigned int, bool);
+static bool pr_float_type (void *, unsigned int);
+static bool pr_complex_type (void *, unsigned int);
+static bool pr_bool_type (void *, unsigned int);
+static bool pr_enum_type
+ (void *, const char *, const char **, bfd_signed_vma *);
+static bool pr_pointer_type (void *);
+static bool pr_function_type (void *, int, bool);
+static bool pr_reference_type (void *);
+static bool pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
+static bool pr_array_type (void *, bfd_signed_vma, bfd_signed_vma, bool);
+static bool pr_set_type (void *, bool);
+static bool pr_offset_type (void *);
+static bool pr_method_type (void *, bool, int, bool);
+static bool pr_const_type (void *);
+static bool pr_volatile_type (void *);
+static bool pr_start_struct_type
+ (void *, const char *, unsigned int, bool, unsigned int);
+static bool pr_struct_field
+ (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bool pr_end_struct_type (void *);
+static bool pr_start_class_type
+ (void *, const char *, unsigned int, bool, unsigned int, bool, bool);
+static bool pr_class_static_member
+ (void *, const char *, const char *, enum debug_visibility);
+static bool pr_class_baseclass
+ (void *, bfd_vma, bool, enum debug_visibility);
+static bool pr_class_start_method (void *, const char *);
+static bool pr_class_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);
+static bool pr_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool);
+static bool pr_class_end_method (void *);
+static bool pr_end_class_type (void *);
+static bool pr_typedef_type (void *, const char *);
+static bool pr_tag_type
+ (void *, const char *, unsigned int, enum debug_type_kind);
+static bool pr_typdef (void *, const char *);
+static bool pr_tag (void *, const char *);
+static bool pr_int_constant (void *, const char *, bfd_vma);
+static bool pr_float_constant (void *, const char *, double);
+static bool pr_typed_constant (void *, const char *, bfd_vma);
+static bool pr_variable (void *, const char *, enum debug_var_kind, bfd_vma);
+static bool pr_start_function (void *, const char *, bool);
+static bool pr_function_parameter
+ (void *, const char *, enum debug_parm_kind, bfd_vma);
+static bool pr_start_block (void *, bfd_vma);
+static bool pr_end_block (void *, bfd_vma);
+static bool pr_end_function (void *);
+static bool pr_lineno (void *, const char *, unsigned long, bfd_vma);
+static bool append_parent (struct pr_handle *, const char *);
+/* Only used by tg_ code. */
+static bool tg_fix_visibility
+ (struct pr_handle *, enum debug_visibility);
+static void find_address_in_section (bfd *, asection *, void *);
+static void translate_addresses (bfd *, char *, FILE *, asymbol **);
+static const char *visibility_name (enum debug_visibility);
+/* Tags style replacements. */
+static bool tg_start_compilation_unit (void *, const char *);
+static bool tg_start_source (void *, const char *);
+static bool tg_enum_type
+ (void *, const char *, const char **, bfd_signed_vma *);
+static bool tg_start_struct_type
+ (void *, const char *, unsigned int, bool, unsigned int);
+static bool pr_struct_field
+ (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bool tg_struct_field
+ (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bool tg_struct_field
+ (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
+static bool tg_end_struct_type (void *);
+static bool tg_start_class_type
+ (void *, const char *, unsigned int, bool, unsigned int, bool, bool);
+static bool tg_class_static_member
+ (void *, const char *, const char *, enum debug_visibility);
+static bool tg_class_baseclass (void *, bfd_vma, bool, enum debug_visibility);
+static bool tg_class_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);
+static bool tg_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool);
+static bool tg_end_class_type (void *);
+static bool tg_tag_type
+ (void *, const char *, unsigned int, enum debug_type_kind);
+static bool tg_typdef (void *, const char *);
+static bool tg_tag (void *, const char *);
+static bool tg_int_constant (void *, const char *, bfd_vma);
+static bool tg_float_constant (void *, const char *, double);
+static bool tg_typed_constant (void *, const char *, bfd_vma);
+static bool tg_variable (void *, const char *, enum debug_var_kind, bfd_vma);
+static bool tg_start_function (void *, const char *, bool);
+static bool tg_function_parameter
+ (void *, const char *, enum debug_parm_kind, bfd_vma);
+static bool tg_start_block (void *, bfd_vma);
+static bool tg_end_block (void *, bfd_vma);
+static bool tg_lineno (void *, const char *, unsigned long, bfd_vma);
+\f
static const struct debug_write_fns pr_fns =
{
pr_start_compilation_unit,
pr_lineno
};
\f
+static const struct debug_write_fns tg_fns =
+{
+ tg_start_compilation_unit,
+ tg_start_source,
+ pr_empty_type, /* Same, push_type. */
+ pr_void_type, /* Same, push_type. */
+ pr_int_type, /* Same, push_type. */
+ pr_float_type, /* Same, push_type. */
+ pr_complex_type, /* Same, push_type. */
+ pr_bool_type, /* Same, push_type. */
+ tg_enum_type,
+ pr_pointer_type, /* Same, changes to pointer. */
+ pr_function_type, /* Same, push_type. */
+ pr_reference_type, /* Same, changes to reference. */
+ pr_range_type, /* FIXME: What's that?. */
+ pr_array_type, /* Same, push_type. */
+ pr_set_type, /* FIXME: What's that?. */
+ pr_offset_type, /* FIXME: What's that?. */
+ pr_method_type, /* Same. */
+ pr_const_type, /* Same, changes to const. */
+ pr_volatile_type, /* Same, changes to volatile. */
+ tg_start_struct_type,
+ tg_struct_field,
+ tg_end_struct_type,
+ tg_start_class_type,
+ tg_class_static_member,
+ tg_class_baseclass,
+ pr_class_start_method, /* Same, remembers that's a method. */
+ tg_class_method_variant,
+ tg_class_static_method_variant,
+ pr_class_end_method, /* Same, forgets that's a method. */
+ tg_end_class_type,
+ pr_typedef_type, /* Same, just push type. */
+ tg_tag_type,
+ tg_typdef,
+ tg_tag,
+ tg_int_constant, /* Untested. */
+ tg_float_constant, /* Untested. */
+ tg_typed_constant, /* Untested. */
+ tg_variable,
+ tg_start_function,
+ tg_function_parameter,
+ tg_start_block,
+ tg_end_block,
+ pr_end_function, /* Same, does nothing. */
+ tg_lineno
+};
+
+static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
+\f
/* Print out the generic debugging information recorded in dhandle. */
-boolean
-print_debugging_info (f, dhandle)
- FILE *f;
- PTR dhandle;
+bool
+print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
+ char * (*demangler) (struct bfd *, const char *, int),
+ bool as_tags)
{
struct pr_handle info;
info.indent = 0;
info.stack = NULL;
info.parameter = 0;
+ info.filename = NULL;
+ info.abfd = abfd;
+ info.syms = syms;
+ info.demangler = demangler;
+
+ if (as_tags)
+ {
+ fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);
+ fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);
+ fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);
+ fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);
+ }
- return debug_write (dhandle, &pr_fns, (PTR) &info);
+ return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
+ : debug_write (dhandle, &pr_fns, (void *) & info);
}
\f
/* Indent to the current indentation level. */
static void
-indent (info)
- struct pr_handle *info;
+indent (struct pr_handle *info)
{
unsigned int i;
/* Push a type on the type stack. */
-static boolean
-push_type (info, type)
- struct pr_handle *info;
- const char *type;
+static bool
+push_type (struct pr_handle *info, const char *type)
{
struct pr_stack *n;
/* Prepend a string onto the type on the top of the type stack. */
-static boolean
-prepend_type (info, s)
- struct pr_handle *info;
- const char *s;
+static bool
+prepend_type (struct pr_handle *info, const char *s)
{
char *n;
/* Append a string to the type on the top of the type stack. */
-static boolean
-append_type (info, s)
- struct pr_handle *info;
- const char *s;
+static bool
+append_type (struct pr_handle *info, const char *s)
{
unsigned int len;
return true;
}
+/* Append a string to the parents on the top of the type stack. */
+
+static bool
+append_parent (struct pr_handle *info, const char *s)
+{
+ unsigned int len;
+
+ if (s == NULL)
+ return false;
+
+ assert (info->stack != NULL);
+
+ len = info->stack->parents ? strlen (info->stack->parents) : 0;
+ info->stack->parents = (char *) xrealloc (info->stack->parents,
+ len + strlen (s) + 1);
+ strcpy (info->stack->parents + len, s);
+
+ return true;
+}
+
/* We use an underscore to indicate where the name should go in a type
string. This function substitutes a string for the underscore. If
there is no underscore, the name follows the type. */
-static boolean
-substitute_type (info, s)
- struct pr_handle *info;
- const char *s;
+static bool
+substitute_type (struct pr_handle *info, const char *s)
{
char *u;
/* Indent the type at the top of the stack by appending spaces. */
-static boolean
-indent_type (info)
- struct pr_handle *info;
+static bool
+indent_type (struct pr_handle *info)
{
unsigned int i;
/* Pop a type from the type stack. */
static char *
-pop_type (info)
- struct pr_handle *info;
+pop_type (struct pr_handle *info)
{
struct pr_stack *o;
char *ret;
/* Print a VMA value into a string. */
static void
-print_vma (vma, buf, unsignedp, hexp)
- bfd_vma vma;
- char *buf;
- boolean unsignedp;
- boolean hexp;
+print_vma (bfd_vma vma, char *buf, bool unsignedp, bool hexp)
{
if (sizeof (vma) <= sizeof (unsigned long))
{
else
sprintf (buf, "%ld", (long) vma);
}
+#if BFD_HOST_64BIT_LONG_LONG
+ else if (sizeof (vma) <= sizeof (unsigned long long))
+ {
+#ifndef __MSVCRT__
+ if (hexp)
+ sprintf (buf, "0x%llx", (unsigned long long) vma);
+ else if (unsignedp)
+ sprintf (buf, "%llu", (unsigned long long) vma);
+ else
+ sprintf (buf, "%lld", (long long) vma);
+#else
+ if (hexp)
+ sprintf (buf, "0x%I64x", (unsigned long long) vma);
+ else if (unsignedp)
+ sprintf (buf, "%I64u", (unsigned long long) vma);
+ else
+ sprintf (buf, "%I64d", (long long) vma);
+#endif
+ }
+#endif
else
{
buf[0] = '0';
\f
/* Start a new compilation unit. */
-static boolean
-pr_start_compilation_unit (p, filename)
- PTR p;
- const char *filename;
+static bool
+pr_start_compilation_unit (void *p, const char *filename)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Start a source file within a compilation unit. */
-static boolean
-pr_start_source (p, filename)
- PTR p;
- const char *filename;
+static bool
+pr_start_source (void *p, const char *filename)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push an empty type onto the type stack. */
-static boolean
-pr_empty_type (p)
- PTR p;
+static bool
+pr_empty_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a void type onto the type stack. */
-static boolean
-pr_void_type (p)
- PTR p;
+static bool
+pr_void_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push an integer type onto the type stack. */
-static boolean
-pr_int_type (p, size, unsignedp)
- PTR p;
- unsigned int size;
- boolean unsignedp;
+static bool
+pr_int_type (void *p, unsigned int size, bool unsignedp)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[10];
+ char ab[40];
sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
return push_type (info, ab);
/* Push a floating type onto the type stack. */
-static boolean
-pr_float_type (p, size)
- PTR p;
- unsigned int size;
+static bool
+pr_float_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[10];
+ char ab[40];
if (size == 4)
return push_type (info, "float");
/* Push a complex type onto the type stack. */
-static boolean
-pr_complex_type (p, size)
- PTR p;
- unsigned int size;
+static bool
+pr_complex_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
return prepend_type (info, "complex ");
}
-/* Push a boolean type onto the type stack. */
+/* Push a bool type onto the type stack. */
-static boolean
-pr_bool_type (p, size)
- PTR p;
- unsigned int size;
+static bool
+pr_bool_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[10];
+ char ab[40];
sprintf (ab, "bool%d", size * 8);
/* Push an enum type onto the type stack. */
-static boolean
-pr_enum_type (p, tag, names, values)
- PTR p;
- const char *tag;
- const char **names;
- bfd_signed_vma *values;
+static bool
+pr_enum_type (void *p, const char *tag, const char **names,
+ bfd_signed_vma *values)
{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int i;
if (values[i] != val)
{
- char ab[20];
+ char ab[22];
print_vma (values[i], ab, false, false);
if (! append_type (info, " = ")
/* Turn the top type on the stack into a pointer. */
-static boolean
-pr_pointer_type (p)
- PTR p;
+static bool
+pr_pointer_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
/* Turn the top type on the stack into a function returning that type. */
-static boolean
-pr_function_type (p, argcount, varargs)
- PTR p;
- int argcount;
- boolean varargs;
+static bool
+pr_function_type (void *p, int argcount, bool varargs)
{
struct pr_handle *info = (struct pr_handle *) p;
char **arg_types;
for (i = argcount - 1; i >= 0; i--)
{
if (! substitute_type (info, ""))
- return false;
+ {
+ free (arg_types);
+ return false;
+ }
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
- return false;
+ {
+ free (arg_types);
+ return false;
+ }
len += strlen (arg_types[i]) + 2;
}
if (varargs)
/* Turn the top type on the stack into a reference to that type. */
-static boolean
-pr_reference_type (p)
- PTR p;
+static bool
+pr_reference_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Make a range type. */
-static boolean
-pr_range_type (p, lower, upper)
- PTR p;
- bfd_signed_vma lower;
- bfd_signed_vma upper;
+static bool
+pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
{
struct pr_handle *info = (struct pr_handle *) p;
- char abl[20], abu[20];
+ char abl[22], abu[22];
assert (info->stack != NULL);
/* Make an array type. */
-/*ARGSUSED*/
-static boolean
-pr_array_type (p, lower, upper, stringp)
- PTR p;
- bfd_signed_vma lower;
- bfd_signed_vma upper;
- boolean stringp;
+static bool
+pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
+ bool stringp)
{
struct pr_handle *info = (struct pr_handle *) p;
char *range_type;
- char abl[20], abu[20], ab[50];
+ char abl[22], abu[22], ab[50];
range_type = pop_type (info);
if (range_type == NULL)
/* Make a set type. */
-/*ARGSUSED*/
-static boolean
-pr_set_type (p, bitstringp)
- PTR p;
- boolean bitstringp;
+static bool
+pr_set_type (void *p, bool bitstringp)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Make an offset type. */
-static boolean
-pr_offset_type (p)
- PTR p;
+static bool
+pr_offset_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
/* Make a method type. */
-static boolean
-pr_method_type (p, domain, argcount, varargs)
- PTR p;
- boolean domain;
- int argcount;
- boolean varargs;
+static bool
+pr_method_type (void *p, bool domain, int argcount, bool varargs)
{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int len;
domain_type = pop_type (info);
if (domain_type == NULL)
return false;
- if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
+ if (startswith (domain_type, "class ")
&& strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
domain_type += sizeof "class " - 1;
- else if (strncmp (domain_type, "union class ",
- sizeof "union class ") == 0
+ else if (startswith (domain_type, "union class ")
&& (strchr (domain_type + sizeof "union class " - 1, ' ')
== NULL))
domain_type += sizeof "union class " - 1;
for (i = argcount - 1; i >= 0; i--)
{
if (! substitute_type (info, ""))
- return false;
+ {
+ free (arg_types);
+ return false;
+ }
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
- return false;
+ {
+ free (arg_types);
+ return false;
+ }
len += strlen (arg_types[i]) + 2;
}
if (varargs)
/* Make a const qualified type. */
-static boolean
-pr_const_type (p)
- PTR p;
+static bool
+pr_const_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Make a volatile qualified type. */
-static boolean
-pr_volatile_type (p)
- PTR p;
+static bool
+pr_volatile_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Start accumulating a struct type. */
-static boolean
-pr_start_struct_type (p, tag, id, structp, size)
- PTR p;
- const char *tag;
- unsigned int id;
- boolean structp;
- unsigned int size;
+static bool
+pr_start_struct_type (void *p, const char *tag, unsigned int id,
+ bool structp, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Output the visibility of a field in a struct. */
-static boolean
-pr_fix_visibility (info, visibility)
- struct pr_handle *info;
- enum debug_visibility visibility;
+static bool
+pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
{
const char *s = NULL;
char *t;
if (info->stack->visibility == visibility)
return true;
- assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
-
switch (visibility)
{
case DEBUG_VISIBILITY_PUBLIC:
/* Add a field to a struct type. */
-static boolean
-pr_struct_field (p, name, bitpos, bitsize, visibility)
- PTR p;
- const char *name;
- bfd_vma bitpos;
- bfd_vma bitsize;
- enum debug_visibility visibility;
+static bool
+pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
+ enum debug_visibility visibility)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[20];
+ char ab[22];
char *t;
if (! substitute_type (info, name))
/* Finish a struct type. */
-static boolean
-pr_end_struct_type (p)
- PTR p;
+static bool
+pr_end_struct_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
/* Start a class type. */
-static boolean
-pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
- PTR p;
- const char *tag;
- unsigned int id;
- boolean structp;
- unsigned int size;
- boolean vptr;
- boolean ownvptr;
+static bool
+pr_start_class_type (void *p, const char *tag, unsigned int id,
+ bool structp, unsigned int size,
+ bool vptr, bool ownvptr)
{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL;
/* Add a static member to a class. */
-static boolean
-pr_class_static_member (p, name, physname, visibility)
- PTR p;
- const char *name;
- const char *physname;
- enum debug_visibility visibility;
+static bool
+pr_class_static_member (void *p, const char *name, const char *physname,
+ enum debug_visibility visibility)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
/* Add a base class to a class. */
-static boolean
-pr_class_baseclass (p, bitpos, virtual, visibility)
- PTR p;
- bfd_vma bitpos;
- boolean virtual;
- enum debug_visibility visibility;
+static bool
+pr_class_baseclass (void *p, bfd_vma bitpos, bool is_virtual,
+ enum debug_visibility visibility)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
const char *prefix;
- char ab[20];
+ char ab[22];
char *s, *l, *n;
assert (info->stack != NULL && info->stack->next != NULL);
if (t == NULL)
return false;
- if (strncmp (t, "class ", sizeof "class " - 1) == 0)
+ if (startswith (t, "class "))
t += sizeof "class " - 1;
/* Push it back on to take advantage of the prepend_type and
if (! push_type (info, t))
return false;
- if (virtual)
+ if (is_virtual)
{
if (! prepend_type (info, "virtual "))
return false;
/* Start adding a method to a class. */
-static boolean
-pr_class_start_method (p, name)
- PTR p;
- const char *name;
+static bool
+pr_class_start_method (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Add a variant to a method. */
-static boolean
-pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
- context)
- PTR p;
- const char *physname;
- enum debug_visibility visibility;
- boolean constp;
- boolean volatilep;
- bfd_vma voffset;
- boolean context;
+static bool
+pr_class_method_variant (void *p, const char *physname,
+ enum debug_visibility visibility,
+ bool constp, bool volatilep,
+ bfd_vma voffset, bool context)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
return false;
if (context || voffset != 0)
{
- char ab[20];
+ char ab[22];
if (context)
{
/* Add a static variant to a method. */
-static boolean
-pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
- PTR p;
- const char *physname;
- enum debug_visibility visibility;
- boolean constp;
- boolean volatilep;
+static bool
+pr_class_static_method_variant (void *p, const char *physname,
+ enum debug_visibility visibility,
+ bool constp, bool volatilep)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
/* Finish up a method. */
-static boolean
-pr_class_end_method (p)
- PTR p;
+static bool
+pr_class_end_method (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Finish up a class. */
-static boolean
-pr_end_class_type (p)
- PTR p;
+static bool
+pr_end_class_type (void *p)
{
return pr_end_struct_type (p);
}
/* Push a type on the stack using a typedef name. */
-static boolean
-pr_typedef_type (p, name)
- PTR p;
- const char *name;
+static bool
+pr_typedef_type (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a type on the stack using a tag name. */
-static boolean
-pr_tag_type (p, name, id, kind)
- PTR p;
- const char *name;
- unsigned int id;
- enum debug_type_kind kind;
+static bool
+pr_tag_type (void *p, const char *name, unsigned int id,
+ enum debug_type_kind kind)
{
struct pr_handle *info = (struct pr_handle *) p;
const char *t, *tag;
- char idbuf[20];
+ char idbuf[22];
switch (kind)
{
t = "union class ";
break;
default:
- abort ();
+ /* PR 25625: Corrupt input can trigger this case. */
return false;
}
/* Output a typedef. */
-static boolean
-pr_typdef (p, name)
- PTR p;
- const char *name;
+static bool
+pr_typdef (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
/* 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 ATTRIBUTE_UNUSED;
+static bool
+pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
/* Output an integer constant. */
-static boolean
-pr_int_constant (p, name, val)
- PTR p;
- const char *name;
- bfd_vma val;
+static bool
+pr_int_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[20];
+ char ab[22];
indent (info);
print_vma (val, ab, false, false);
/* Output a floating point constant. */
-static boolean
-pr_float_constant (p, name, val)
- PTR p;
- const char *name;
- double val;
+static bool
+pr_float_constant (void *p, const char *name, double val)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Output a typed constant. */
-static boolean
-pr_typed_constant (p, name, val)
- PTR p;
- const char *name;
- bfd_vma val;
+static bool
+pr_typed_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
- char ab[20];
+ char ab[22];
t = pop_type (info);
if (t == NULL)
/* Output a variable. */
-static boolean
-pr_variable (p, name, kind, val)
- PTR p;
- const char *name;
- enum debug_var_kind kind;
- bfd_vma val;
+static bool
+pr_variable (void *p, const char *name, enum debug_var_kind kind,
+ bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
- char ab[20];
+ char ab[22];
if (! substitute_type (info, name))
return false;
/* Start outputting a function. */
-static boolean
-pr_start_function (p, name, global)
- PTR p;
- const char *name;
- boolean global;
+static bool
+pr_start_function (void *p, const char *name, bool global)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
/* Output a function parameter. */
-static boolean
-pr_function_parameter (p, name, kind, val)
- PTR p;
- const char *name;
- enum debug_parm_kind kind;
- bfd_vma val;
+static bool
+pr_function_parameter (void *p, const char *name,
+ enum debug_parm_kind kind, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
- char ab[20];
+ char ab[22];
if (kind == DEBUG_PARM_REFERENCE
|| kind == DEBUG_PARM_REF_REG)
/* Start writing out a block. */
-static boolean
-pr_start_block (p, addr)
- PTR p;
- bfd_vma addr;
+static bool
+pr_start_block (void *p, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[20];
+ char ab[22];
if (info->parameter > 0)
{
/* Write out line number information. */
-static boolean
-pr_lineno (p, filename, lineno, addr)
- PTR p;
- const char *filename;
- unsigned long lineno;
- bfd_vma addr;
+static bool
+pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[20];
+ char ab[22];
indent (info);
print_vma (addr, ab, true, true);
/* Finish writing out a block. */
-static boolean
-pr_end_block (p, addr)
- PTR p;
- bfd_vma addr;
+static bool
+pr_end_block (void *p, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
- char ab[20];
+ char ab[22];
info->indent -= 2;
/* Finish writing out a function. */
-/*ARGSUSED*/
-static boolean
-pr_end_function (p)
- PTR p ATTRIBUTE_UNUSED;
+static bool
+pr_end_function (void *p ATTRIBUTE_UNUSED)
+{
+ return true;
+}
+\f
+/* Tags style generation functions start here. */
+
+/* Variables for address to line translation. */
+static bfd_vma pc;
+static const char *filename;
+static const char *functionname;
+static unsigned int line;
+static bool found;
+
+/* Look for an address in a section. This is called via
+ bfd_map_over_sections. */
+
+static void
+find_address_in_section (bfd *abfd, asection *section, void *data)
+{
+ bfd_vma vma;
+ bfd_size_type size;
+ asymbol **syms = (asymbol **) data;
+
+ if (found)
+ return;
+
+ if ((bfd_section_flags (section) & SEC_ALLOC) == 0)
+ return;
+
+ vma = bfd_section_vma (section);
+ if (pc < vma)
+ return;
+
+ size = bfd_section_size (section);
+ if (pc >= vma + size)
+ return;
+
+ found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
+ &filename, &functionname, &line);
+}
+
+static void
+translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
+{
+ pc = bfd_scan_vma (addr_hex, NULL, 16);
+ found = false;
+ bfd_map_over_sections (abfd, find_address_in_section, syms);
+
+ if (! found)
+ fprintf (f, "??");
+ else
+ fprintf (f, "%u", line);
+}
+
+/* Start a new compilation unit. */
+
+static bool
+tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+
+ free (info->filename);
+ /* Should it be relative? best way to do it here?. */
+ info->filename = strdup (fname);
+
+ return true;
+}
+
+/* Start a source file within a compilation unit. */
+
+static bool
+tg_start_source (void *p, const char *fname)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+
+ free (info->filename);
+ /* Should it be relative? best way to do it here?. */
+ info->filename = strdup (fname);
+
+ return true;
+}
+
+/* Push an enum type onto the type stack. */
+
+static bool
+tg_enum_type (void *p, const char *tag, const char **names,
+ bfd_signed_vma *values)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ unsigned int i;
+ const char *name;
+ char ab[22];
+
+ if (! pr_enum_type (p, tag, names, values))
+ return false;
+
+ name = tag ? tag : "unknown";
+ /* Generate an entry for the enum. */
+ if (tag)
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag,
+ info->filename, info->stack->type);
+
+ /* Generate entries for the values. */
+ if (names != NULL)
+ {
+ for (i = 0; names[i] != NULL; i++)
+ {
+ print_vma (values[i], ab, false, false);
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
+ names[i], info->filename, name, ab);
+ }
+ }
+
+ return true;
+}
+
+/* Start accumulating a struct type. */
+
+static bool
+tg_start_struct_type (void *p, const char *tag, unsigned int id,
+ bool structp,
+ unsigned int size ATTRIBUTE_UNUSED)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ const char *name;
+ char idbuf[20];
+
+ if (tag != NULL)
+ name = tag;
+ else
+ {
+ name = idbuf;
+ sprintf (idbuf, "%%anon%u", id);
+ }
+
+ if (! push_type (info, name))
+ return false;
+
+ info->stack->flavor = structp ? "struct" : "union";
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename,
+ info->stack->flavor[0]);
+
+ info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
+
+ return indent_type (info);
+}
+
+/* Output the visibility of a field in a struct. */
+
+static bool
+tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
{
+ assert (info->stack != NULL);
+
+ if (info->stack->visibility == visibility)
+ return true;
+
+ assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
+
+ info->stack->visibility = visibility;
+
+ return true;
+}
+
+/* Add a field to a struct type. */
+
+static bool
+tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
+ bfd_vma bitsize ATTRIBUTE_UNUSED,
+ enum debug_visibility visibility)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ if (! tg_fix_visibility (info, visibility))
+ return false;
+
+ /* It happens, a bug? */
+ if (! name[0])
+ return true;
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
+ name, info->filename, t, info->stack->flavor, info->stack->type,
+ visibility_name (visibility));
+
+ return true;
+}
+
+/* Finish a struct type. */
+
+static bool
+tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
+{
+ assert (((struct pr_handle *) p)->stack != NULL);
+
+ return true;
+}
+
+/* Start a class type. */
+
+static bool
+tg_start_class_type (void *p, const char *tag, unsigned int id,
+ bool structp, unsigned int size,
+ bool vptr, bool ownvptr)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *tv = NULL;
+ const char *name;
+ char idbuf[20];
+
+ info->indent += 2;
+
+ if (vptr && ! ownvptr)
+ {
+ tv = pop_type (info);
+ if (tv == NULL)
+ return false;
+ }
+
+ if (tag != NULL)
+ name = tag;
+ else
+ {
+ sprintf (idbuf, "%%anon%u", id);
+ name = idbuf;
+ }
+
+ if (! push_type (info, name))
+ return false;
+
+ info->stack->flavor = structp ? "class" : "union class";
+ info->stack->parents = NULL;
+ info->stack->num_parents = 0;
+
+ if (size != 0 || vptr || ownvptr || tag != NULL)
+ {
+ if (vptr)
+ {
+ if (! append_type (info, " vtable "))
+ return false;
+ if (ownvptr)
+ {
+ if (! append_type (info, "self "))
+ return false;
+ }
+ else
+ {
+ if (! append_type (info, tv)
+ || ! append_type (info, " "))
+ return false;
+ }
+ }
+ }
+
+ info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
+
+ return true;
+}
+
+/* Add a static member to a class. */
+
+static bool
+tg_class_static_member (void *p, const char *name,
+ const char *physname ATTRIBUTE_UNUSED,
+ enum debug_visibility visibility)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+ int len_var, len_class;
+ char *full_name;
+
+ len_var = strlen (name);
+ len_class = strlen (info->stack->next->type);
+ full_name = (char *) xmalloc (len_var + len_class + 3);
+ if (! full_name)
+ return false;
+ sprintf (full_name, "%s::%s", info->stack->next->type, name);
+
+ if (! substitute_type (info, full_name))
+ {
+ free (full_name);
+ return false;
+ }
+
+ if (! prepend_type (info, "static "))
+ {
+ free (full_name);
+ return false;
+ }
+
+ t = pop_type (info);
+ if (t == NULL)
+ {
+ free (full_name);
+ return false;
+ }
+
+ if (! tg_fix_visibility (info, visibility))
+ {
+ free (t);
+ free (full_name);
+ return false;
+ }
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
+ name, info->filename, t, info->stack->type,
+ visibility_name (visibility));
+ free (t);
+ free (full_name);
+
return true;
}
+
+/* Add a base class to a class. */
+
+static bool
+tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
+ bool is_virtual, enum debug_visibility visibility)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+ const char *prefix;
+
+ assert (info->stack != NULL && info->stack->next != NULL);
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ if (startswith (t, "class "))
+ t += sizeof "class " - 1;
+
+ /* Push it back on to take advantage of the prepend_type and
+ append_type routines. */
+ if (! push_type (info, t))
+ return false;
+
+ if (is_virtual)
+ {
+ if (! prepend_type (info, "virtual "))
+ return false;
+ }
+
+ switch (visibility)
+ {
+ case DEBUG_VISIBILITY_PUBLIC:
+ prefix = "public ";
+ break;
+ case DEBUG_VISIBILITY_PROTECTED:
+ prefix = "protected ";
+ break;
+ case DEBUG_VISIBILITY_PRIVATE:
+ prefix = "private ";
+ break;
+ default:
+ prefix = "/* unknown visibility */ ";
+ break;
+ }
+
+ if (! prepend_type (info, prefix))
+ return false;
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ if (info->stack->num_parents && ! append_parent (info, ", "))
+ return false;
+
+ if (! append_parent (info, t))
+ return false;
+ info->stack->num_parents++;
+
+ free (t);
+
+ return true;
+}
+
+/* Add a variant to a method. */
+
+static bool
+tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
+ enum debug_visibility visibility,
+ bool constp, bool volatilep,
+ bfd_vma voffset ATTRIBUTE_UNUSED,
+ bool context)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *method_type;
+ char *context_type;
+ char *method_name;
+
+ assert (info->stack != NULL);
+ assert (info->stack->next != NULL);
+
+ /* Put the const and volatile qualifiers on the type. */
+ if (volatilep)
+ {
+ if (! append_type (info, " volatile"))
+ return false;
+ }
+ if (constp)
+ {
+ if (! append_type (info, " const"))
+ return false;
+ }
+
+ method_name = strdup (context ? info->stack->next->next->method
+ : info->stack->next->method);
+
+ /* Stick the name of the method into its type. */
+ if (! substitute_type (info, method_name))
+ {
+ free (method_name);
+ return false;
+ }
+
+ /* Get the type. */
+ method_type = pop_type (info);
+ if (method_type == NULL)
+ {
+ free (method_name);
+ return false;
+ }
+
+ /* Pull off the context type if there is one. */
+ if (! context)
+ context_type = NULL;
+ else
+ {
+ context_type = pop_type (info);
+ if (context_type == NULL)
+ {
+ free (method_type);
+ free (method_name);
+ return false;
+ }
+ }
+
+ /* Now the top of the stack is the class. */
+ if (! tg_fix_visibility (info, visibility))
+ {
+ free (method_type);
+ free (method_name);
+ free (context_type);
+ return false;
+ }
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
+ method_name, info->filename, method_type, info->stack->type);
+ free (method_type);
+ free (method_name);
+ free (context_type);
+
+ return true;
+}
+
+/* Add a static variant to a method. */
+
+static bool
+tg_class_static_method_variant (void *p,
+ const char *physname ATTRIBUTE_UNUSED,
+ enum debug_visibility visibility,
+ bool constp, bool volatilep)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *method_type;
+ char *method_name;
+
+ assert (info->stack != NULL);
+ assert (info->stack->next != NULL);
+ assert (info->stack->next->method != NULL);
+
+ /* Put the const and volatile qualifiers on the type. */
+ if (volatilep)
+ {
+ if (! append_type (info, " volatile"))
+ return false;
+ }
+ if (constp)
+ {
+ if (! append_type (info, " const"))
+ return false;
+ }
+
+ /* Mark it as static. */
+ if (! prepend_type (info, "static "))
+ return false;
+
+ method_name = strdup (info->stack->next->method);
+ /* Stick the name of the method into its type. */
+ if (! substitute_type (info, info->stack->next->method))
+ {
+ free (method_name);
+ return false;
+ }
+
+ /* Get the type. */
+ method_type = pop_type (info);
+ if (method_type == NULL)
+ {
+ free (method_name);
+ return false;
+ }
+
+ /* Now the top of the stack is the class. */
+ if (! tg_fix_visibility (info, visibility))
+ {
+ free (method_type);
+ free (method_name);
+ return false;
+ }
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
+ method_name, info->filename, method_type, info->stack->type,
+ visibility_name (visibility));
+ free (method_type);
+ free (method_name);
+
+ return true;
+}
+
+/* Finish up a class. */
+
+static bool
+tg_end_class_type (void *p)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type,
+ info->filename, info->stack->flavor);
+ if (info->stack->num_parents)
+ {
+ fprintf (info->f, "\tinherits:%s", info->stack->parents);
+ free (info->stack->parents);
+ }
+ fputc ('\n', info->f);
+
+ return tg_end_struct_type (p);
+}
+
+/* Push a type on the stack using a tag name. */
+
+static bool
+tg_tag_type (void *p, const char *name, unsigned int id,
+ enum debug_type_kind kind)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ const char *t, *tag;
+ char idbuf[20];
+
+ switch (kind)
+ {
+ case DEBUG_KIND_STRUCT:
+ t = "struct ";
+ break;
+ case DEBUG_KIND_UNION:
+ t = "union ";
+ break;
+ case DEBUG_KIND_ENUM:
+ t = "enum ";
+ break;
+ case DEBUG_KIND_CLASS:
+ t = "class ";
+ break;
+ case DEBUG_KIND_UNION_CLASS:
+ t = "union class ";
+ break;
+ default:
+ abort ();
+ return false;
+ }
+
+ if (! push_type (info, t))
+ return false;
+ if (name != NULL)
+ tag = name;
+ else
+ {
+ sprintf (idbuf, "%%anon%u", id);
+ tag = idbuf;
+ }
+
+ if (! append_type (info, tag))
+ return false;
+
+ return true;
+}
+
+/* Output a typedef. */
+
+static bool
+tg_typdef (void *p, const char *name)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *s;
+
+ s = pop_type (info);
+ if (s == NULL)
+ return false;
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
+ info->filename, s);
+
+ free (s);
+
+ return true;
+}
+
+/* Output a tag. The tag should already be in the string on the
+ stack, so all we have to do here is print it out. */
+
+static bool
+tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+ free (t);
+
+ return true;
+}
+
+/* Output an integer constant. */
+
+static bool
+tg_int_constant (void *p, const char *name, bfd_vma val)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char ab[22];
+
+ indent (info);
+ print_vma (val, ab, false, false);
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
+ name, info->filename, ab);
+ return true;
+}
+
+/* Output a floating point constant. */
+
+static bool
+tg_float_constant (void *p, const char *name, double val)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+
+ indent (info);
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
+ name, info->filename, val);
+ return true;
+}
+
+/* Output a typed constant. */
+
+static bool
+tg_typed_constant (void *p, const char *name, bfd_vma val)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+ char ab[22];
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ indent (info);
+ print_vma (val, ab, false, false);
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
+ name, info->filename, t, ab);
+
+ free (t);
+
+ return true;
+}
+
+/* Output a variable. */
+
+static bool
+tg_variable (void *p, const char *name, enum debug_var_kind kind,
+ bfd_vma val ATTRIBUTE_UNUSED)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t, *dname, *from_class;
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ dname = NULL;
+ if (info->demangler)
+ dname = info->demangler (info->abfd, name, demangle_flags);
+
+ from_class = NULL;
+ if (dname != NULL)
+ {
+ char *sep;
+ sep = strstr (dname, "::");
+ if (sep)
+ {
+ *sep = 0;
+ name = sep + 2;
+ from_class = dname;
+ }
+ else
+ /* Obscure types as vts and type_info nodes. */
+ name = dname;
+ }
+
+ fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t);
+
+ switch (kind)
+ {
+ case DEBUG_STATIC:
+ case DEBUG_LOCAL_STATIC:
+ fprintf (info->f, "\tfile:");
+ break;
+ case DEBUG_REGISTER:
+ fprintf (info->f, "\tregister:");
+ break;
+ default:
+ break;
+ }
+
+ if (from_class)
+ fprintf (info->f, "\tclass:%s", from_class);
+
+ if (dname)
+ free (dname);
+
+ fprintf (info->f, "\n");
+
+ free (t);
+
+ return true;
+}
+
+/* Start outputting a function. */
+
+static bool
+tg_start_function (void *p, const char *name, bool global)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *dname;
+
+ if (! global)
+ info->stack->flavor = "static";
+ else
+ info->stack->flavor = NULL;
+
+ dname = NULL;
+ if (info->demangler)
+ dname = info->demangler (info->abfd, name, demangle_flags);
+
+ if (! substitute_type (info, dname ? dname : name))
+ return false;
+
+ info->stack->method = NULL;
+ if (dname != NULL)
+ {
+ char *sep;
+ sep = strstr (dname, "::");
+ if (sep)
+ {
+ info->stack->method = dname;
+ *sep = 0;
+ name = sep + 2;
+ }
+ else
+ {
+ info->stack->method = "";
+ name = dname;
+ }
+ sep = strchr (name, '(');
+ if (sep)
+ *sep = 0;
+ /* Obscure functions as type_info function. */
+ }
+
+ info->stack->parents = strdup (name);
+
+ if (! info->stack->method && ! append_type (info, "("))
+ return false;
+
+ info->parameter = 1;
+
+ return true;
+}
+
+/* Output a function parameter. */
+
+static bool
+tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
+ bfd_vma val ATTRIBUTE_UNUSED)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char *t;
+
+ if (kind == DEBUG_PARM_REFERENCE
+ || kind == DEBUG_PARM_REF_REG)
+ {
+ if (! pr_reference_type (p))
+ return false;
+ }
+
+ if (! substitute_type (info, name))
+ return false;
+
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+
+ if (! info->stack->method)
+ {
+ if (info->parameter != 1 && ! append_type (info, ", "))
+ return false;
+
+ if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
+ if (! append_type (info, "register "))
+ return false;
+
+ if (! append_type (info, t))
+ return false;
+ }
+
+ free (t);
+
+ ++info->parameter;
+
+ return true;
+}
+
+/* Start writing out a block. */
+
+static bool
+tg_start_block (void *p, bfd_vma addr)
+{
+ struct pr_handle *info = (struct pr_handle *) p;
+ char ab[22], kind, *partof;
+ char *t;
+ bool local;
+
+ if (info->parameter > 0)
+ {
+ info->parameter = 0;
+
+ /* Delayed name. */
+ fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
+ free (info->stack->parents);
+
+ print_vma (addr, ab, true, true);
+ translate_addresses (info->abfd, ab, info->f, info->syms);
+ local = info->stack->flavor != NULL;
+ if (info->stack->method && *info->stack->method)
+ {
+ kind = 'm';
+ partof = (char *) info->stack->method;
+ }
+ else
+ {
+ kind = 'f';
+ partof = NULL;
+ if (! info->stack->method && ! append_type (info, ")"))
+ return false;
+ }
+ t = pop_type (info);
+ if (t == NULL)
+ return false;
+ fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
+ if (local)
+ fputs ("\tfile:", info->f);
+ if (partof)
+ {
+ fprintf (info->f, "\tclass:%s", partof);
+ free (partof);
+ }
+ fputc ('\n', info->f);
+ }
+
+ return true;
+}
+
+/* Write out line number information. */
+
+static bool
+tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED,
+ unsigned long lineno ATTRIBUTE_UNUSED,
+ bfd_vma addr ATTRIBUTE_UNUSED)
+{
+ return true;
+}
+
+/* Finish writing out a block. */
+
+static bool
+tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
+{
+ return true;
+}
+
+/* Convert the visibility value into a human readable name. */
+
+static const char *
+visibility_name (enum debug_visibility visibility)
+{
+ const char *s;
+
+ switch (visibility)
+ {
+ case DEBUG_VISIBILITY_PUBLIC:
+ s = "public";
+ break;
+ case DEBUG_VISIBILITY_PRIVATE:
+ s = "private";
+ break;
+ case DEBUG_VISIBILITY_PROTECTED:
+ s = "protected";
+ break;
+ case DEBUG_VISIBILITY_IGNORE:
+ s = "/* ignore */";
+ break;
+ default:
+ abort ();
+ return false;
+ }
+ return s;
+}
projects / deliverable / binutils-gdb.git / blobdiff