darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-26 21:40:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8c2bc6877d
darling-gdb/binutils/prdbg.c

1863 lines
38 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* prdbg.c -- Print out generic debugging information.
Copyright 1995, 1996 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
/* This file prints out the generic debugging information, by
supplying a set of routines to debug_write. */
#include <stdio.h>
#include <assert.h>
#include "bfd.h"
#include "bucomm.h"
#include "libiberty.h"
#include "debug.h"
#include "budbg.h"
/* This is the structure we use as a handle for these routines. */
struct pr_handle
{
/* File to print information to. */
FILE *f;
/* Current indentation level. */
unsigned int indent;
/* Type stack. */
struct pr_stack *stack;
/* Parameter number we are about to output. */
int parameter;
};
/* The type stack. */
struct pr_stack
{
/* Next element on the stack. */
struct pr_stack *next;
/* This element. */
char *type;
/* Current visibility of fields if this is a class. */
enum debug_visibility visibility;
/* Name of the current method we are handling. */
const char *method;
};
static void indent PARAMS ((struct pr_handle *));
static boolean push_type PARAMS ((struct pr_handle *, const char *));
static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
static boolean append_type PARAMS ((struct pr_handle *, const char *));
static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
static boolean indent_type PARAMS ((struct pr_handle *));
static char *pop_type PARAMS ((struct pr_handle *));
static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
static boolean pr_fix_visibility
PARAMS ((struct pr_handle *, enum debug_visibility));
static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
static boolean pr_start_source PARAMS ((PTR, const char *));
static boolean pr_empty_type PARAMS ((PTR));
static boolean pr_void_type PARAMS ((PTR));
static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
static boolean pr_float_type PARAMS ((PTR, unsigned int));
static boolean pr_complex_type PARAMS ((PTR, unsigned int));
static boolean pr_bool_type PARAMS ((PTR, unsigned int));
static boolean pr_enum_type
PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
static boolean pr_pointer_type PARAMS ((PTR));
static boolean pr_function_type PARAMS ((PTR, int, boolean));
static boolean pr_reference_type PARAMS ((PTR));
static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
static boolean pr_array_type
PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
static boolean pr_set_type PARAMS ((PTR, boolean));
static boolean pr_offset_type PARAMS ((PTR));
static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
static boolean pr_const_type PARAMS ((PTR));
static boolean pr_volatile_type PARAMS ((PTR));
static boolean pr_start_struct_type
PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
static boolean pr_struct_field
PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
static boolean pr_end_struct_type PARAMS ((PTR));
static boolean pr_start_class_type
PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
boolean));
static boolean pr_class_static_member
PARAMS ((PTR, const char *, const char *, enum debug_visibility));
static boolean pr_class_baseclass
PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
static boolean pr_class_start_method PARAMS ((PTR, const char *));
static boolean pr_class_method_variant
PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
bfd_vma, boolean));
static boolean pr_class_static_method_variant
PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
static boolean pr_class_end_method PARAMS ((PTR));
static boolean pr_end_class_type PARAMS ((PTR));
static boolean pr_typedef_type PARAMS ((PTR, const char *));
static boolean pr_tag_type
PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
static boolean pr_typdef PARAMS ((PTR, const char *));
static boolean pr_tag PARAMS ((PTR, const char *));
static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
static boolean pr_float_constant PARAMS ((PTR, const char *, double));
static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
static boolean pr_variable
PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
static boolean pr_function_parameter
PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
static boolean pr_start_block PARAMS ((PTR, bfd_vma));
static boolean pr_end_block PARAMS ((PTR, bfd_vma));
static boolean pr_end_function PARAMS ((PTR));
static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
static const struct debug_write_fns pr_fns =
{
pr_start_compilation_unit,
pr_start_source,
pr_empty_type,
pr_void_type,
pr_int_type,
pr_float_type,
pr_complex_type,
pr_bool_type,
pr_enum_type,
pr_pointer_type,
pr_function_type,
pr_reference_type,
pr_range_type,
pr_array_type,
pr_set_type,
pr_offset_type,
pr_method_type,
pr_const_type,
pr_volatile_type,
pr_start_struct_type,
pr_struct_field,
pr_end_struct_type,
pr_start_class_type,
pr_class_static_member,
pr_class_baseclass,
pr_class_start_method,
pr_class_method_variant,
pr_class_static_method_variant,
pr_class_end_method,
pr_end_class_type,
pr_typedef_type,
pr_tag_type,
pr_typdef,
pr_tag,
pr_int_constant,
pr_float_constant,
pr_typed_constant,
pr_variable,
pr_start_function,
pr_function_parameter,
pr_start_block,
pr_end_block,
pr_end_function,
pr_lineno
};
/* Print out the generic debugging information recorded in dhandle. */
boolean
print_debugging_info (f, dhandle)
FILE *f;
PTR dhandle;
{
struct pr_handle info;
info.f = f;
info.indent = 0;
info.stack = NULL;
info.parameter = 0;
return debug_write (dhandle, &pr_fns, (PTR) &info);
}
/* Indent to the current indentation level. */
static void
indent (info)
struct pr_handle *info;
{
unsigned int i;
for (i = 0; i < info->indent; i++)
putc (' ', info->f);
}
/* Push a type on the type stack. */
static boolean
push_type (info, type)
struct pr_handle *info;
const char *type;
{
struct pr_stack *n;
if (type == NULL)
return false;
n = (struct pr_stack *) xmalloc (sizeof *n);
memset (n, 0, sizeof *n);
n->type = xstrdup (type);
n->visibility = DEBUG_VISIBILITY_IGNORE;
n->method = NULL;
n->next = info->stack;
info->stack = n;
return true;
}
/* Prepend a string onto the type on the top of the type stack. */
static boolean
prepend_type (info, s)
struct pr_handle *info;
const char *s;
{
char *n;
assert (info->stack != NULL);
n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
sprintf (n, "%s%s", s, info->stack->type);
free (info->stack->type);
info->stack->type = n;
return true;
}
/* Append a string to the type on the top of the type stack. */
static boolean
append_type (info, s)
struct pr_handle *info;
const char *s;
{
unsigned int len;
if (s == NULL)
return false;
assert (info->stack != NULL);
len = strlen (info->stack->type);
info->stack->type = (char *) xrealloc (info->stack->type,
len + strlen (s) + 1);
strcpy (info->stack->type + len, s);
return true;
}
/* We use an underscore to indicate where the name should go in a type
string. This function substitutes a string for the underscore. If
there is no underscore, the name follows the type. */
static boolean
substitute_type (info, s)
struct pr_handle *info;
const char *s;
{
char *u;
assert (info->stack != NULL);
u = strchr (info->stack->type, '|');
if (u != NULL)
{
char *n;
n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
memcpy (n, info->stack->type, u - info->stack->type);
strcpy (n + (u - info->stack->type), s);
strcat (n, u + 1);
free (info->stack->type);
info->stack->type = n;
return true;
}
if (strchr (s, '|') != NULL
&& (strchr (info->stack->type, '{') != NULL
|| strchr (info->stack->type, '(') != NULL))
{
if (! prepend_type (info, "(")
|| ! append_type (info, ")"))
return false;
}
if (*s == '\0')
return true;
return (append_type (info, " ")
&& append_type (info, s));
}
/* Indent the type at the top of the stack by appending spaces. */
static boolean
indent_type (info)
struct pr_handle *info;
{
unsigned int i;
for (i = 0; i < info->indent; i++)
{
if (! append_type (info, " "))
return false;
}
return true;
}
/* Pop a type from the type stack. */
static char *
pop_type (info)
struct pr_handle *info;
{
struct pr_stack *o;
char *ret;
assert (info->stack != NULL);
o = info->stack;
info->stack = o->next;
ret = o->type;
free (o);
return ret;
}
/* Print a VMA value into a string. */
static void
print_vma (vma, buf, unsignedp, hexp)
bfd_vma vma;
char *buf;
boolean unsignedp;
boolean hexp;
{
if (sizeof (vma) <= sizeof (unsigned long))
{
if (hexp)
sprintf (buf, "0x%lx", (unsigned long) vma);
else if (unsignedp)
sprintf (buf, "%lu", (unsigned long) vma);
else
sprintf (buf, "%ld", (long) vma);
}
else
{
buf[0] = '0';
buf[1] = 'x';
sprintf_vma (buf + 2, vma);
}
}
/* Start a new compilation unit. */
static boolean
pr_start_compilation_unit (p, filename)
PTR p;
const char *filename;
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->indent == 0);
fprintf (info->f, "%s:\n", filename);
return true;
}
/* Start a source file within a compilation unit. */
static boolean
pr_start_source (p, filename)
PTR p;
const char *filename;
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->indent == 0);
fprintf (info->f, " %s:\n", filename);
return true;
}
/* Push an empty type onto the type stack. */
static boolean
pr_empty_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
return push_type (info, "<undefined>");
}
/* Push a void type onto the type stack. */
static boolean
pr_void_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
return push_type (info, "void");
}
/* Push an integer type onto the type stack. */
static boolean
pr_int_type (p, size, unsignedp)
PTR p;
unsigned int size;
boolean unsignedp;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[10];
sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
return push_type (info, ab);
}
/* Push a floating type onto the type stack. */
static boolean
pr_float_type (p, size)
PTR p;
unsigned int size;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[10];
if (size == 4)
return push_type (info, "float");
else if (size == 8)
return push_type (info, "double");
sprintf (ab, "float%d", size * 8);
return push_type (info, ab);
}
/* Push a complex type onto the type stack. */
static boolean
pr_complex_type (p, size)
PTR p;
unsigned int size;
{
struct pr_handle *info = (struct pr_handle *) p;
if (! pr_float_type (p, size))
return false;
return prepend_type (info, "complex ");
}
/* Push a boolean type onto the type stack. */
static boolean
pr_bool_type (p, size)
PTR p;
unsigned int size;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[10];
sprintf (ab, "bool%d", size * 8);
return push_type (info, ab);
}
/* Push an enum type onto the type stack. */
static boolean
pr_enum_type (p, tag, names, values)
PTR p;
const char *tag;
const char **names;
bfd_signed_vma *values;
{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int i;
bfd_signed_vma val;
if (! push_type (info, "enum "))
return false;
if (tag != NULL)
{
if (! append_type (info, tag)
|| ! append_type (info, " "))
return false;
}
if (! append_type (info, "{ "))
return false;
if (names == NULL)
{
if (! append_type (info, "/* undefined */"))
return false;
}
else
{
val = 0;
for (i = 0; names[i] != NULL; i++)
{
if (i > 0)
{
if (! append_type (info, ", "))
return false;
}
if (! append_type (info, names[i]))
return false;
if (values[i] != val)
{
char ab[20];
print_vma (values[i], ab, false, false);
if (! append_type (info, " = ")
|| ! append_type (info, ab))
return false;
val = values[i];
}
++val;
}
}
return append_type (info, " }");
}
/* Turn the top type on the stack into a pointer. */
static boolean
pr_pointer_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
assert (info->stack != NULL);
s = strchr (info->stack->type, '|');
if (s != NULL && s[1] == '[')
return substitute_type (info, "(*|)");
return substitute_type (info, "*|");
}
/* Turn the top type on the stack into a function returning that type. */
static boolean
pr_function_type (p, argcount, varargs)
PTR p;
int argcount;
boolean varargs;
{
struct pr_handle *info = (struct pr_handle *) p;
char **arg_types;
unsigned int len;
char *s;
assert (info->stack != NULL);
len = 10;
if (argcount <= 0)
{
arg_types = NULL;
len += 15;
}
else
{
int i;
arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
for (i = argcount - 1; i >= 0; i--)
{
if (! substitute_type (info, ""))
return false;
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
return false;
len += strlen (arg_types[i]) + 2;
}
if (varargs)
len += 5;
}
/* Now the return type is on the top of the stack. */
s = (char *) xmalloc (len);
strcpy (s, "(|) (");
if (argcount < 0)
strcat (s, "/* unknown */");
else
{
int i;
for (i = 0; i < argcount; i++)
{
if (i > 0)
strcat (s, ", ");
strcat (s, arg_types[i]);
}
if (varargs)
{
if (i > 0)
strcat (s, ", ");
strcat (s, "...");
}
if (argcount > 0)
free (arg_types);
}
strcat (s, ")");
if (! substitute_type (info, s))
return false;
free (s);
return true;
}
/* Turn the top type on the stack into a reference to that type. */
static boolean
pr_reference_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL);
return substitute_type (info, "&|");
}
/* Make a range type. */
static boolean
pr_range_type (p, lower, upper)
PTR p;
bfd_signed_vma lower;
bfd_signed_vma upper;
{
struct pr_handle *info = (struct pr_handle *) p;
char abl[20], abu[20];
assert (info->stack != NULL);
if (! substitute_type (info, ""))
return false;
print_vma (lower, abl, false, false);
print_vma (upper, abu, false, false);
return (prepend_type (info, "range (")
&& append_type (info, "):")
&& append_type (info, abl)
&& append_type (info, ":")
&& append_type (info, abu));
}
/* Make an array type. */
/*ARGSUSED*/
static boolean
pr_array_type (p, lower, upper, stringp)
PTR p;
bfd_signed_vma lower;
bfd_signed_vma upper;
boolean stringp;
{
struct pr_handle *info = (struct pr_handle *) p;
char *range_type;
char abl[20], abu[20], ab[50];
range_type = pop_type (info);
if (range_type == NULL)
return false;
if (lower == 0)
{
if (upper == -1)
sprintf (ab, "|[]");
else
{
print_vma (upper + 1, abu, false, false);
sprintf (ab, "|[%s]", abu);
}
}
else
{
print_vma (lower, abl, false, false);
print_vma (upper, abu, false, false);
sprintf (ab, "|[%s:%s]", abl, abu);
}
if (! substitute_type (info, ab))
return false;
if (strcmp (range_type, "int") != 0)
{
if (! append_type (info, ":")
|| ! append_type (info, range_type))
return false;
}
if (stringp)
{
if (! append_type (info, " /* string */"))
return false;
}
return true;
}
/* Make a set type. */
/*ARGSUSED*/
static boolean
pr_set_type (p, bitstringp)
PTR p;
boolean bitstringp;
{
struct pr_handle *info = (struct pr_handle *) p;
if (! substitute_type (info, ""))
return false;
if (! prepend_type (info, "set { ")
|| ! append_type (info, " }"))
return false;
if (bitstringp)
{
if (! append_type (info, "/* bitstring */"))
return false;
}
return true;
}
/* Make an offset type. */
static boolean
pr_offset_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
if (! substitute_type (info, ""))
return false;
t = pop_type (info);
if (t == NULL)
return false;
return (substitute_type (info, "")
&& prepend_type (info, " ")
&& prepend_type (info, t)
&& append_type (info, "::|"));
}
/* Make a method type. */
static boolean
pr_method_type (p, domain, argcount, varargs)
PTR p;
boolean domain;
int argcount;
boolean varargs;
{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int len;
char *domain_type;
char **arg_types;
char *s;
len = 10;
if (! domain)
domain_type = NULL;
else
{
if (! substitute_type (info, ""))
return false;
domain_type = pop_type (info);
if (domain_type == NULL)
return false;
if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
&& strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
domain_type += sizeof "class " - 1;
else if (strncmp (domain_type, "union class ",
sizeof "union class ") == 0
&& (strchr (domain_type + sizeof "union class " - 1, ' ')
== NULL))
domain_type += sizeof "union class " - 1;
len += strlen (domain_type);
}
if (argcount <= 0)
{
arg_types = NULL;
len += 15;
}
else
{
int i;
arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
for (i = argcount - 1; i >= 0; i--)
{
if (! substitute_type (info, ""))
return false;
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
return false;
len += strlen (arg_types[i]) + 2;
}
if (varargs)
len += 5;
}
/* Now the return type is on the top of the stack. */
s = (char *) xmalloc (len);
if (! domain)
*s = '\0';
else
strcpy (s, domain_type);
strcat (s, "::| (");
if (argcount < 0)
strcat (s, "/* unknown */");
else
{
int i;
for (i = 0; i < argcount; i++)
{
if (i > 0)
strcat (s, ", ");
strcat (s, arg_types[i]);
}
if (varargs)
{
if (i > 0)
strcat (s, ", ");
strcat (s, "...");
}
if (argcount > 0)
free (arg_types);
}
strcat (s, ")");
if (! substitute_type (info, s))
return false;
free (s);
return true;
}
/* Make a const qualified type. */
static boolean
pr_const_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
return substitute_type (info, "const |");
}
/* Make a volatile qualified type. */
static boolean
pr_volatile_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
return substitute_type (info, "volatile |");
}
/* Start accumulating a struct type. */
static boolean
pr_start_struct_type (p, tag, id, structp, size)
PTR p;
const char *tag;
unsigned int id;
boolean structp;
unsigned int size;
{
struct pr_handle *info = (struct pr_handle *) p;
info->indent += 2;
if (! push_type (info, structp ? "struct " : "union "))
return false;
if (tag != NULL)
{
if (! append_type (info, tag))
return false;
}
else
{
char idbuf[20];
sprintf (idbuf, "%%anon%u", id);
if (! append_type (info, idbuf))
return false;
}
if (! append_type (info, " {"))
return false;
if (size != 0 || tag != NULL)
{
char ab[30];
if (! append_type (info, " /*"))
return false;
if (size != 0)
{
sprintf (ab, " size %u", size);
if (! append_type (info, ab))
return false;
}
if (tag != NULL)
{
sprintf (ab, " id %u", id);
if (! append_type (info, ab))
return false;
}
if (! append_type (info, " */"))
return false;
}
if (! append_type (info, "\n"))
return false;
info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
return indent_type (info);
}
/* Output the visibility of a field in a struct. */
static boolean
pr_fix_visibility (info, visibility)
struct pr_handle *info;
enum debug_visibility visibility;
{
const char *s = NULL;
char *t;
unsigned int len;
assert (info->stack != NULL);
if (info->stack->visibility == visibility)
return true;
assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
switch (visibility)
{
case DEBUG_VISIBILITY_PUBLIC:
s = "public";
break;
case DEBUG_VISIBILITY_PRIVATE:
s = "private";
break;
case DEBUG_VISIBILITY_PROTECTED:
s = "protected";
break;
case DEBUG_VISIBILITY_IGNORE:
s = "/* ignore */";
break;
default:
abort ();
return false;
}
/* Trim off a trailing space in the struct string, to make the
output look a bit better, then stick on the visibility string. */
t = info->stack->type;
len = strlen (t);
assert (t[len - 1] == ' ');
t[len - 1] = '\0';
if (! append_type (info, s)
|| ! append_type (info, ":\n")
|| ! indent_type (info))
return false;
info->stack->visibility = visibility;
return true;
}
/* Add a field to a struct type. */
static boolean
pr_struct_field (p, name, bitpos, bitsize, visibility)
PTR p;
const char *name;
bfd_vma bitpos;
bfd_vma bitsize;
enum debug_visibility visibility;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
char *t;
if (! substitute_type (info, name))
return false;
if (! append_type (info, "; /* "))
return false;
if (bitsize != 0)
{
print_vma (bitsize, ab, true, false);
if (! append_type (info, "bitsize ")
|| ! append_type (info, ab)
|| ! append_type (info, ", "))
return false;
}
print_vma (bitpos, ab, true, false);
if (! append_type (info, "bitpos ")
|| ! append_type (info, ab)
|| ! append_type (info, " */\n")
|| ! indent_type (info))
return false;
t = pop_type (info);
if (t == NULL)
return false;
if (! pr_fix_visibility (info, visibility))
return false;
return append_type (info, t);
}
/* Finish a struct type. */
static boolean
pr_end_struct_type (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
assert (info->stack != NULL);
assert (info->indent >= 2);
info->indent -= 2;
/* Change the trailing indentation to have a close brace. */
s = info->stack->type + strlen (info->stack->type) - 2;
assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
*s++ = '}';
*s = '\0';
return true;
}
/* Start a class type. */
static boolean
pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
PTR p;
const char *tag;
unsigned int id;
boolean structp;
unsigned int size;
boolean vptr;
boolean ownvptr;
{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL;
info->indent += 2;
if (vptr && ! ownvptr)
{
tv = pop_type (info);
if (tv == NULL)
return false;
}
if (! push_type (info, structp ? "class " : "union class "))
return false;
if (tag != NULL)
{
if (! append_type (info, tag))
return false;
}
else
{
char idbuf[20];
sprintf (idbuf, "%%anon%u", id);
if (! append_type (info, idbuf))
return false;
}
if (! append_type (info, " {"))
return false;
if (size != 0 || vptr || ownvptr || tag != NULL)
{
if (! append_type (info, " /*"))
return false;
if (size != 0)
{
char ab[20];
sprintf (ab, "%u", size);
if (! append_type (info, " size ")
|| ! append_type (info, ab))
return false;
}
if (vptr)
{
if (! append_type (info, " vtable "))
return false;
if (ownvptr)
{
if (! append_type (info, "self "))
return false;
}
else
{
if (! append_type (info, tv)
|| ! append_type (info, " "))
return false;
}
}
if (tag != NULL)
{
char ab[30];
sprintf (ab, " id %u", id);
if (! append_type (info, ab))
return false;
}
if (! append_type (info, " */"))
return false;
}
info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
return (append_type (info, "\n")
&& indent_type (info));
}
/* Add a static member to a class. */
static boolean
pr_class_static_member (p, name, physname, visibility)
PTR p;
const char *name;
const char *physname;
enum debug_visibility visibility;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
if (! substitute_type (info, name))
return false;
if (! prepend_type (info, "static ")
|| ! append_type (info, "; /* ")
|| ! append_type (info, physname)
|| ! append_type (info, " */\n")
|| ! indent_type (info))
return false;
t = pop_type (info);
if (t == NULL)
return false;
if (! pr_fix_visibility (info, visibility))
return false;
return append_type (info, t);
}
/* Add a base class to a class. */
static boolean
pr_class_baseclass (p, bitpos, virtual, visibility)
PTR p;
bfd_vma bitpos;
boolean virtual;
enum debug_visibility visibility;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
const char *prefix;
char ab[20];
char *s, *l, *n;
assert (info->stack != NULL && info->stack->next != NULL);
if (! substitute_type (info, ""))
return false;
t = pop_type (info);
if (t == NULL)
return false;
if (strncmp (t, "class ", sizeof "class " - 1) == 0)
t += sizeof "class " - 1;
/* Push it back on to take advantage of the prepend_type and
append_type routines. */
if (! push_type (info, t))
return false;
if (virtual)
{
if (! prepend_type (info, "virtual "))
return false;
}
switch (visibility)
{
case DEBUG_VISIBILITY_PUBLIC:
prefix = "public ";
break;
case DEBUG_VISIBILITY_PROTECTED:
prefix = "protected ";
break;
case DEBUG_VISIBILITY_PRIVATE:
prefix = "private ";
break;
default:
prefix = "/* unknown visibility */ ";
break;
}
if (! prepend_type (info, prefix))
return false;
if (bitpos != 0)
{
print_vma (bitpos, ab, true, false);
if (! append_type (info, " /* bitpos ")
|| ! append_type (info, ab)
|| ! append_type (info, " */"))
return false;
}
/* Now the top of the stack is something like "public A / * bitpos
10 * /". The next element on the stack is something like "class
xx { / * size 8 * /\n...". We want to substitute the top of the
stack in before the {. */
s = strchr (info->stack->next->type, '{');
assert (s != NULL);
--s;
/* If there is already a ':', then we already have a baseclass, and
we must append this one after a comma. */
for (l = info->stack->next->type; l != s; l++)
if (*l == ':')
break;
if (! prepend_type (info, l == s ? " : " : ", "))
return false;
t = pop_type (info);
if (t == NULL)
return false;
n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
memcpy (n, info->stack->type, s - info->stack->type);
strcpy (n + (s - info->stack->type), t);
strcat (n, s);
free (info->stack->type);
info->stack->type = n;
free (t);
return true;
}
/* Start adding a method to a class. */
static boolean
pr_class_start_method (p, name)
PTR p;
const char *name;
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL);
info->stack->method = name;
return true;
}
/* Add a variant to a method. */
static boolean
pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
context)
PTR p;
const char *physname;
enum debug_visibility visibility;
boolean constp;
boolean volatilep;
bfd_vma voffset;
boolean context;
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
char *context_type;
assert (info->stack != NULL);
assert (info->stack->next != NULL);
/* Put the const and volatile qualifiers on the type. */
if (volatilep)
{
if (! append_type (info, " volatile"))
return false;
}
if (constp)
{
if (! append_type (info, " const"))
return false;
}
/* Stick the name of the method into its type. */
if (! substitute_type (info,
(context
? info->stack->next->next->method
: info->stack->next->method)))
return false;
/* Get the type. */
method_type = pop_type (info);
if (method_type == NULL)
return false;
/* Pull off the context type if there is one. */
if (! context)
context_type = NULL;
else
{
context_type = pop_type (info);
if (context_type == NULL)
return false;
}
/* Now the top of the stack is the class. */
if (! pr_fix_visibility (info, visibility))
return false;
if (! append_type (info, method_type)
|| ! append_type (info, " /* ")
|| ! append_type (info, physname)
|| ! append_type (info, " "))
return false;
if (context || voffset != 0)
{
char ab[20];
if (context)
{
if (! append_type (info, "context ")
|| ! append_type (info, context_type)
|| ! append_type (info, " "))
return false;
}
print_vma (voffset, ab, true, false);
if (! append_type (info, "voffset ")
|| ! append_type (info, ab))
return false;
}
return (append_type (info, " */;\n")
&& indent_type (info));
}
/* Add a static variant to a method. */
static boolean
pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
PTR p;
const char *physname;
enum debug_visibility visibility;
boolean constp;
boolean volatilep;
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
assert (info->stack != NULL);
assert (info->stack->next != NULL);
assert (info->stack->next->method != NULL);
/* Put the const and volatile qualifiers on the type. */
if (volatilep)
{
if (! append_type (info, " volatile"))
return false;
}
if (constp)
{
if (! append_type (info, " const"))
return false;
}
/* Mark it as static. */
if (! prepend_type (info, "static "))
return false;
/* Stick the name of the method into its type. */
if (! substitute_type (info, info->stack->next->method))
return false;
/* Get the type. */
method_type = pop_type (info);
if (method_type == NULL)
return false;
/* Now the top of the stack is the class. */
if (! pr_fix_visibility (info, visibility))
return false;
return (append_type (info, method_type)
&& append_type (info, " /* ")
&& append_type (info, physname)
&& append_type (info, " */;\n")
&& indent_type (info));
}
/* Finish up a method. */
static boolean
pr_class_end_method (p)
PTR p;
{
struct pr_handle *info = (struct pr_handle *) p;
info->stack->method = NULL;
return true;
}
/* Finish up a class. */
static boolean
pr_end_class_type (p)
PTR p;
{
return pr_end_struct_type (p);
}
/* Push a type on the stack using a typedef name. */
static boolean
pr_typedef_type (p, name)
PTR p;
const char *name;
{
struct pr_handle *info = (struct pr_handle *) p;
return push_type (info, name);
}
/* Push a type on the stack using a tag name. */
static boolean
pr_tag_type (p, name, id, kind)
PTR p;
const char *name;
unsigned int id;
enum debug_type_kind kind;
{
struct pr_handle *info = (struct pr_handle *) p;
const char *t, *tag;
char idbuf[20];
switch (kind)
{
case DEBUG_KIND_STRUCT:
t = "struct ";
break;
case DEBUG_KIND_UNION:
t = "union ";
break;
case DEBUG_KIND_ENUM:
t = "enum ";
break;
case DEBUG_KIND_CLASS:
t = "class ";
break;
case DEBUG_KIND_UNION_CLASS:
t = "union class ";
break;
default:
abort ();
return false;
}
if (! push_type (info, t))
return false;
if (name != NULL)
tag = name;
else
{
sprintf (idbuf, "%%anon%u", id);
tag = idbuf;
}
if (! append_type (info, tag))
return false;
if (name != NULL && kind != DEBUG_KIND_ENUM)
{
sprintf (idbuf, " /* id %u */", id);
if (! append_type (info, idbuf))
return false;
}
return true;
}
/* Output a typedef. */
static boolean
pr_typdef (p, name)
PTR p;
const char *name;
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
if (! substitute_type (info, name))
return false;
s = pop_type (info);
if (s == NULL)
return false;
indent (info);
fprintf (info->f, "typedef %s;\n", s);
free (s);
return true;
}
/* Output a tag. The tag should already be in the string on the
stack, so all we have to do here is print it out. */
/*ARGSUSED*/
static boolean
pr_tag (p, name)
PTR p;
const char *name ATTRIBUTE_UNUSED;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
t = pop_type (info);
if (t == NULL)
return false;
indent (info);
fprintf (info->f, "%s;\n", t);
free (t);
return true;
}
/* Output an integer constant. */
static boolean
pr_int_constant (p, name, val)
PTR p;
const char *name;
bfd_vma val;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
indent (info);
print_vma (val, ab, false, false);
fprintf (info->f, "const int %s = %s;\n", name, ab);
return true;
}
/* Output a floating point constant. */
static boolean
pr_float_constant (p, name, val)
PTR p;
const char *name;
double val;
{
struct pr_handle *info = (struct pr_handle *) p;
indent (info);
fprintf (info->f, "const double %s = %g;\n", name, val);
return true;
}
/* Output a typed constant. */
static boolean
pr_typed_constant (p, name, val)
PTR p;
const char *name;
bfd_vma val;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];
t = pop_type (info);
if (t == NULL)
return false;
indent (info);
print_vma (val, ab, false, false);
fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
free (t);
return true;
}
/* Output a variable. */
static boolean
pr_variable (p, name, kind, val)
PTR p;
const char *name;
enum debug_var_kind kind;
bfd_vma val;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];
if (! substitute_type (info, name))
return false;
t = pop_type (info);
if (t == NULL)
return false;
indent (info);
switch (kind)
{
case DEBUG_STATIC:
case DEBUG_LOCAL_STATIC:
fprintf (info->f, "static ");
break;
case DEBUG_REGISTER:
fprintf (info->f, "register ");
break;
default:
break;
}
print_vma (val, ab, true, true);
fprintf (info->f, "%s /* %s */;\n", t, ab);
free (t);
return true;
}
/* Start outputting a function. */
static boolean
pr_start_function (p, name, global)
PTR p;
const char *name;
boolean global;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
if (! substitute_type (info, name))
return false;
t = pop_type (info);
if (t == NULL)
return false;
indent (info);
if (! global)
fprintf (info->f, "static ");
fprintf (info->f, "%s (", t);
info->parameter = 1;
return true;
}
/* Output a function parameter. */
static boolean
pr_function_parameter (p, name, kind, val)
PTR p;
const char *name;
enum debug_parm_kind kind;
bfd_vma val;
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
char ab[20];
if (kind == DEBUG_PARM_REFERENCE
|| kind == DEBUG_PARM_REF_REG)
{
if (! pr_reference_type (p))
return false;
}
if (! substitute_type (info, name))
return false;
t = pop_type (info);
if (t == NULL)
return false;
if (info->parameter != 1)
fprintf (info->f, ", ");
if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
fprintf (info->f, "register ");
print_vma (val, ab, true, true);
fprintf (info->f, "%s /* %s */", t, ab);
free (t);
++info->parameter;
return true;
}
/* Start writing out a block. */
static boolean
pr_start_block (p, addr)
PTR p;
bfd_vma addr;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
if (info->parameter > 0)
{
fprintf (info->f, ")\n");
info->parameter = 0;
}
indent (info);
print_vma (addr, ab, true, true);
fprintf (info->f, "{ /* %s */\n", ab);
info->indent += 2;
return true;
}
/* Write out line number information. */
static boolean
pr_lineno (p, filename, lineno, addr)
PTR p;
const char *filename;
unsigned long lineno;
bfd_vma addr;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
indent (info);
print_vma (addr, ab, true, true);
fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
return true;
}
/* Finish writing out a block. */
static boolean
pr_end_block (p, addr)
PTR p;
bfd_vma addr;
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[20];
info->indent -= 2;
indent (info);
print_vma (addr, ab, true, true);
fprintf (info->f, "} /* %s */\n", ab);
return true;
}
/* Finish writing out a function. */
/*ARGSUSED*/
static boolean
pr_end_function (p)
PTR p ATTRIBUTE_UNUSED;
{
return true;
}
Reference in New Issue View Git Blame Copy Permalink