Back to index

cell-binutils  2.17cvs20070401
Classes | Functions | Variables
sym_ids.c File Reference
#include "libiberty.h"
#include "safe-ctype.h"
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "cg_arcs.h"
#include "sym_ids.h"

Go to the source code of this file.

Classes

struct  sym_id
struct  sym_id::match

Functions

static void parse_spec (char *, Sym *)
static void parse_id (struct sym_id *)
static bfd_boolean match (Sym *, Sym *)
static void extend_match (struct match *, Sym *, Sym_Table *, bfd_boolean)
void sym_id_add (const char *spec, Table_Id which_table)
void sym_id_parse ()
bfd_boolean sym_id_arc_is_present (Sym_Table *sym_tab, Sym *from, Sym *to)

Variables

static struct sym_idid_list
Sym_Table syms [NUM_TABLES]
static Sym_Table right_ids
static Source_File non_existent_file

Class Documentation

struct sym_id

Definition at line 31 of file sym_ids.c.

Collaboration diagram for sym_id:
Class Members
bfd_boolean has_right
struct match left
struct sym_id * next
struct match right
char * spec
Table_Id which_table
struct sym_id::match

Definition at line 38 of file sym_ids.c.

Collaboration diagram for sym_id::match:
Class Members
Sym * first_match
int prev_index
Sym * prev_match
Sym sym

Function Documentation

static void extend_match ( struct match m,
Sym sym,
Sym_Table tab,
bfd_boolean  second_pass 
) [static]

Definition at line 231 of file sym_ids.c.

{
  if (m->prev_match != sym - 1)
    {
      /* Discontinuity: add new match to table.  */
      if (second_pass)
       {
         tab->base[tab->len] = *sym;
         m->prev_index = tab->len;

         /* Link match into match's chain.  */
         tab->base[tab->len].next = m->first_match;
         m->first_match = &tab->base[tab->len];
       }

      ++tab->len;
    }

  /* Extend match to include this symbol.  */
  if (second_pass)
    tab->base[m->prev_index].end_addr = sym->end_addr;

  m->prev_match = sym;
}

Here is the caller graph for this function:

static bfd_boolean match ( Sym pattern,
Sym sym 
) [static]

Definition at line 219 of file sym_ids.c.

{
  return (pattern->file ? pattern->file == sym->file : TRUE)
    && (pattern->line_num ? pattern->line_num == sym->line_num : TRUE)
    && (pattern->name
       ? strcmp (pattern->name,
                sym->name+(discard_underscores && sym->name[0] == '_')) == 0
       : TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void parse_id ( struct sym_id id) [static]

Definition at line 170 of file sym_ids.c.

{
  char *slash;

  DBG (IDDEBUG, printf ("[parse_id] %s -> ", id->spec));

  slash = strchr (id->spec, '/');
  if (slash)
    {
      parse_spec (slash + 1, &id->right.sym);
      *slash = '\0';
      id->has_right = TRUE;
    }
  parse_spec (id->spec, &id->left.sym);

#ifdef DEBUG
  if (debug_level & IDDEBUG)
    {
      printf ("%s:", id->left.sym.file ? id->left.sym.file->name : "*");

      if (id->left.sym.name)
       printf ("%s", id->left.sym.name);
      else if (id->left.sym.line_num)
       printf ("%d", id->left.sym.line_num);
      else
       printf ("*");

      if (id->has_right)
       {
         printf ("/%s:",
                id->right.sym.file ? id->right.sym.file->name : "*");

         if (id->right.sym.name)
           printf ("%s", id->right.sym.name);
         else if (id->right.sym.line_num)
           printf ("%d", id->right.sym.line_num);
         else
           printf ("*");
       }

      printf ("\n");
    }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void parse_spec ( char *  spec,
Sym sym 
) [static]

Definition at line 115 of file sym_ids.c.

{
  char *colon;

  sym_init (sym);
  colon = strrchr (spec, ':');

  if (colon)
    {
      *colon = '\0';

      if (colon > spec)
       {
         sym->file = source_file_lookup_name (spec);

         if (!sym->file)
           sym->file = &non_existent_file;
       }

      spec = colon + 1;

      if (strlen (spec))
       {
         if (ISDIGIT (spec[0]))
           sym->line_num = atoi (spec);
         else
           sym->name = spec;
       }
    }
  else if (strlen (spec))
    {
      /* No colon: spec is a filename if it contains a dot.  */
      if (strchr (spec, '.'))
       {
         sym->file = source_file_lookup_name (spec);

         if (!sym->file)
           sym->file = &non_existent_file;
       }
      else if (ISDIGIT (*spec))
       {
         sym->line_num = atoi (spec);
       }
      else if (strlen (spec))
       {
         sym->name = spec;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sym_id_add ( const char *  spec,
Table_Id  which_table 
)

Definition at line 87 of file sym_ids.c.

{
  struct sym_id *id;
  int len = strlen (spec);

  id = (struct sym_id *) xmalloc (sizeof (*id) + len + 1);
  memset (id, 0, sizeof (*id));

  id->spec = (char *) id + sizeof (*id);
  strcpy (id->spec, spec);
  id->which_table = which_table;

  id->next = id_list;
  id_list = id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean sym_id_arc_is_present ( Sym_Table sym_tab,
Sym from,
Sym to 
)

Definition at line 365 of file sym_ids.c.

{
  Sym *sym;

  for (sym = sym_tab->base; sym < sym_tab->limit; ++sym)
    {
      if (from->addr >= sym->addr && from->addr <= sym->end_addr
         && arc_lookup (sym, to))
       return TRUE;
    }

  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sym_id_parse ( void  )

Definition at line 266 of file sym_ids.c.

{
  Sym *sym, *left, *right;
  struct sym_id *id;
  Sym_Table *tab;

  /* Convert symbol ids into Syms, so we can deal with them more easily.  */
  for (id = id_list; id; id = id->next)
    parse_id (id);

  /* First determine size of each table.  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      for (id = id_list; id; id = id->next)
       {
         if (match (&id->left.sym, sym))
           extend_match (&id->left, sym, &syms[id->which_table], FALSE);

         if (id->has_right && match (&id->right.sym, sym))
           extend_match (&id->right, sym, &right_ids, FALSE);
       }
    }

  /* Create tables of appropriate size and reset lengths.  */
  for (tab = syms; tab < &syms[NUM_TABLES]; ++tab)
    {
      if (tab->len)
       {
         tab->base = (Sym *) xmalloc (tab->len * sizeof (Sym));
         tab->limit = tab->base + tab->len;
         tab->len = 0;
       }
    }

  if (right_ids.len)
    {
      right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym));
      right_ids.limit = right_ids.base + right_ids.len;
      right_ids.len = 0;
    }

  /* Make a second pass through symtab, creating syms as necessary.  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      for (id = id_list; id; id = id->next)
       {
         if (match (&id->left.sym, sym))
           extend_match (&id->left, sym, &syms[id->which_table], TRUE);

         if (id->has_right && match (&id->right.sym, sym))
           extend_match (&id->right, sym, &right_ids, TRUE);
       }
    }

  /* Go through ids creating arcs as needed.  */
  for (id = id_list; id; id = id->next)
    {
      if (id->has_right)
       {
         for (left = id->left.first_match; left; left = left->next)
           {
             for (right = id->right.first_match; right; right = right->next)
              {
                DBG (IDDEBUG,
                     printf (
                            "[sym_id_parse]: arc %s:%s(%lx-%lx) -> %s:%s(%lx-%lx) to %s\n",
                            left->file ? left->file->name : "*",
                            left->name ? left->name : "*",
                            (unsigned long) left->addr,
                            (unsigned long) left->end_addr,
                            right->file ? right->file->name : "*",
                            right->name ? right->name : "*",
                            (unsigned long) right->addr,
                            (unsigned long) right->end_addr,
                            table_name[id->which_table]));

                arc_add (left, right, (unsigned long) 0);
              }
           }
       }
    }

  /* Finally, we can sort the tables and we're done.  */
  for (tab = &syms[0]; tab < &syms[NUM_TABLES]; ++tab)
    {
      DBG (IDDEBUG, printf ("[sym_id_parse] syms[%s]:\n",
                         table_name[tab - &syms[0]]));
      symtab_finalize (tab);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

struct sym_id * id_list [static]
Initial value:
{
  0, "<non-existent-file>", 0, 0, 0, NULL
}

Definition at line 80 of file sym_ids.c.

Sym_Table right_ids [static]

Definition at line 78 of file sym_ids.c.

Definition at line 59 of file sym_ids.c.