Back to index

cell-binutils  2.17cvs20070401
Classes | Functions | Variables
prdbg.c File Reference
#include <stdio.h>
#include <assert.h>
#include "bfd.h"
#include "bucomm.h"
#include "libiberty.h"
#include "debug.h"
#include "budbg.h"

Go to the source code of this file.

Classes

struct  pr_handle
struct  pr_stack

Functions

static void indent (struct pr_handle *)
static bfd_boolean push_type (struct pr_handle *, const char *)
static bfd_boolean prepend_type (struct pr_handle *, const char *)
static bfd_boolean append_type (struct pr_handle *, const char *)
static bfd_boolean substitute_type (struct pr_handle *, const char *)
static bfd_boolean indent_type (struct pr_handle *)
static char * pop_type (struct pr_handle *)
static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean)
static bfd_boolean pr_fix_visibility (struct pr_handle *, enum debug_visibility)
static bfd_boolean pr_start_compilation_unit (void *, const char *)
static bfd_boolean pr_start_source (void *, const char *)
static bfd_boolean pr_empty_type (void *)
static bfd_boolean pr_void_type (void *)
static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean)
static bfd_boolean pr_float_type (void *, unsigned int)
static bfd_boolean pr_complex_type (void *, unsigned int)
static bfd_boolean pr_bool_type (void *, unsigned int)
static bfd_boolean pr_enum_type (void *, const char *, const char **, bfd_signed_vma *)
static bfd_boolean pr_pointer_type (void *)
static bfd_boolean pr_function_type (void *, int, bfd_boolean)
static bfd_boolean pr_reference_type (void *)
static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma)
static bfd_boolean pr_array_type (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean)
static bfd_boolean pr_set_type (void *, bfd_boolean)
static bfd_boolean pr_offset_type (void *)
static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean)
static bfd_boolean pr_const_type (void *)
static bfd_boolean pr_volatile_type (void *)
static bfd_boolean pr_start_struct_type (void *, const char *, unsigned int, bfd_boolean, unsigned int)
static bfd_boolean pr_struct_field (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility)
static bfd_boolean pr_end_struct_type (void *)
static bfd_boolean pr_start_class_type (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean)
static bfd_boolean pr_class_static_member (void *, const char *, const char *, enum debug_visibility)
static bfd_boolean pr_class_baseclass (void *, bfd_vma, bfd_boolean, enum debug_visibility)
static bfd_boolean pr_class_start_method (void *, const char *)
static bfd_boolean pr_class_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean)
static bfd_boolean pr_class_static_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean)
static bfd_boolean pr_class_end_method (void *)
static bfd_boolean pr_end_class_type (void *)
static bfd_boolean pr_typedef_type (void *, const char *)
static bfd_boolean pr_tag_type (void *, const char *, unsigned int, enum debug_type_kind)
static bfd_boolean pr_typdef (void *, const char *)
static bfd_boolean pr_tag (void *, const char *)
static bfd_boolean pr_int_constant (void *, const char *, bfd_vma)
static bfd_boolean pr_float_constant (void *, const char *, double)
static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma)
static bfd_boolean pr_variable (void *, const char *, enum debug_var_kind, bfd_vma)
static bfd_boolean pr_start_function (void *, const char *, bfd_boolean)
static bfd_boolean pr_function_parameter (void *, const char *, enum debug_parm_kind, bfd_vma)
static bfd_boolean pr_start_block (void *, bfd_vma)
static bfd_boolean pr_end_block (void *, bfd_vma)
static bfd_boolean pr_end_function (void *)
static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma)
static bfd_boolean append_parent (struct pr_handle *, const char *)
static bfd_boolean tg_fix_visibility (struct pr_handle *, enum debug_visibility)
static void find_address_in_section (bfd *, asection *, void *)
static void translate_addresses (bfd *, char *, FILE *, asymbol **)
static const char * visibility_name (enum debug_visibility)
static bfd_boolean tg_start_compilation_unit (void *, const char *)
static bfd_boolean tg_start_source (void *, const char *)
static bfd_boolean tg_enum_type (void *, const char *, const char **, bfd_signed_vma *)
static bfd_boolean tg_start_struct_type (void *, const char *, unsigned int, bfd_boolean, unsigned int)
static bfd_boolean tg_struct_field (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility)
static bfd_boolean tg_end_struct_type (void *)
static bfd_boolean tg_start_class_type (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean)
static bfd_boolean tg_class_static_member (void *, const char *, const char *, enum debug_visibility)
static bfd_boolean tg_class_baseclass (void *, bfd_vma, bfd_boolean, enum debug_visibility)
static bfd_boolean tg_class_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean)
static bfd_boolean tg_class_static_method_variant (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean)
static bfd_boolean tg_end_class_type (void *)
static bfd_boolean tg_tag_type (void *, const char *, unsigned int, enum debug_type_kind)
static bfd_boolean tg_typdef (void *, const char *)
static bfd_boolean tg_tag (void *, const char *)
static bfd_boolean tg_int_constant (void *, const char *, bfd_vma)
static bfd_boolean tg_float_constant (void *, const char *, double)
static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma)
static bfd_boolean tg_variable (void *, const char *, enum debug_var_kind, bfd_vma)
static bfd_boolean tg_start_function (void *, const char *, bfd_boolean)
static bfd_boolean tg_function_parameter (void *, const char *, enum debug_parm_kind, bfd_vma)
static bfd_boolean tg_start_block (void *, bfd_vma)
static bfd_boolean tg_end_block (void *, bfd_vma)
static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma)
bfd_boolean print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms, void *demangler, bfd_boolean as_tags)
static bfd_boolean pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
static bfd_boolean pr_end_function (void *p ATTRIBUTE_UNUSED)
static bfd_boolean tg_start_compilation_unit (void *p, const char *filename ATTRIBUTE_UNUSED)
static bfd_boolean tg_start_struct_type (void *p, const char *tag, unsigned int id, bfd_boolean structp, unsigned int size ATTRIBUTE_UNUSED)
static bfd_boolean tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED, bfd_vma bitsize ATTRIBUTE_UNUSED, enum debug_visibility visibility)
static bfd_boolean tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
static bfd_boolean tg_class_static_member (void *p, const char *name, const char *physname ATTRIBUTE_UNUSED, enum debug_visibility visibility)
static bfd_boolean tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED, bfd_boolean virtual, enum debug_visibility visibility)
static bfd_boolean tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED, enum debug_visibility visibility, bfd_boolean constp, bfd_boolean volatilep, bfd_vma voffset ATTRIBUTE_UNUSED, bfd_boolean context)
static bfd_boolean tg_class_static_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED, enum debug_visibility visibility, bfd_boolean constp, bfd_boolean volatilep)
static bfd_boolean tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
static bfd_boolean tg_variable (void *p, const char *name, enum debug_var_kind kind, bfd_vma val ATTRIBUTE_UNUSED)
static bfd_boolean tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val ATTRIBUTE_UNUSED)
static bfd_boolean tg_lineno (void *p ATTRIBUTE_UNUSED, const char *filename ATTRIBUTE_UNUSED, unsigned long lineno ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
static bfd_boolean tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)

Variables

static struct debug_write_fns
static bfd_vma pc
static const char * filename
static const char * functionname
static unsigned int line
static bfd_boolean found

Class Documentation

struct pr_stack

Definition at line 61 of file prdbg.c.

Collaboration diagram for pr_stack:
Class Members
struct pr_stack * next
char * type

Function Documentation

static bfd_boolean append_parent ( struct pr_handle info,
const char *  s 
) [static]

Definition at line 394 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean append_type ( struct pr_handle info,
const char *  s 
) [static]

Definition at line 374 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static void find_address_in_section ( bfd abfd,
asection section,
void *  data 
) [static]

Definition at line 1891 of file prdbg.c.

{
  bfd_vma vma;
  bfd_size_type size;
  asymbol **syms = (asymbol **) data;

  if (found)
    return;

  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;

  vma = bfd_get_section_vma (abfd, section);
  if (pc < vma)
    return;

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

  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
                             &filename, &functionname, &line);
}

Here is the caller graph for this function:

static void indent ( struct pr_handle info) [static]

Definition at line 324 of file prdbg.c.

{
  unsigned int i;

  for (i = 0; i < info->indent; i++)
    putc (' ', info->f);
}

Here is the caller graph for this function:

static bfd_boolean indent_type ( struct pr_handle info) [static]

Definition at line 458 of file prdbg.c.

{
  unsigned int i;

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

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * pop_type ( struct pr_handle info) [static]

Definition at line 474 of file prdbg.c.

{
  struct pr_stack *o;
  char *ret;

  assert (info->stack != NULL);

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

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_array_type ( void *  p,
bfd_signed_vma  lower,
bfd_signed_vma  upper,
bfd_boolean  stringp 
) [static]

Definition at line 800 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_bool_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 604 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char ab[10];

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

  return push_type (info, ab);
}

Here is the call graph for this function:

static bfd_boolean pr_class_baseclass ( void *  p,
bfd_vma  bitpos,
bfd_boolean  virtual,
enum debug_visibility  visibility 
) [static]

Definition at line 1301 of file prdbg.c.

{
  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 (CONST_STRNEQ (t, "class "))
    t += sizeof "class " - 1;

  /* Push it back on to take advantage of the prepend_type and
     append_type routines.  */
  if (! push_type (info, t))
    return FALSE;

  if (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;
}

Here is the call graph for this function:

static bfd_boolean pr_class_end_method ( void *  p) [static]

Definition at line 1540 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  info->stack->method = NULL;
  return TRUE;
}
static bfd_boolean pr_class_method_variant ( void *  p,
const char *  physname,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep,
bfd_vma  voffset,
bfd_boolean  context 
) [static]

Definition at line 1409 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_class_start_method ( void *  p,
const char *  name 
) [static]

Definition at line 1397 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->stack != NULL);
  info->stack->method = name;
  return TRUE;
}
static bfd_boolean pr_class_static_member ( void *  p,
const char *  name,
const char *  physname,
enum debug_visibility  visibility 
) [static]

Definition at line 1272 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_class_static_method_variant ( void *  p,
const char *  physname,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep 
) [static]

Definition at line 1489 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_complex_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 591 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

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

  return prepend_type (info, "complex ");
}

Here is the call graph for this function:

static bfd_boolean pr_const_type ( void *  p) [static]

Definition at line 990 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

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

Here is the call graph for this function:

static bfd_boolean pr_empty_type ( void *  p) [static]

Definition at line 542 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

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

Here is the call graph for this function:

static bfd_boolean pr_end_block ( void *  p,
bfd_vma  addr 
) [static]

Definition at line 1856 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_end_class_type ( void *  p) [static]

Definition at line 1551 of file prdbg.c.

{
  return pr_end_struct_type (p);
}

Here is the call graph for this function:

static bfd_boolean pr_end_function ( void *  ) [static]
static bfd_boolean pr_end_function ( void *p  ATTRIBUTE_UNUSED) [static]

Definition at line 1873 of file prdbg.c.

{
  return TRUE;
}
static bfd_boolean pr_end_struct_type ( void *  p) [static]

Definition at line 1161 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_enum_type ( void *  p,
const char *  tag,
const char **  names,
bfd_signed_vma values 
) [static]

Definition at line 617 of file prdbg.c.

{
  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, " }");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_fix_visibility ( struct pr_handle info,
enum debug_visibility  visibility 
) [static]

Definition at line 1068 of file prdbg.c.

{
  const char *s = NULL;
  char *t;
  unsigned int len;

  assert (info->stack != NULL);

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_float_constant ( void *  p,
const char *  name,
double  val 
) [static]

Definition at line 1681 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

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

Here is the call graph for this function:

static bfd_boolean pr_float_type ( void *  p,
unsigned int  size 
) [static]

Definition at line 574 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_function_parameter ( void *  p,
const char *  name,
enum debug_parm_kind  kind,
bfd_vma  val 
) [static]

Definition at line 1778 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_function_type ( void *  p,
int  argcount,
bfd_boolean  varargs 
) [static]

Definition at line 691 of file prdbg.c.

{
  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 = xmalloc (len);
  LITSTRCPY (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;
}

Here is the call graph for this function:

static bfd_boolean pr_int_constant ( void *  p,
const char *  name,
bfd_vma  val 
) [static]

Definition at line 1667 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_int_type ( void *  p,
unsigned int  size,
bfd_boolean  unsignedp 
) [static]

Definition at line 562 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char ab[10];

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

Here is the call graph for this function:

static bfd_boolean pr_lineno ( void *  p,
const char *  filename,
unsigned long  lineno,
bfd_vma  addr 
) [static]

Definition at line 1841 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_method_type ( void *  p,
bfd_boolean  domain,
int  argcount,
bfd_boolean  varargs 
) [static]

Definition at line 894 of file prdbg.c.

{
  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 (CONST_STRNEQ (domain_type, "class ")
         && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
       domain_type += sizeof "class " - 1;
      else if (CONST_STRNEQ (domain_type, "union class ")
              && (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;
}

Here is the call graph for this function:

static bfd_boolean pr_offset_type ( void *  p) [static]

Definition at line 873 of file prdbg.c.

{
  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, "::|"));
}

Here is the call graph for this function:

static bfd_boolean pr_pointer_type ( void *  p) [static]

Definition at line 675 of file prdbg.c.

{
  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, "*|");
}

Here is the call graph for this function:

static bfd_boolean pr_range_type ( void *  p,
bfd_signed_vma  lower,
bfd_signed_vma  upper 
) [static]

Definition at line 777 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_reference_type ( void *  p) [static]

Definition at line 765 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->stack != NULL);

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pr_set_type ( void *  p,
bfd_boolean  bitstringp 
) [static]

Definition at line 850 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_start_block ( void *  p,
bfd_vma  addr 
) [static]

Definition at line 1818 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_start_class_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int  size,
bfd_boolean  vptr,
bfd_boolean  ownvptr 
) [static]

Definition at line 1184 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_start_compilation_unit ( void *  p,
const char *  filename 
) [static]

Definition at line 514 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->indent == 0);

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

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean pr_start_function ( void *  p,
const char *  name,
bfd_boolean  global 
) [static]

Definition at line 1753 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_start_source ( void *  p,
const char *  filename 
) [static]

Definition at line 528 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->indent == 0);

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

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean pr_start_struct_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int  size 
) [static]

Definition at line 1010 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_struct_field ( void *  p,
const char *  name,
bfd_vma  bitpos,
bfd_vma  bitsize,
enum debug_visibility  visibility 
) [static]

Definition at line 1119 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_tag ( void *  ,
const char *   
) [static]
static bfd_boolean pr_tag ( void *  p,
const char *name  ATTRIBUTE_UNUSED 
) [static]

Definition at line 1647 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_tag_type ( void *  p,
const char *  name,
unsigned int  id,
enum debug_type_kind  kind 
) [static]

Definition at line 1569 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_typdef ( void *  p,
const char *  name 
) [static]

Definition at line 1623 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_typed_constant ( void *  p,
const char *  name,
bfd_vma  val 
) [static]

Definition at line 1693 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_typedef_type ( void *  p,
const char *  name 
) [static]

Definition at line 1559 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  return push_type (info, name);
}

Here is the call graph for this function:

static bfd_boolean pr_variable ( void *  p,
const char *  name,
enum debug_var_kind  kind,
bfd_vma  val 
) [static]

Definition at line 1715 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean pr_void_type ( void *  p) [static]

Definition at line 552 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  return push_type (info, "void");
}

Here is the call graph for this function:

static bfd_boolean pr_volatile_type ( void *  p) [static]

Definition at line 1000 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

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

Here is the call graph for this function:

static bfd_boolean prepend_type ( struct pr_handle info,
const char *  s 
) [static]

Definition at line 357 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean print_debugging_info ( FILE *  f,
void *  dhandle,
bfd abfd,
asymbol **  syms,
void *  demangler,
bfd_boolean  as_tags 
)

Definition at line 295 of file prdbg.c.

{
  struct pr_handle info;

  info.f = f;
  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 as_tags ? debug_write (dhandle, &tg_fns, (void *) & info)
    : debug_write (dhandle, &pr_fns, (void *) & info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_vma ( bfd_vma  vma,
char *  buf,
bfd_boolean  unsignedp,
bfd_boolean  hexp 
) [static]

Definition at line 492 of file prdbg.c.

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

Here is the caller graph for this function:

static bfd_boolean push_type ( struct pr_handle info,
const char *  type 
) [static]

Definition at line 335 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean substitute_type ( struct pr_handle info,
const char *  s 
) [static]

Definition at line 416 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean tg_class_baseclass ( void *  ,
bfd_vma  ,
bfd_boolean  ,
enum  debug_visibility 
) [static]
static bfd_boolean tg_class_baseclass ( void *  p,
bfd_vma bitpos  ATTRIBUTE_UNUSED,
bfd_boolean  virtual,
enum debug_visibility  visibility 
) [static]

Definition at line 2186 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char *t;
  const char *prefix;

  assert (info->stack != NULL && info->stack->next != NULL);

  t = pop_type (info);
  if (t == NULL)
    return FALSE;

  if (CONST_STRNEQ (t, "class "))
    t += sizeof "class " - 1;

  /* Push it back on to take advantage of the prepend_type and
     append_type routines.  */
  if (! push_type (info, t))
    return FALSE;

  if (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;
}

Here is the call graph for this function:

static bfd_boolean tg_class_method_variant ( void *  ,
const char *  ,
enum  debug_visibility,
bfd_boolean  ,
bfd_boolean  ,
bfd_vma  ,
bfd_boolean   
) [static]
static bfd_boolean tg_class_method_variant ( void *  p,
const char *physname  ATTRIBUTE_UNUSED,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep,
bfd_vma voffset  ATTRIBUTE_UNUSED,
bfd_boolean  context 
) [static]

Definition at line 2251 of file prdbg.c.

{
  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))
    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 (! tg_fix_visibility (info, visibility))
    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;
}

Here is the call graph for this function:

static bfd_boolean tg_class_static_member ( void *  ,
const char *  ,
const char *  ,
enum  debug_visibility 
) [static]
static bfd_boolean tg_class_static_member ( void *  p,
const char *  name,
const char *physname  ATTRIBUTE_UNUSED,
enum debug_visibility  visibility 
) [static]

Definition at line 2145 of file prdbg.c.

{
  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 = 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))
    return FALSE;

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

  t = pop_type (info);
  if (t == NULL)
    return FALSE;

  if (! tg_fix_visibility (info, visibility))
    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;
}

Here is the call graph for this function:

static bfd_boolean tg_class_static_method_variant ( void *  ,
const char *  ,
enum  debug_visibility,
bfd_boolean  ,
bfd_boolean   
) [static]
static bfd_boolean tg_class_static_method_variant ( void *  p,
const char *physname  ATTRIBUTE_UNUSED,
enum debug_visibility  visibility,
bfd_boolean  constp,
bfd_boolean  volatilep 
) [static]

Definition at line 2315 of file prdbg.c.

{
  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))
    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 (! tg_fix_visibility (info, visibility))
    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;
}

Here is the call graph for this function:

static bfd_boolean tg_end_block ( void *  ,
bfd_vma   
) [static]
static bfd_boolean tg_end_block ( void *p  ATTRIBUTE_UNUSED,
bfd_vma addr  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2761 of file prdbg.c.

{
  return TRUE;
}
static bfd_boolean tg_end_class_type ( void *  p) [static]

Definition at line 2370 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_end_struct_type ( void *  ) [static]

Here is the caller graph for this function:

static bfd_boolean tg_end_struct_type ( void *p  ATTRIBUTE_UNUSED) [static]

Definition at line 2072 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  assert (info->stack != NULL);

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_enum_type ( void *  p,
const char *  tag,
const char **  names,
bfd_signed_vma values 
) [static]

Definition at line 1961 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_fix_visibility ( struct pr_handle info,
enum debug_visibility  visibility 
) [static]

Definition at line 2027 of file prdbg.c.

{
  assert (info->stack != NULL);

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

  assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);

  info->stack->visibility = visibility;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean tg_float_constant ( void *  p,
const char *  name,
double  val 
) [static]

Definition at line 2489 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_function_parameter ( void *  ,
const char *  ,
enum  debug_parm_kind,
bfd_vma   
) [static]
static bfd_boolean tg_function_parameter ( void *  p,
const char *  name,
enum debug_parm_kind  kind,
bfd_vma val  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2658 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_int_constant ( void *  p,
const char *  name,
bfd_vma  val 
) [static]

Definition at line 2474 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char ab[20];

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

Here is the call graph for this function:

static bfd_boolean tg_lineno ( void *  ,
const char *  ,
unsigned  long,
bfd_vma   
) [static]
static bfd_boolean tg_lineno ( void *p  ATTRIBUTE_UNUSED,
const char *filename  ATTRIBUTE_UNUSED,
unsigned long lineno  ATTRIBUTE_UNUSED,
bfd_vma addr  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2751 of file prdbg.c.

{
  return TRUE;
}
static bfd_boolean tg_start_block ( void *  p,
bfd_vma  addr 
) [static]

Definition at line 2701 of file prdbg.c.

{
  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, 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;
}

Here is the call graph for this function:

static bfd_boolean tg_start_class_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int  size,
bfd_boolean  vptr,
bfd_boolean  ownvptr 
) [static]

Definition at line 2083 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char *tv = NULL;
  const char *name;

  info->indent += 2;

  if (vptr && ! ownvptr)
    {
      tv = pop_type (info);
      if (tv == NULL)
       return FALSE;
    }

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

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

Here is the call graph for this function:

static bfd_boolean tg_start_compilation_unit ( void *  ,
const char *   
) [static]
static bfd_boolean tg_start_compilation_unit ( void *  p,
const char *filename  ATTRIBUTE_UNUSED 
) [static]

Definition at line 1931 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;

  fprintf (stderr, "New compilation unit: %s\n", filename);

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

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_start_function ( void *  p,
const char *  name,
bfd_boolean  global 
) [static]

Definition at line 2598 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  const char *dname;

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

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

  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;

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

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

  info->parameter = 1;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_start_source ( void *  p,
const char *  filename 
) [static]

Definition at line 1947 of file prdbg.c.

{
  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 TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_start_struct_type ( void *  ,
const char *  ,
unsigned  int,
bfd_boolean  ,
unsigned  int 
) [static]
static bfd_boolean tg_start_struct_type ( void *  p,
const char *  tag,
unsigned int  id,
bfd_boolean  structp,
unsigned int size  ATTRIBUTE_UNUSED 
) [static]

Definition at line 1995 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_struct_field ( void *  ,
const char *  ,
bfd_vma  ,
bfd_vma  ,
enum  debug_visibility 
) [static]
static bfd_boolean tg_struct_field ( void *  p,
const char *  name,
bfd_vma bitpos  ATTRIBUTE_UNUSED,
bfd_vma bitsize  ATTRIBUTE_UNUSED,
enum debug_visibility  visibility 
) [static]

Definition at line 2044 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_tag ( void *  ,
const char *   
) [static]
static bfd_boolean tg_tag ( void *p  ATTRIBUTE_UNUSED,
const char *name  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2458 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char *t;

  t = pop_type (info);
  if (t == NULL)
    return FALSE;
  free (t);

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_tag_type ( void *  p,
const char *  name,
unsigned int  id,
enum debug_type_kind  kind 
) [static]

Definition at line 2389 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_typdef ( void *  p,
const char *  name 
) [static]

Definition at line 2437 of file prdbg.c.

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

Here is the call graph for this function:

static bfd_boolean tg_typed_constant ( void *  p,
const char *  name,
bfd_vma  val 
) [static]

Definition at line 2502 of file prdbg.c.

{
  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, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
          name, info->filename, t, ab);

  free (t);

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean tg_variable ( void *  ,
const char *  ,
enum  debug_var_kind,
bfd_vma   
) [static]
static bfd_boolean tg_variable ( void *  p,
const char *  name,
enum debug_var_kind  kind,
bfd_vma val  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2525 of file prdbg.c.

{
  struct pr_handle *info = (struct pr_handle *) p;
  char *t;
  const char *dname, *from_class;

  t = pop_type (info);
  if (t == NULL)
    return FALSE;

  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;
       }
    }
  else
    from_class = NULL;

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

Here is the call graph for this function:

static void translate_addresses ( bfd abfd,
char *  addr_hex,
FILE *  f,
asymbol **  syms 
) [static]

Definition at line 1916 of file prdbg.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static const char * visibility_name ( enum debug_visibility  visibility) [static]

Definition at line 2769 of file prdbg.c.

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

Here is the caller graph for this function:


Variable Documentation

static struct debug_write_fns [static]

Definition at line 196 of file prdbg.c.

const char* filename [static]

Definition at line 1882 of file prdbg.c.

bfd_boolean found [static]

Definition at line 1885 of file prdbg.c.

const char* functionname [static]

Definition at line 1883 of file prdbg.c.

unsigned int line [static]

Definition at line 1884 of file prdbg.c.

bfd_vma pc [static]

Definition at line 1881 of file prdbg.c.