Back to index

cell-binutils  2.17cvs20070401
Functions | Variables
corefile.c File Reference
#include "libiberty.h"
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "corefile.h"

Go to the source code of this file.

Functions

static void read_function_mappings (const char *)
static int core_sym_class (asymbol *)
static bfd_boolean get_src_info (bfd_vma, const char **, const char **, int *)
void i386_find_call (Sym *, bfd_vma, bfd_vma)
void alpha_find_call (Sym *, bfd_vma, bfd_vma)
void vax_find_call (Sym *, bfd_vma, bfd_vma)
void tahoe_find_call (Sym *, bfd_vma, bfd_vma)
void sparc_find_call (Sym *, bfd_vma, bfd_vma)
void mips_find_call (Sym *, bfd_vma, bfd_vma)
static void parse_error (const char *filename)
void core_init (const char *aout_name)
void core_get_text_space (bfd *cbfd)
void find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
void core_create_function_syms ()
void core_create_line_syms ()

Variables

bfdcore_bfd
static int core_num_syms
static asymbol ** core_syms
asectioncore_text_sect
PTR core_text_space
static int min_insn_size
int offset_to_code
struct function_mapsymbol_map
unsigned int symbol_map_count

Function Documentation

void alpha_find_call ( Sym ,
bfd_vma  ,
bfd_vma   
)

Definition at line 93 of file alpha.c.

{
  bfd_vma pc, dest_pc;
  unsigned int insn;
  Sym *child;

  if (indirect_child.name == NULL)
    {
      sym_init (&indirect_child);
      indirect_child.name = _("<indirect child>");
      indirect_child.cg.prop.fract = 1.0;
      indirect_child.cg.cyc.head = &indirect_child;
    }

  if (!core_text_space)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf (_("[find_call] %s: 0x%lx to 0x%lx\n"),
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));
  for (pc = (p_lowpc + 3) & ~(bfd_vma) 3; pc < p_highpc; pc += 4)
    {
      insn = bfd_get_32 (core_bfd, ((unsigned char *) core_text_space
                                + pc - core_text_sect->vma));
      switch (insn & (0x3f << 26))
       {
       case OP_Jxx << 26:
         /*
          * There is no simple and reliable way to determine the
          * target of a jsr (the hint bits help, but there aren't
          * enough bits to get a satisfactory hit rate).  Instead,
          * for any indirect jump we simply add an arc from PARENT
          * to INDIRECT_CHILD---that way the user it at least able
          * to see that there are other calls as well.
          */
         if ((insn & (3 << 14)) == Jxx_FUNC_JSR << 14
             || (insn & (3 << 14)) == Jxx_FUNC_JSR_COROUTINE << 14)
           {
             DBG (CALLDEBUG,
                 printf (_("[find_call] 0x%lx: jsr%s <indirect_child>\n"),
                        (unsigned long) pc,
                        ((insn & (3 << 14)) == Jxx_FUNC_JSR << 14
                         ? "" : "_coroutine")));
             arc_add (parent, &indirect_child, (unsigned long) 0);
           }
         break;

       case OP_BSR << 26:
         DBG (CALLDEBUG,
              printf (_("[find_call] 0x%lx: bsr"), (unsigned long) pc));
         /*
          * Regular PC relative addressing.  Check that this is the
          * address of a function.  The linker sometimes redirects
          * the entry point by 8 bytes to skip loading the global
          * pointer, so we allow for either address:
          */
         dest_pc = pc + 4 + (((bfd_signed_vma) (insn & 0x1fffff)
                            ^ 0x100000) - 0x100000);
         if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
           {
             child = sym_lookup (&symtab, dest_pc);
             DBG (CALLDEBUG,
                 printf (" 0x%lx\t; name=%s, addr=0x%lx",
                        (unsigned long) dest_pc, child->name,
                        (unsigned long) child->addr));
             if (child->addr == dest_pc || child->addr == dest_pc - 8)
              {
                DBG (CALLDEBUG, printf ("\n"));
                /* a hit:  */
                arc_add (parent, child, (unsigned long) 0);
                continue;
              }
           }
         /*
          * Something funny going on.
          */
         DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
         break;

       default:
         break;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void core_create_function_syms ( void  )

Definition at line 426 of file corefile.c.

{
  bfd_vma min_vma = ~(bfd_vma) 0;
  bfd_vma max_vma = 0;
  int class;
  long i, found, skip;
  unsigned int j;

  /* Pass 1 - determine upper bound on number of function names.  */
  symtab.len = 0;

  for (i = 0; i < core_num_syms; ++i)
    {
      if (!core_sym_class (core_syms[i]))
       continue;

      /* This should be replaced with a binary search or hashed
        search.  Gross.

        Don't create a symtab entry for a function that has
        a mapping to a file, unless it's the first function
        in the file.  */
      skip = 0;
      for (j = 0; j < symbol_map_count; j++)
       if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
         {
           if (j > 0 && ! strcmp (symbol_map [j].file_name,
                               symbol_map [j - 1].file_name))
             skip = 1;
           break;
         }

      if (!skip)
       ++symtab.len;
    }

  if (symtab.len == 0)
    {
      fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
      done (1);
    }

  /* The "+ 2" is for the sentinels.  */
  symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));

  /* Pass 2 - create symbols.  */
  symtab.limit = symtab.base;

  for (i = 0; i < core_num_syms; ++i)
    {
      asection *sym_sec;

      class = core_sym_class (core_syms[i]);

      if (!class)
       {
         DBG (AOUTDEBUG,
              printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
                     (unsigned long) core_syms[i]->value,
                     core_syms[i]->name));
         continue;
       }

      /* This should be replaced with a binary search or hashed
        search.  Gross.   */
      skip = 0;
      found = 0;

      for (j = 0; j < symbol_map_count; j++)
       if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
         {
           if (j > 0 && ! strcmp (symbol_map [j].file_name,
                               symbol_map [j - 1].file_name))
             skip = 1;
           else
             found = j;
           break;
         }

      if (skip)
       continue;

      sym_init (symtab.limit);

      /* Symbol offsets are always section-relative.  */
      sym_sec = core_syms[i]->section;
      symtab.limit->addr = core_syms[i]->value;
      if (sym_sec)
       symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);

      if (symbol_map_count
         && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
       {
         symtab.limit->name = symbol_map[found].file_name;
         symtab.limit->mapped = 1;
       }
      else
       {
         symtab.limit->name = core_syms[i]->name;
         symtab.limit->mapped = 0;
       }

      /* Lookup filename and line number, if we can.  */
      {
       const char *filename, *func_name;

       if (get_src_info (symtab.limit->addr, &filename, &func_name,
                       &symtab.limit->line_num))
         {
           symtab.limit->file = source_file_lookup_path (filename);

           /* FIXME: Checking __osf__ here does not work with a cross
              gprof.  */
#ifdef __osf__
           /* Suppress symbols that are not function names.  This is
              useful to suppress code-labels and aliases.

              This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
              labels do not appear in the symbol table info, so this isn't
              necessary.  */

           if (strcmp (symtab.limit->name, func_name) != 0)
             {
              /* The symbol's address maps to a different name, so
                 it can't be a function-entry point.  This happens
                 for labels, for example.  */
              DBG (AOUTDEBUG,
                   printf ("[core_create_function_syms: rej %s (maps to %s)\n",
                          symtab.limit->name, func_name));
              continue;
             }
#endif
         }
      }

      symtab.limit->is_func = TRUE;
      symtab.limit->is_bb_head = TRUE;

      if (class == 't')
       symtab.limit->is_static = TRUE;

      /* Keep track of the minimum and maximum vma addresses used by all
        symbols.  When computing the max_vma, use the ending address of the
        section containing the symbol, if available.  */
      min_vma = MIN (symtab.limit->addr, min_vma);
      if (sym_sec)
       max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
                     + bfd_section_size (sym_sec->owner, sym_sec) - 1,
                     max_vma);
      else
       max_vma = MAX (symtab.limit->addr, max_vma);

      /* If we see "main" without an initial '_', we assume names
        are *not* prefixed by '_'.  */
      if (symtab.limit->name[0] == 'm' && discard_underscores
         && strcmp (symtab.limit->name, "main") == 0)
       discard_underscores = 0;

      DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
                           (long) (symtab.limit - symtab.base),
                           symtab.limit->name,
                           (unsigned long) symtab.limit->addr));
      ++symtab.limit;
    }

  /* Create sentinels.  */
  sym_init (symtab.limit);
  symtab.limit->name = "<locore>";
  symtab.limit->addr = 0;
  symtab.limit->end_addr = min_vma - 1;
  ++symtab.limit;

  sym_init (symtab.limit);
  symtab.limit->name = "<hicore>";
  symtab.limit->addr = max_vma + 1;
  symtab.limit->end_addr = ~(bfd_vma) 0;
  ++symtab.limit;

  symtab.len = symtab.limit - symtab.base;
  symtab_finalize (&symtab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void core_create_line_syms ( void  )

Definition at line 612 of file corefile.c.

{
  char *prev_name, *prev_filename;
  unsigned int prev_name_len, prev_filename_len;
  bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
  Sym *prev, dummy, *sentinel, *sym;
  const char *filename;
  int prev_line_num;
  Sym_Table ltab;
  bfd_vma vma_high;

  /* Create symbols for functions as usual.  This is necessary in
     cases where parts of a program were not compiled with -g.  For
     those parts we still want to get info at the function level.  */
  core_create_function_syms ();

  /* Pass 1: count the number of symbols.  */

  /* To find all line information, walk through all possible
     text-space addresses (one by one!) and get the debugging
     info for each address.  When the debugging info changes,
     it is time to create a new symbol.

     Of course, this is rather slow and it would be better if
     BFD would provide an iterator for enumerating all line infos.  */
  prev_name_len = PATH_MAX;
  prev_filename_len = PATH_MAX;
  prev_name = xmalloc (prev_name_len);
  prev_filename = xmalloc (prev_filename_len);
  ltab.len = 0;
  prev_line_num = 0;

  vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
  for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
    {
      unsigned int len;

      if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
         || (prev_line_num == dummy.line_num
             && prev_name != NULL
             && strcmp (prev_name, dummy.name) == 0
             && strcmp (prev_filename, filename) == 0))
       continue;

      ++ltab.len;
      prev_line_num = dummy.line_num;

      len = strlen (dummy.name);
      if (len >= prev_name_len)
       {
         prev_name_len = len + 1024;
         free (prev_name);
         prev_name = xmalloc (prev_name_len);
       }

      strcpy (prev_name, dummy.name);
      len = strlen (filename);

      if (len >= prev_filename_len)
       {
         prev_filename_len = len + 1024;
         free (prev_filename);
         prev_filename = xmalloc (prev_filename_len);
       }

      strcpy (prev_filename, filename);

      min_vma = MIN (vma, min_vma);
      max_vma = MAX (vma, max_vma);
    }

  free (prev_name);
  free (prev_filename);

  /* Make room for function symbols, too.  */
  ltab.len += symtab.len;
  ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
  ltab.limit = ltab.base;

  /* Pass 2 - create symbols.  */

  /* We now set is_static as we go along, rather than by running
     through the symbol table at the end.

     The old way called symtab_finalize before the is_static pass,
     causing a problem since symtab_finalize uses is_static as part of
     its address conflict resolution algorithm.  Since global symbols
     were prefered over static symbols, and all line symbols were
     global at that point, static function names that conflicted with
     their own line numbers (static, but labeled as global) were
     rejected in favor of the line num.

     This was not the desired functionality.  We always want to keep
     our function symbols and discard any conflicting line symbols.
     Perhaps symtab_finalize should be modified to make this
     distinction as well, but the current fix works and the code is a
     lot cleaner now.  */
  prev = 0;

  for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
    {
      sym_init (ltab.limit);

      if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
         || (prev && prev->line_num == ltab.limit->line_num
             && strcmp (prev->name, ltab.limit->name) == 0
             && strcmp (prev->file->name, filename) == 0))
       continue;

      /* Make name pointer a malloc'ed string.  */
      ltab.limit->name = xstrdup (ltab.limit->name);
      ltab.limit->file = source_file_lookup_path (filename);

      ltab.limit->addr = vma;

      /* Set is_static based on the enclosing function, using either:
        1) the previous symbol, if it's from the same function, or
        2) a symtab lookup.  */
      if (prev && ltab.limit->file == prev->file &&
         strcmp (ltab.limit->name, prev->name) == 0)
       {
         ltab.limit->is_static = prev->is_static;
       }
      else
       {
         sym = sym_lookup(&symtab, ltab.limit->addr);
         ltab.limit->is_static = sym->is_static;
       }

      prev = ltab.limit;

      /* If we see "main" without an initial '_', we assume names
        are *not* prefixed by '_'.  */
      if (ltab.limit->name[0] == 'm' && discard_underscores
         && strcmp (ltab.limit->name, "main") == 0)
       discard_underscores = 0;

      DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
                           (unsigned long) (ltab.limit - ltab.base),
                           ltab.limit->name,
                           (unsigned long) ltab.limit->addr));
      ++ltab.limit;
    }

  /* Update sentinels.  */
  sentinel = sym_lookup (&symtab, (bfd_vma) 0);

  if (sentinel
      && strcmp (sentinel->name, "<locore>") == 0
      && min_vma <= sentinel->end_addr)
    sentinel->end_addr = min_vma - 1;

  sentinel = sym_lookup (&symtab, ~(bfd_vma) 0);

  if (sentinel
      && strcmp (sentinel->name, "<hicore>") == 0
      && max_vma >= sentinel->addr)
    sentinel->addr = max_vma + 1;

  /* Copy in function symbols.  */
  memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
  ltab.limit += symtab.len;

  if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
    {
      fprintf (stderr,
              _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
              whoami, ltab.len, (long) (ltab.limit - ltab.base));
      done (1);
    }

  /* Finalize ltab and make it symbol table.  */
  symtab_finalize (&ltab);
  free (symtab.base);
  symtab = ltab;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void core_get_text_space ( bfd cbfd)

Definition at line 245 of file corefile.c.

{
  core_text_space = malloc (bfd_get_section_size (core_text_sect));

  if (!core_text_space)
    {
      fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
              whoami, (unsigned long) bfd_get_section_size (core_text_sect));
      done (1);
    }

  if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
                             0, bfd_get_section_size (core_text_sect)))
    {
      bfd_perror ("bfd_get_section_contents");
      free (core_text_space);
      core_text_space = 0;
    }

  if (!core_text_space)
    fprintf (stderr, _("%s: can't do -c\n"), whoami);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void core_init ( const char *  aout_name)

Definition at line 149 of file corefile.c.

{
  int core_sym_bytes;
  asymbol *synthsyms;
  long synth_count;

  core_bfd = bfd_openr (aout_name, 0);

  if (!core_bfd)
    {
      perror (aout_name);
      done (1);
    }

  if (!bfd_check_format (core_bfd, bfd_object))
    {
      fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
      done (1);
    }

  /* Get core's text section.  */
  core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
  if (!core_text_sect)
    {
      core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
      if (!core_text_sect)
       {
         fprintf (stderr, _("%s: can't find .text section in %s\n"),
                 whoami, aout_name);
         done (1);
       }
    }

  /* Read core's symbol table.  */

  /* This will probably give us more than we need, but that's ok.  */
  core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
  if (core_sym_bytes < 0)
    {
      fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
              bfd_errmsg (bfd_get_error ()));
      done (1);
    }

  core_syms = (asymbol **) xmalloc (core_sym_bytes);
  core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);

  if (core_num_syms < 0)
    {
      fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
              bfd_errmsg (bfd_get_error ()));
      done (1);
    }

  synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
                                     0, NULL, &synthsyms);
  if (synth_count > 0)
    {
      asymbol **symp;
      long new_size;
      long i;

      new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
      core_syms = xrealloc (core_syms, new_size);
      symp = core_syms + core_num_syms;
      core_num_syms += synth_count;
      for (i = 0; i < synth_count; i++)
       *symp++ = synthsyms + i;
      *symp = 0;
    }

  min_insn_size = 1;
  offset_to_code = 0;

  switch (bfd_get_arch (core_bfd))
    {
    case bfd_arch_vax:
    case bfd_arch_tahoe:
      offset_to_code = 2;
      break;

    case bfd_arch_alpha:
      min_insn_size = 4;
      break;

    default:
      break;
    }

  if (function_mapping_file)
    read_function_mappings (function_mapping_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int core_sym_class ( asymbol sym) [static]

Definition at line 313 of file corefile.c.

{
  symbol_info syminfo;
  const char *name;
  char sym_prefix;
  int i;

  if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
    return 0;

  /* Must be a text symbol, and static text symbols
     don't qualify if ignore_static_funcs set.   */
  if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
    {
      DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
                           sym->name));
      return 0;
    }

  bfd_get_symbol_info (core_bfd, sym, &syminfo);
  i = syminfo.type;

  if (i == 'T')
    return i;               /* It's a global symbol.  */

  if (i == 'W')
    /* Treat weak symbols as text symbols.  FIXME: a weak symbol may
       also be a data symbol.  */
    return 'T';

  if (i != 't')
    {
      /* Not a static text symbol.  */
      DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
                           sym->name, i));
      return 0;
    }

  /* Do some more filtering on static function-names.  */
  if (ignore_static_funcs)
    return 0;

  /* Can't zero-length name or funny characters in name, where
     `funny' includes: `.' (.o file names) and `$' (Pascal labels).  */
  if (!sym->name || sym->name[0] == '\0')
    return 0;

  for (name = sym->name; *name; ++name)
    {
      if (*name == '.' || *name == '$')
       return 0;
    }

  /* On systems where the C compiler adds an underscore to all
     names, static names without underscores seem usually to be
     labels in hand written assembler in the library.  We don't want
     these names.  This is certainly necessary on a Sparc running
     SunOS 4.1 (try profiling a program that does a lot of
     division). I don't know whether it has harmful side effects on
     other systems.  Perhaps it should be made configurable.  */
  sym_prefix = bfd_get_symbol_leading_char (core_bfd);

  if ((sym_prefix && sym_prefix != sym->name[0])
      /* GCC may add special symbols to help gdb figure out the file
       language.  We want to ignore these, since sometimes they mask
       the real function.  (dj@ctron)  */
      || !strncmp (sym->name, "__gnu_compiled", 14)
      || !strncmp (sym->name, "___gnu_compiled", 15))
    {
      return 0;
    }

  /* If the object file supports marking of function symbols, then
     we can zap anything that doesn't have BSF_FUNCTION set.  */
  if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
    return 0;

  return 't';               /* It's a static text symbol.  */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 270 of file corefile.c.

{
  switch (bfd_get_arch (core_bfd))
    {
    case bfd_arch_i386:
      i386_find_call (parent, p_lowpc, p_highpc);
      break;

    case bfd_arch_alpha:
      alpha_find_call (parent, p_lowpc, p_highpc);
      break;

    case bfd_arch_vax:
      vax_find_call (parent, p_lowpc, p_highpc);
      break;

    case bfd_arch_sparc:
      sparc_find_call (parent, p_lowpc, p_highpc);
      break;

    case bfd_arch_tahoe:
      tahoe_find_call (parent, p_lowpc, p_highpc);
      break;

    case bfd_arch_mips:
      mips_find_call (parent, p_lowpc, p_highpc);
      break;

    default:
      fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
              whoami, bfd_printable_name(core_bfd));

      /* Don't give the error more than once.  */
      ignore_direct_calls = FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean get_src_info ( bfd_vma  addr,
const char **  filename,
const char **  name,
int line_num 
) [static]

Definition at line 396 of file corefile.c.

{
  const char *fname = 0, *func_name = 0;
  int l = 0;

  if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
                          addr - core_text_sect->vma,
                          &fname, &func_name, (unsigned int *) &l)
      && fname && func_name && l)
    {
      DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
                           (unsigned long) addr, fname, l, func_name));
      *filename = fname;
      *name = func_name;
      *line_num = l;
      return TRUE;
    }
  else
    {
      DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
                           (long) addr, fname ? fname : "<unknown>", l,
                           func_name ? func_name : "<unknown>"));
      return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void i386_find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 50 of file i386.c.

{
  unsigned char *instructp;
  Sym *child;
  bfd_vma pc, destpc;

  if (core_text_space == 0)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));

  for (pc = p_lowpc; pc < p_highpc; ++pc)
    {
      instructp = (unsigned char *) core_text_space + pc - core_text_sect->vma;
      if (i386_iscall (instructp))
       {
         DBG (CALLDEBUG,
              printf ("[findcall]\t0x%lx:call", (unsigned long) pc));
         /*
          *  regular pc relative addressing
          *    check that this is the address of
          *    a function.
          */

         destpc = bfd_get_32 (core_bfd, instructp + 1) + pc + 5;
         if (destpc >= s_lowpc && destpc <= s_highpc)
           {
             child = sym_lookup (&symtab, destpc);
             if (child && child->addr == destpc)
              {
                /*
                 *      a hit
                 */
                DBG (CALLDEBUG,
                     printf ("\tdestpc 0x%lx (%s)\n",
                            (unsigned long) destpc, child->name));
                arc_add (parent, child, (unsigned long) 0);
                instructp += 4;    /* call is a 5 byte instruction */
                continue;
              }
           }
         /*
          *  else:
          *    it looked like a callf, but it:
          *      a) wasn't actually a callf, or
          *      b) didn't point to a known function in the symtab, or
          *      c) something funny is going on.
          */
         DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mips_find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 42 of file mips.c.

{
  bfd_vma pc, dest_pc;
  unsigned int op;
  int offset;
  Sym *child;
  static bfd_boolean inited = FALSE;

  if (!inited)
    {
      inited = TRUE;
      sym_init (&indirect_child);
      indirect_child.name = _("<indirect child>");
      indirect_child.cg.prop.fract = 1.0;
      indirect_child.cg.cyc.head = &indirect_child;
    }

  if (!core_text_space)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf (_("[find_call] %s: 0x%lx to 0x%lx\n"),
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));
  for (pc = p_lowpc; pc < p_highpc; pc += 4)
    {
      op = bfd_get_32 (core_bfd, &((char *)core_text_space)[pc - s_lowpc]);
      if ((op & 0xfc000000) == 0x0c000000)
       {
         /* This is a "jal" instruction.  Check that the destination
            is the address of a function.  */
         DBG (CALLDEBUG,
              printf (_("[find_call] 0x%lx: jal"), (unsigned long) pc));
          offset = (op & 0x03ffffff) << 2;
         dest_pc = (pc & ~(bfd_vma) 0xfffffff) | offset;
         if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
           {
             child = sym_lookup (&symtab, dest_pc);
             DBG (CALLDEBUG,
                 printf (" 0x%lx\t; name=%s, addr=0x%lx",
                        (unsigned long) dest_pc, child->name,
                        (unsigned long) child->addr));
             if (child->addr == dest_pc)
              {
                DBG (CALLDEBUG, printf ("\n"));
                /* a hit:  */
                arc_add (parent, child, (unsigned long) 0);
                continue;
              }
           }
         /* Something funny going on.  */
         DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
       }
      else if ((op & 0xfc00f83f) == 0x0000f809)
       {
         /* This is a "jalr" instruction (indirect call).  */
         DBG (CALLDEBUG,
              printf (_("[find_call] 0x%lx: jalr\n"), (unsigned long) pc));
         arc_add (parent, &indirect_child, (unsigned long) 0);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void parse_error ( const char *  filename) [static]

Definition at line 56 of file corefile.c.

{
  fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename);
  done (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void read_function_mappings ( const char *  filename) [static]

Definition at line 63 of file corefile.c.

{
  FILE *file = fopen (filename, "r");
  char dummy[1024];
  int count = 0;

  if (!file)
    {
      fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
      done (1);
    }

  /* First parse the mapping file so we know how big we need to
     make our tables.  We also do some sanity checks at this
     time.  */
  while (!feof (file))
    {
      int matches;

      matches = fscanf (file, "%[^\n:]", dummy);
      if (!matches)
       parse_error (filename);

      /* Just skip messages about files with no symbols.  */
      if (!strncmp (dummy, "No symbols in ", 14))
       {
         matches = fscanf (file, "\n");
         if (matches == EOF)
           parse_error (filename);
         continue;
       }

      /* Don't care what else is on this line at this point.  */
      matches = fscanf (file, "%[^\n]\n", dummy);
      if (!matches)
       parse_error (filename);
      count++;
    }

  /* Now we know how big we need to make our table.  */
  symbol_map = ((struct function_map *)
              xmalloc (count * sizeof (struct function_map)));

  /* Rewind the input file so we can read it again.  */
  rewind (file);

  /* Read each entry and put it into the table.  */
  count = 0;
  while (!feof (file))
    {
      int matches;
      char *tmp;

      matches = fscanf (file, "%[^\n:]", dummy);
      if (!matches)
       parse_error (filename);

      /* Just skip messages about files with no symbols.  */
      if (!strncmp (dummy, "No symbols in ", 14))
       {
         matches = fscanf (file, "\n");
         if (matches == EOF)
           parse_error (filename);
         continue;
       }

      /* dummy has the filename, go ahead and copy it.  */
      symbol_map[count].file_name = xmalloc (strlen (dummy) + 1);
      strcpy (symbol_map[count].file_name, dummy);

      /* Now we need the function name.  */
      matches = fscanf (file, "%[^\n]\n", dummy);
      if (!matches)
       parse_error (filename);
      tmp = strrchr (dummy, ' ') + 1;
      symbol_map[count].function_name = xmalloc (strlen (tmp) + 1);
      strcpy (symbol_map[count].function_name, tmp);
      count++;
    }

  /* Record the size of the map table for future reference.  */
  symbol_map_count = count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sparc_find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 45 of file sparc.c.

{
  bfd_vma pc, dest_pc;
  unsigned int insn;
  Sym *child;

  if (core_text_space == 0)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf ("[find_call] %s: 0x%lx to 0x%lx\n",
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));
  for (pc = (p_lowpc + 3) & ~(bfd_vma) 3; pc < p_highpc; pc += 4)
    {
      insn = bfd_get_32 (core_bfd, ((unsigned char *) core_text_space
                                + pc - core_text_sect->vma));
      if (insn & CALL)
       {
         DBG (CALLDEBUG,
              printf ("[find_call] 0x%lx: callf", (unsigned long) pc));
         /*
          * Regular pc relative addressing check that this is the
          * address of a function.
          */
         dest_pc = pc + (((bfd_signed_vma) (insn & 0x3fffffff)
                        ^ 0x20000000) - 0x20000000);
         if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
           {
             child = sym_lookup (&symtab, dest_pc);
             DBG (CALLDEBUG,
                 printf ("\tdest_pc=0x%lx, (name=%s, addr=0x%lx)\n",
                        (unsigned long) dest_pc, child->name,
                        (unsigned long) child->addr));
             if (child->addr == dest_pc)
              {
                /* a hit:  */
                arc_add (parent, child, (unsigned long) 0);
                continue;
              }
           }
         /*
          * Something funny going on.
          */
         DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void tahoe_find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 220 of file tahoe.c.

{
  unsigned char *instructp;
  long length;
  Sym *child;
  tahoe_operandenum mode;
  tahoe_operandenum firstmode;
  bfd_vma pc, destpc;
  static bfd_boolean inited = FALSE;

  if (!inited)
    {
      inited = TRUE;
      sym_init (&indirectchild);
      indirectchild.cg.prop.fract = 1.0;
      indirectchild.cg.cyc.head = &indirectchild;
    }

  if (core_text_space == 0)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));
  for (pc = p_lowpc; pc < p_highpc; pc += length)
    {
      length = 1;
      instructp = ((unsigned char *) core_text_space
                 + pc - core_text_sect->vma);
      if ((*instructp & 0xff) == CALLF)
       {
         /*
          *    maybe a callf, better check it out.
          *      skip the count of the number of arguments.
          */
         DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
                              (unsigned long) pc));
         firstmode = tahoe_operandmode (instructp + length);
         switch (firstmode)
           {
           case literal:
           case immediate:
             break;
           default:
             goto botched;
           }
         length += tahoe_operandlength (instructp + length);
         mode = tahoe_operandmode (instructp + length);
         DBG (CALLDEBUG,
              printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
              printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
           );
         switch (mode)
           {
           case regdef:
           case bytedispdef:
           case worddispdef:
           case longdispdef:
           case bytereldef:
           case wordreldef:
           case longreldef:
             /*
              *    indirect call: call through pointer
              *      either  *d(r)   as a parameter or local
              *              (r)     as a return value
              *              *f      as a global pointer
              *      [are there others that we miss?,
              *       e.g. arrays of pointers to functions???]
              */
             arc_add (parent, &indirectchild, (unsigned long) 0);
             length += tahoe_operandlength (instructp + length);
             continue;
           case byterel:
           case wordrel:
           case longrel:
             /*
              *    regular pc relative addressing
              *      check that this is the address of
              *      a function.
              */
             destpc = pc + tahoe_offset (instructp + length);
             if (destpc >= s_lowpc && destpc <= s_highpc)
              {
                child = sym_lookup (&symtab, destpc);
                DBG (CALLDEBUG,
                     printf ("[findcall]\tdestpc 0x%lx",
                            (unsigned long) destpc);
                     printf (" child->name %s", child->name);
                     printf (" child->addr 0x%lx\n",
                            (unsigned long) child->addr);
                  );
                if (child->addr == destpc)
                  {
                    /*
                     *    a hit
                     */
                    arc_add (parent, child, (unsigned long) 0);
                    length += tahoe_operandlength (instructp + length);
                    continue;
                  }
                goto botched;
              }
             /*
              *    else:
              *      it looked like a callf,
              *      but it wasn't to anywhere.
              */
             goto botched;
           default:
           botched:
             /*
              *    something funny going on.
              */
             DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
             length = 1;
             continue;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vax_find_call ( Sym parent,
bfd_vma  p_lowpc,
bfd_vma  p_highpc 
)

Definition at line 232 of file vax.c.

{
  unsigned char *instructp;
  long length;
  Sym *child;
  operandenum mode;
  operandenum firstmode;
  bfd_vma pc, destpc;
  static bfd_boolean inited = FALSE;

  if (!inited)
    {
      inited = TRUE;
      sym_init (&indirectchild);
      indirectchild.cg.prop.fract = 1.0;
      indirectchild.cg.cyc.head = &indirectchild;
    }

  if (core_text_space == 0)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
                       parent->name, (unsigned long) p_lowpc,
                       (unsigned long) p_highpc));
  for (pc = p_lowpc; pc < p_highpc; pc += length)
    {
      length = 1;
      instructp = ((unsigned char *) core_text_space
                 + pc - core_text_sect->vma);
      if ((*instructp & 0xff) == CALLS)
       {
         /*
          *    maybe a calls, better check it out.
          *      skip the count of the number of arguments.
          */
         DBG (CALLDEBUG,
              printf ("[findcall]\t0x%lx:calls", (unsigned long) pc));
         firstmode = vax_operandmode (instructp + length);
         switch (firstmode)
           {
           case literal:
           case immediate:
             break;
           default:
             goto botched;
           }
         length += vax_operandlength (instructp + length);
         mode = vax_operandmode (instructp + length);
         DBG (CALLDEBUG,
              printf ("\tfirst operand is %s", vax_operandname (firstmode));
              printf ("\tsecond operand is %s\n", vax_operandname (mode)));
         switch (mode)
           {
           case regdef:
           case bytedispdef:
           case worddispdef:
           case longdispdef:
           case bytereldef:
           case wordreldef:
           case longreldef:
             /*
              *    indirect call: call through pointer
              *      either  *d(r)   as a parameter or local
              *              (r)     as a return value
              *              *f      as a global pointer
              *      [are there others that we miss?,
              *       e.g. arrays of pointers to functions???]
              */
             arc_add (parent, &indirectchild, (unsigned long) 0);
             length += vax_operandlength (instructp + length);
             continue;
           case byterel:
           case wordrel:
           case longrel:
             /*
              *    regular pc relative addressing
              *      check that this is the address of
              *      a function.
              */
             destpc = pc + vax_offset (instructp + length);
             if (destpc >= s_lowpc && destpc <= s_highpc)
              {
                child = sym_lookup (&symtab, destpc);
                DBG (CALLDEBUG,
                     printf ("[findcall]\tdestpc 0x%lx",
                            (unsigned long) destpc);
                     printf (" child->name %s", child->name);
                     printf (" child->addr 0x%lx\n",
                            (unsigned long) child->addr);
                  );
                if (child->addr == destpc)
                  {
                    /*
                     *    a hit
                     */
                    arc_add (parent, child, (unsigned long) 0);
                    length += vax_operandlength (instructp + length);
                    continue;
                  }
                goto botched;
              }
             /*
              *    else:
              *      it looked like a calls,
              *      but it wasn't to anywhere.
              */
             goto botched;
           default:
           botched:
             /*
              *    something funny going on.
              */
             DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
             length = 1;
             continue;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 30 of file corefile.c.

int core_num_syms [static]

Definition at line 31 of file corefile.c.

asymbol** core_syms [static]

Definition at line 32 of file corefile.c.

Definition at line 33 of file corefile.c.

Definition at line 34 of file corefile.c.

int min_insn_size [static]

Definition at line 36 of file corefile.c.

Definition at line 37 of file corefile.c.

Definition at line 40 of file corefile.c.

Definition at line 41 of file corefile.c.