Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Functions | Variables
symtab.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  sym
struct  Sym_Table
struct  sym.hist
struct  sym.cg
struct  sym.cg.prop
struct  sym.cg.cyc

Defines

#define NBBS   10

Typedefs

typedef struct sym Sym

Functions

void sym_init (Sym *)
void symtab_finalize (Sym_Table *)
Symsym_lookup (Sym_Table *, bfd_vma)
void find_call (Sym *, bfd_vma, bfd_vma)

Variables

Sym_Table symtab

Class Documentation

struct sym

Definition at line 36 of file symtab.h.

Collaboration diagram for sym:
Class Members
bfd_vma addr
bfd_vma bb_addr
unsigned long bb_calls
struct sym cg
bfd_vma end_addr
Source_File * file
unsigned int has_been_placed:1
struct sym hist
unsigned int is_bb_head:1
unsigned int is_func:1
unsigned int is_static:1
int line_num
unsigned int mapped:1
const char * name
unsigned long ncalls
struct sym * next
int nuses
struct sym * prev
struct Sym_Table

Definition at line 104 of file symtab.h.

Collaboration diagram for Sym_Table:
Class Members
Sym * base
unsigned int len
Sym * limit
struct sym.hist

Definition at line 66 of file symtab.h.

Class Members
bfd_vma scaled_addr
double time
struct sym.cg

Definition at line 74 of file symtab.h.

Class Members
double child_time
struct arc * children
cg cyc
int index
struct arc * parents
bfd_boolean print_flag
cg prop
unsigned long self_calls
int top_order
struct sym.cg.prop

Definition at line 81 of file symtab.h.

Class Members
double child
double fract
double self
struct sym.cg.cyc

Definition at line 88 of file symtab.h.

Class Members
struct sym * head
struct sym * next
int num

Define Documentation

#define NBBS   10

Definition at line 32 of file symtab.h.


Typedef Documentation

typedef struct sym Sym

Function Documentation

void find_call ( Sym ,
bfd_vma  ,
bfd_vma   
)

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:

void sym_init ( Sym )

Definition at line 37 of file symtab.c.

{
  memset (sym, 0, sizeof (*sym));

  /* It is not safe to assume that a binary zero corresponds
     to a floating-point 0.0, so initialize floats explicitly.  */
  sym->hist.time = 0.0;
  sym->cg.child_time = 0.0;
  sym->cg.prop.fract = 0.0;
  sym->cg.prop.self = 0.0;
  sym->cg.prop.child = 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sym* sym_lookup ( Sym_Table ,
bfd_vma   
)

Definition at line 216 of file symtab.c.

{
  long low, high;
  long mid = -1;
  Sym *sym;
#ifdef DEBUG
  int probes = 0;
#endif /* DEBUG */

  if (!sym_tab->len)
    return 0;

  sym = sym_tab->base;
  for (low = 0, high = sym_tab->len - 1; low != high;)
    {
      DBG (LOOKUPDEBUG, ++probes);
      mid = (high + low) / 2;

      if (sym[mid].addr <= address && sym[mid + 1].addr > address)
       {
         if (address > sym[mid].end_addr)
           {
             /* Address falls into gap between
               sym[mid] and sym[mid + 1].  */
             return 0;
           }
         else
           {
             DBG (LOOKUPDEBUG,
                 printf ("[sym_lookup] %d probes (symtab->len=%u)\n",
                        probes, sym_tab->len - 1));
             return &sym[mid];
           }
       }

      if (sym[mid].addr > address)
       high = mid;
      else
       low = mid + 1;
    }

  if (sym[mid + 1].addr <= address)
    {
      if (address > sym[mid + 1].end_addr)
       {
         /* Address is beyond end of sym[mid + 1].  */
         return 0;
       }
      else
       {
         DBG (LOOKUPDEBUG, printf ("[sym_lookup] %d (%u) probes, fall off\n",
                                probes, sym_tab->len - 1));
         return &sym[mid + 1];
       }
    }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void symtab_finalize ( Sym_Table )

Definition at line 79 of file symtab.c.

{
  Sym *src, *dst;
  bfd_vma prev_addr;

  if (!tab->len)
    return;

  /* Sort symbol table in order of increasing function addresses.  */
  qsort (tab->base, tab->len, sizeof (Sym), cmp_addr);

  /* Remove duplicate entries to speed-up later processing and
     set end_addr if its not set yet.  */
  prev_addr = tab->base[0].addr + 1;

  for (src = dst = tab->base; src < tab->limit; ++src)
    {
      if (src->addr == prev_addr)
       {
         /* If same address, favor global symbol over static one,
            then function over line number.  If both symbols are
            either static or global and either function or line, check
            whether one has name beginning with underscore while
            the other doesn't.  In such cases, keep sym without
            underscore.  This takes cares of compiler generated
            symbols (such as __gnu_compiled, __c89_used, etc.).  */
         if ((!src->is_static && dst[-1].is_static)
             || ((src->is_static == dst[-1].is_static)
                && ((src->is_func && !dst[-1].is_func)
                    || ((src->is_func == dst[-1].is_func)
                       && ((src->name[0] != '_' && dst[-1].name[0] == '_')
                           || (src->name[0]
                              && src->name[1] != '_'
                              && dst[-1].name[1] == '_'))))))
           {
             DBG (AOUTDEBUG | IDDEBUG,
                 printf ("[symtab_finalize] favor %s@%c%c over %s@%c%c",
                        src->name, src->is_static ? 't' : 'T',
                        src->is_func ? 'F' : 'f',
                        dst[-1].name, dst[-1].is_static ? 't' : 'T',
                        dst[-1].is_func ? 'F' : 'f');
                 printf (" (addr=%lx)\n", (unsigned long) src->addr));

             dst[-1] = *src;
           }
         else
           {
             DBG (AOUTDEBUG | IDDEBUG,
                 printf ("[symtab_finalize] favor %s@%c%c over %s@%c%c",
                        dst[-1].name, dst[-1].is_static ? 't' : 'T',
                        dst[-1].is_func ? 'F' : 'f',
                        src->name, src->is_static ? 't' : 'T',
                        src->is_func ? 'F' : 'f');
                 printf (" (addr=%lx)\n", (unsigned long) src->addr));
           }
       }
      else
       {
         if (dst > tab->base && dst[-1].end_addr == 0)
           dst[-1].end_addr = src->addr - 1;

         /* Retain sym only if it has a non-empty address range.  */
         if (!src->end_addr || src->addr <= src->end_addr)
           {
             *dst = *src;
             dst++;
             prev_addr = src->addr;
           }
       }
    }

  if (tab->len > 0 && dst[-1].end_addr == 0)
    dst[-1].end_addr
      = core_text_sect->vma + bfd_get_section_size (core_text_sect) - 1;

  DBG (AOUTDEBUG | IDDEBUG,
       printf ("[symtab_finalize]: removed %d duplicate entries\n",
              tab->len - (int) (dst - tab->base)));

  tab->limit = dst;
  tab->len = tab->limit - tab->base;

  DBG (AOUTDEBUG | IDDEBUG,
       unsigned int j;

       for (j = 0; j < tab->len; ++j)
        {
          printf ("[symtab_finalize] 0x%lx-0x%lx\t%s\n",
               (long) tab->base[j].addr, (long) tab->base[j].end_addr,
               tab->base[j].name);
        }
  );
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 31 of file symtab.c.