Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions | Variables
syms.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "safe-ctype.h"
#include "bfdlink.h"
#include "aout/stab_gnu.h"

Go to the source code of this file.

Classes

struct  section_to_type
struct  indexentry
struct  stab_find_info

Defines

#define ENABLE_CACHING
#define STRDXOFF   (0)
#define TYPEOFF   (4)
#define OTHEROFF   (5)
#define DESCOFF   (6)
#define VALOFF   (8)
#define STABSIZE   (12)

Functions

bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym)
bfd_boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
void bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
asymbol_bfd_generic_make_empty_symbol (bfd *abfd)
static char coff_section_type (const char *s)
static char decode_section_type (const struct bfd_section *section)
int bfd_decode_symclass (asymbol *symbol)
bfd_boolean bfd_is_undefined_symclass (int symclass)
void bfd_symbol_info (asymbol *symbol, symbol_info *ret)
long _bfd_generic_read_minisymbols (bfd *abfd, bfd_boolean dynamic, void **minisymsp, unsigned int *sizep)
asymbol_bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic ATTRIBUTE_UNUSED, const void *minisym, asymbol *sym ATTRIBUTE_UNUSED)
static int cmpindexentry (const void *a, const void *b)
bfd_boolean _bfd_stab_section_find_nearest_line (bfd *abfd, asymbol **symbols, asection *section, bfd_vma offset, bfd_boolean *pfound, const char **pfilename, const char **pfnname, unsigned int *pline, void **pinfo)

Variables

static struct section_to_type []

Class Documentation

struct section_to_type

Definition at line 550 of file syms.c.

Class Members
const char * section
char type
struct indexentry

Definition at line 850 of file syms.c.

Class Members
char * directory_name
char * file_name
char * function_name
bfd_byte * stab
bfd_byte * str
bfd_vma val
struct stab_find_info

Definition at line 878 of file syms.c.

Collaboration diagram for stab_find_info:
Class Members
char * cached_file_name
struct indexentry * cached_indexentry
bfd_vma cached_offset
bfd_byte * cached_stab
char * filename
struct indexentry * indextable
int indextablesize
bfd_byte * stabs
asection * stabsec
bfd_byte * strs
asection * strsec

Define Documentation

#define DESCOFF   (6)
#define ENABLE_CACHING

Definition at line 844 of file syms.c.

#define OTHEROFF   (5)
#define STABSIZE   (12)
#define STRDXOFF   (0)
#define TYPEOFF   (4)
#define VALOFF   (8)

Function Documentation

Definition at line 527 of file syms.c.

{
  bfd_size_type amt = sizeof (asymbol);
  asymbol *new = bfd_zalloc (abfd, amt);
  if (new)
    new->the_bfd = abfd;
  return new;
}

Here is the call graph for this function:

asymbol* _bfd_generic_minisymbol_to_symbol ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_boolean dynamic  ATTRIBUTE_UNUSED,
const void *  minisym,
asymbol *sym  ATTRIBUTE_UNUSED 
)

Definition at line 825 of file syms.c.

{
  return *(asymbol **) minisym;
}
long _bfd_generic_read_minisymbols ( bfd abfd,
bfd_boolean  dynamic,
void **  minisymsp,
unsigned int sizep 
)

Definition at line 780 of file syms.c.

{
  long storage;
  asymbol **syms = NULL;
  long symcount;

  if (dynamic)
    storage = bfd_get_dynamic_symtab_upper_bound (abfd);
  else
    storage = bfd_get_symtab_upper_bound (abfd);
  if (storage < 0)
    goto error_return;
  if (storage == 0)
    return 0;

  syms = bfd_malloc (storage);
  if (syms == NULL)
    goto error_return;

  if (dynamic)
    symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
  else
    symcount = bfd_canonicalize_symtab (abfd, syms);
  if (symcount < 0)
    goto error_return;

  *minisymsp = syms;
  *sizep = sizeof (asymbol *);
  return symcount;

 error_return:
  bfd_set_error (bfd_error_no_symbols);
  if (syms != NULL)
    free (syms);
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean _bfd_stab_section_find_nearest_line ( bfd abfd,
asymbol **  symbols,
asection section,
bfd_vma  offset,
bfd_boolean pfound,
const char **  pfilename,
const char **  pfnname,
unsigned int pline,
void **  pinfo 
)

Definition at line 907 of file syms.c.

{
  struct stab_find_info *info;
  bfd_size_type stabsize, strsize;
  bfd_byte *stab, *str;
  bfd_byte *last_stab = NULL;
  bfd_size_type stroff;
  struct indexentry *indexentry;
  char *file_name;
  char *directory_name;
  int saw_fun;
  bfd_boolean saw_line, saw_func;

  *pfound = FALSE;
  *pfilename = bfd_get_filename (abfd);
  *pfnname = NULL;
  *pline = 0;

  /* Stabs entries use a 12 byte format:
       4 byte string table index
       1 byte stab type
       1 byte stab other field
       2 byte stab desc field
       4 byte stab value
     FIXME: This will have to change for a 64 bit object format.

     The stabs symbols are divided into compilation units.  For the
     first entry in each unit, the type of 0, the value is the length
     of the string table for this unit, and the desc field is the
     number of stabs symbols for this unit.  */

#define STRDXOFF (0)
#define TYPEOFF (4)
#define OTHEROFF (5)
#define DESCOFF (6)
#define VALOFF (8)
#define STABSIZE (12)

  info = *pinfo;
  if (info != NULL)
    {
      if (info->stabsec == NULL || info->strsec == NULL)
       {
         /* No stabs debugging information.  */
         return TRUE;
       }

      stabsize = (info->stabsec->rawsize
                ? info->stabsec->rawsize
                : info->stabsec->size);
      strsize = (info->strsec->rawsize
               ? info->strsec->rawsize
               : info->strsec->size);
    }
  else
    {
      long reloc_size, reloc_count;
      arelent **reloc_vector;
      int i;
      char *name;
      char *function_name;
      bfd_size_type amt = sizeof *info;

      info = bfd_zalloc (abfd, amt);
      if (info == NULL)
       return FALSE;

      /* FIXME: When using the linker --split-by-file or
        --split-by-reloc options, it is possible for the .stab and
        .stabstr sections to be split.  We should handle that.  */

      info->stabsec = bfd_get_section_by_name (abfd, ".stab");
      info->strsec = bfd_get_section_by_name (abfd, ".stabstr");

      if (info->stabsec == NULL || info->strsec == NULL)
       {
         /* No stabs debugging information.  Set *pinfo so that we
             can return quickly in the info != NULL case above.  */
         *pinfo = info;
         return TRUE;
       }

      stabsize = (info->stabsec->rawsize
                ? info->stabsec->rawsize
                : info->stabsec->size);
      strsize = (info->strsec->rawsize
               ? info->strsec->rawsize
               : info->strsec->size);

      info->stabs = bfd_alloc (abfd, stabsize);
      info->strs = bfd_alloc (abfd, strsize);
      if (info->stabs == NULL || info->strs == NULL)
       return FALSE;

      if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
                                  0, stabsize)
         || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
                                    0, strsize))
       return FALSE;

      /* If this is a relocatable object file, we have to relocate
        the entries in .stab.  This should always be simple 32 bit
        relocations against symbols defined in this object file, so
        this should be no big deal.  */
      reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
      if (reloc_size < 0)
       return FALSE;
      reloc_vector = bfd_malloc (reloc_size);
      if (reloc_vector == NULL && reloc_size != 0)
       return FALSE;
      reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
                                       symbols);
      if (reloc_count < 0)
       {
         if (reloc_vector != NULL)
           free (reloc_vector);
         return FALSE;
       }
      if (reloc_count > 0)
       {
         arelent **pr;

         for (pr = reloc_vector; *pr != NULL; pr++)
           {
             arelent *r;
             unsigned long val;
             asymbol *sym;

             r = *pr;
             /* Ignore R_*_NONE relocs.  */
             if (r->howto->dst_mask == 0)
              continue;

             if (r->howto->rightshift != 0
                || r->howto->size != 2
                || r->howto->bitsize != 32
                || r->howto->pc_relative
                || r->howto->bitpos != 0
                || r->howto->dst_mask != 0xffffffff)
              {
                (*_bfd_error_handler)
                  (_("Unsupported .stab relocation"));
                bfd_set_error (bfd_error_invalid_operation);
                if (reloc_vector != NULL)
                  free (reloc_vector);
                return FALSE;
              }

             val = bfd_get_32 (abfd, info->stabs + r->address);
             val &= r->howto->src_mask;
             sym = *r->sym_ptr_ptr;
             val += sym->value + sym->section->vma + r->addend;
             bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
           }
       }

      if (reloc_vector != NULL)
       free (reloc_vector);

      /* First time through this function, build a table matching
        function VM addresses to stabs, then sort based on starting
        VM address.  Do this in two passes: once to count how many
        table entries we'll need, and a second to actually build the
        table.  */

      info->indextablesize = 0;
      saw_fun = 1;
      for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
       {
         if (stab[TYPEOFF] == (bfd_byte) N_SO)
           {
             /* N_SO with null name indicates EOF */
             if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
              continue;

             /* if we did not see a function def, leave space for one.  */
             if (saw_fun == 0)
              ++info->indextablesize;

             saw_fun = 0;

             /* two N_SO's in a row is a filename and directory. Skip */
             if (stab + STABSIZE < info->stabs + stabsize
                && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
              {
                stab += STABSIZE;
              }
           }
         else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
           {
             saw_fun = 1;
             ++info->indextablesize;
           }
       }

      if (saw_fun == 0)
       ++info->indextablesize;

      if (info->indextablesize == 0)
       return TRUE;
      ++info->indextablesize;

      amt = info->indextablesize;
      amt *= sizeof (struct indexentry);
      info->indextable = bfd_alloc (abfd, amt);
      if (info->indextable == NULL)
       return FALSE;

      file_name = NULL;
      directory_name = NULL;
      saw_fun = 1;

      for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
          i < info->indextablesize && stab < info->stabs + stabsize;
          stab += STABSIZE)
       {
         switch (stab[TYPEOFF])
           {
           case 0:
             /* This is the first entry in a compilation unit.  */
             if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
              break;
             str += stroff;
             stroff = bfd_get_32 (abfd, stab + VALOFF);
             break;

           case N_SO:
             /* The main file name.  */

             /* The following code creates a new indextable entry with
                a NULL function name if there were no N_FUNs in a file.
                Note that a N_SO without a file name is an EOF and
                there could be 2 N_SO following it with the new filename
                and directory.  */
             if (saw_fun == 0)
              {
                info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
                info->indextable[i].stab = last_stab;
                info->indextable[i].str = str;
                info->indextable[i].directory_name = directory_name;
                info->indextable[i].file_name = file_name;
                info->indextable[i].function_name = NULL;
                ++i;
              }
             saw_fun = 0;

             file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
             if (*file_name == '\0')
              {
                directory_name = NULL;
                file_name = NULL;
                saw_fun = 1;
              }
             else
              {
                last_stab = stab;
                if (stab + STABSIZE >= info->stabs + stabsize
                    || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
                  {
                    directory_name = NULL;
                  }
                else
                  {
                    /* Two consecutive N_SOs are a directory and a
                      file name.  */
                    stab += STABSIZE;
                    directory_name = file_name;
                    file_name = ((char *) str
                               + bfd_get_32 (abfd, stab + STRDXOFF));
                  }
              }
             break;

           case N_SOL:
             /* The name of an include file.  */
             file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
             break;

           case N_FUN:
             /* A function name.  */
             saw_fun = 1;
             name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);

             if (*name == '\0')
              name = NULL;

             function_name = name;

             if (name == NULL)
              continue;

             info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
             info->indextable[i].stab = stab;
             info->indextable[i].str = str;
             info->indextable[i].directory_name = directory_name;
             info->indextable[i].file_name = file_name;
             info->indextable[i].function_name = function_name;
             ++i;
             break;
           }
       }

      if (saw_fun == 0)
       {
         info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
         info->indextable[i].stab = last_stab;
         info->indextable[i].str = str;
         info->indextable[i].directory_name = directory_name;
         info->indextable[i].file_name = file_name;
         info->indextable[i].function_name = NULL;
         ++i;
       }

      info->indextable[i].val = (bfd_vma) -1;
      info->indextable[i].stab = info->stabs + stabsize;
      info->indextable[i].str = str;
      info->indextable[i].directory_name = NULL;
      info->indextable[i].file_name = NULL;
      info->indextable[i].function_name = NULL;
      ++i;

      info->indextablesize = i;
      qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
            cmpindexentry);

      *pinfo = info;
    }

  /* We are passed a section relative offset.  The offsets in the
     stabs information are absolute.  */
  offset += bfd_get_section_vma (abfd, section);

#ifdef ENABLE_CACHING
  if (info->cached_indexentry != NULL
      && offset >= info->cached_offset
      && offset < (info->cached_indexentry + 1)->val)
    {
      stab = info->cached_stab;
      indexentry = info->cached_indexentry;
      file_name = info->cached_file_name;
    }
  else
#endif
    {
      long low, high;
      long mid = -1;

      /* Cache non-existent or invalid.  Do binary search on
         indextable.  */
      indexentry = NULL;

      low = 0;
      high = info->indextablesize - 1;
      while (low != high)
       {
         mid = (high + low) / 2;
         if (offset >= info->indextable[mid].val
             && offset < info->indextable[mid + 1].val)
           {
             indexentry = &info->indextable[mid];
             break;
           }

         if (info->indextable[mid].val > offset)
           high = mid;
         else
           low = mid + 1;
       }

      if (indexentry == NULL)
       return TRUE;

      stab = indexentry->stab + STABSIZE;
      file_name = indexentry->file_name;
    }

  directory_name = indexentry->directory_name;
  str = indexentry->str;

  saw_line = FALSE;
  saw_func = FALSE;
  for (; stab < (indexentry+1)->stab; stab += STABSIZE)
    {
      bfd_boolean done;
      bfd_vma val;

      done = FALSE;

      switch (stab[TYPEOFF])
       {
       case N_SOL:
         /* The name of an include file.  */
         val = bfd_get_32 (abfd, stab + VALOFF);
         if (val <= offset)
           {
             file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
             *pline = 0;
           }
         break;

       case N_SLINE:
       case N_DSLINE:
       case N_BSLINE:
         /* A line number.  If the function was specified, then the value
            is relative to the start of the function.  Otherwise, the
            value is an absolute address.  */
         val = ((indexentry->function_name ? indexentry->val : 0)
               + bfd_get_32 (abfd, stab + VALOFF));
         /* If this line starts before our desired offset, or if it's
            the first line we've been able to find, use it.  The
            !saw_line check works around a bug in GCC 2.95.3, which emits
            the first N_SLINE late.  */
         if (!saw_line || val <= offset)
           {
             *pline = bfd_get_16 (abfd, stab + DESCOFF);

#ifdef ENABLE_CACHING
             info->cached_stab = stab;
             info->cached_offset = val;
             info->cached_file_name = file_name;
             info->cached_indexentry = indexentry;
#endif
           }
         if (val > offset)
           done = TRUE;
         saw_line = TRUE;
         break;

       case N_FUN:
       case N_SO:
         if (saw_func || saw_line)
           done = TRUE;
         saw_func = TRUE;
         break;
       }

      if (done)
       break;
    }

  *pfound = TRUE;

  if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
      || directory_name == NULL)
    *pfilename = file_name;
  else
    {
      size_t dirlen;

      dirlen = strlen (directory_name);
      if (info->filename == NULL
         || strncmp (info->filename, directory_name, dirlen) != 0
         || strcmp (info->filename + dirlen, file_name) != 0)
       {
         size_t len;

         if (info->filename != NULL)
           free (info->filename);
         len = strlen (file_name) + 1;
         info->filename = bfd_malloc (dirlen + len);
         if (info->filename == NULL)
           return FALSE;
         memcpy (info->filename, directory_name, dirlen);
         memcpy (info->filename + dirlen, file_name, len);
       }

      *pfilename = info->filename;
    }

  if (indexentry->function_name != NULL)
    {
      char *s;

      /* This will typically be something like main:F(0,1), so we want
         to clobber the colon.  It's OK to change the name, since the
         string is in our own local storage anyhow.  */
      s = strchr (indexentry->function_name, ':');
      if (s != NULL)
       *s = '\0';

      *pfnname = indexentry->function_name;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 649 of file syms.c.

{
  char c;

  if (bfd_is_com_section (symbol->section))
    return 'C';
  if (bfd_is_und_section (symbol->section))
    {
      if (symbol->flags & BSF_WEAK)
       {
         /* If weak, determine if it's specifically an object
            or non-object weak.  */
         if (symbol->flags & BSF_OBJECT)
           return 'v';
         else
           return 'w';
       }
      else
       return 'U';
    }
  if (bfd_is_ind_section (symbol->section))
    return 'I';
  if (symbol->flags & BSF_WEAK)
    {
      /* If weak, determine if it's specifically an object
        or non-object weak.  */
      if (symbol->flags & BSF_OBJECT)
       return 'V';
      else
       return 'W';
    }
  if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
    return '?';

  if (bfd_is_abs_section (symbol->section))
    c = 'a';
  else if (symbol->section)
    {
      c = coff_section_type (symbol->section->name);
      if (c == '?')
       c = decode_section_type (symbol->section);
    }
  else
    return '?';
  if (symbol->flags & BSF_GLOBAL)
    c = TOUPPER (c);
  return c;

  /* We don't have to handle these cases just yet, but we will soon:
     N_SETV: 'v';
     N_SETA: 'l';
     N_SETT: 'x';
     N_SETD: 'z';
     N_SETB: 's';
     N_INDR: 'i';
     */
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean bfd_is_local_label ( bfd abfd,
asymbol sym 
)

Definition at line 361 of file syms.c.

{
  /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
     starts with '.' is local.  This would accidentally catch section names
     if we didn't reject them here.  */
  if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
    return FALSE;
  if (sym->name == NULL)
    return FALSE;
  return bfd_is_local_label_name (abfd, sym->name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 721 of file syms.c.

{
  return symclass == 'U' || symclass == 'w' || symclass == 'v';
}

Here is the caller graph for this function:

void bfd_print_symbol_vandf ( bfd abfd,
void *  arg,
asymbol symbol 
)

Definition at line 464 of file syms.c.

{
  FILE *file = arg;

  flagword type = symbol->flags;

  if (symbol->section != NULL)
    bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
  else
    bfd_fprintf_vma (abfd, file, symbol->value);

  /* This presumes that a symbol can not be both BSF_DEBUGGING and
     BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
     BSF_OBJECT.  */
  fprintf (file, " %c%c%c%c%c%c%c",
          ((type & BSF_LOCAL)
           ? (type & BSF_GLOBAL) ? '!' : 'l'
           : (type & BSF_GLOBAL) ? 'g' : ' '),
          (type & BSF_WEAK) ? 'w' : ' ',
          (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
          (type & BSF_WARNING) ? 'W' : ' ',
          (type & BSF_INDIRECT) ? 'I' : ' ',
          (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
          ((type & BSF_FUNCTION)
           ? 'F'
           : ((type & BSF_FILE)
              ? 'f'
              : ((type & BSF_OBJECT) ? 'O' : ' '))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean bfd_set_symtab ( bfd abfd,
asymbol **  location,
unsigned int  symcount 
)

Definition at line 439 of file syms.c.

{
  if (abfd->format != bfd_object || bfd_read_p (abfd))
    {
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
    }

  bfd_get_outsymbols (abfd) = location;
  bfd_get_symcount (abfd) = symcount;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_symbol_info ( asymbol symbol,
symbol_info ret 
)

Definition at line 740 of file syms.c.

{
  ret->type = bfd_decode_symclass (symbol);

  if (bfd_is_undefined_symclass (ret->type))
    ret->value = 0;
  else
    ret->value = symbol->value + symbol->section->vma;

  ret->name = symbol->name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int cmpindexentry ( const void *  a,
const void *  b 
) [static]

Definition at line 863 of file syms.c.

{
  const struct indexentry *contestantA = a;
  const struct indexentry *contestantB = b;

  if (contestantA->val < contestantB->val)
    return -1;
  else if (contestantA->val > contestantB->val)
    return 1;
  else
    return 0;
}

Here is the caller graph for this function:

static char coff_section_type ( const char *  s) [static]

Definition at line 590 of file syms.c.

{
  const struct section_to_type *t;

  for (t = &stt[0]; t->section; t++)
    if (!strncmp (s, t->section, strlen (t->section)))
      return t->type;

  return '?';
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char decode_section_type ( const struct bfd_section section) [static]

Definition at line 609 of file syms.c.

{
  if (section->flags & SEC_CODE)
    return 't';
  if (section->flags & SEC_DATA)
    {
      if (section->flags & SEC_READONLY)
       return 'r';
      else if (section->flags & SEC_SMALL_DATA)
       return 'g';
      else
       return 'd';
    }
  if ((section->flags & SEC_HAS_CONTENTS) == 0)
    {
      if (section->flags & SEC_SMALL_DATA)
       return 's';
      else
       return 'b';
    }
  if (section->flags & SEC_DEBUGGING)
    return 'N';
  if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
    return 'n';

  return '?';
}

Here is the caller graph for this function:


Variable Documentation

struct section_to_type[] [static]
Initial value:
{
  {".bss", 'b'},
  {"code", 't'},            
  {".data", 'd'},
  {"*DEBUG*", 'N'},
  {".debug", 'N'},              
  {".drectve", 'i'},            
  {".edata", 'e'},              
  {".fini", 't'},           
  {".idata", 'i'},              
  {".init", 't'},           
  {".pdata", 'p'},              
  {".rdata", 'r'},          
  {".rodata", 'r'},         
  {".sbss", 's'},           
  {".scommon", 'c'},        
  {".sdata", 'g'},          
  {".text", 't'},
  {"vars", 'd'},            
  {"zerovars", 'b'},        
  {0, 0}
}

Definition at line 559 of file syms.c.