* wince-stub.c (FREE): New macro.

[deliverable/binutils-gdb.git] / bfd / syms.c

diff --git a/bfd/syms.c b/bfd/syms.c
index 138979c3f4bddbf89e4fa538000fd8e4ae2f3b58..6546f585054ac57673a13f43addbded5a15e1785 100644 (file)
--- a/bfd/syms.c
+++ b/bfd/syms.c
@@ -1,5 +1,6 @@
 /* Generic symbol-table support for the BFD library.
 /* Generic symbol-table support for the BFD library.

-   Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+   Free Software Foundation, Inc.

    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.


@@ -87,7 +88,7 @@ SUBSECTION
 |           process_symbol (symbol_table[i]);
 |        }
 
 |           process_symbol (symbol_table[i]);
 |        }
 

-       All storage for the symbols themselves is in an obstack
+       All storage for the symbols themselves is in an objalloc

        connected to the BFD; it is freed when the BFD is closed.
 
 
        connected to the BFD; it is freed when the BFD is closed.
 
 


@@ -226,7 +227,7 @@ CODE_FRAGMENT
 .         <<BSF_GLOBAL>> *}
 .
 .      {* The symbol is a debugging record. The value has an arbitary
 .         <<BSF_GLOBAL>> *}
 .
 .      {* The symbol is a debugging record. The value has an arbitary

-.         meaning. *}
+.         meaning, unless BSF_DEBUGGING_RELOC is also set.  *}

 .#define BSF_DEBUGGING 0x08
 .
 .      {* The symbol denotes a function entry point.  Used in ELF,
 .#define BSF_DEBUGGING 0x08
 .
 .      {* The symbol denotes a function entry point.  Used in ELF,


@@ -284,6 +285,11 @@ CODE_FRAGMENT
 .          others someday.  *}
 .#define BSF_OBJECT       0x10000
 .
 .          others someday.  *}
 .#define BSF_OBJECT       0x10000
 .

+.       {* This symbol is a debugging symbol.  The value is the offset
+.          into the section of the data.  BSF_DEBUGGING should be set
+.          as well.  *}
+.#define BSF_DEBUGGING_RELOC 0x20000
+.

 .  flagword flags;
 .
 .      {* A pointer to the section to which this symbol is
 .  flagword flags;
 .
 .      {* A pointer to the section to which this symbol is


@@ -307,6 +313,8 @@ CODE_FRAGMENT
 #include "bfdlink.h"
 #include "aout/stab_gnu.h"
 
 #include "bfdlink.h"
 #include "aout/stab_gnu.h"
 

+static char coff_section_type PARAMS ((const char *));
+

 /*
 DOCDD
 INODE
 /*
 DOCDD
 INODE


@@ -340,8 +348,35 @@ SYNOPSIS
 DESCRIPTION
        Return true if the given symbol @var{sym} in the BFD @var{abfd} is
        a compiler generated local label, else return false.
 DESCRIPTION
        Return true if the given symbol @var{sym} in the BFD @var{abfd} is
        a compiler generated local label, else return false.

-.#define bfd_is_local_label(abfd, sym) \
-.     BFD_SEND (abfd, _bfd_is_local_label,(abfd, sym))
+*/
+
+boolean
+bfd_is_local_label (abfd, sym)
+     bfd *abfd;
+     asymbol *sym;
+{
+  if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
+    return false;
+  if (sym->name == NULL)
+    return false;
+  return bfd_is_local_label_name (abfd, sym->name);
+}
+
+/*
+FUNCTION
+       bfd_is_local_label_name
+
+SYNOPSIS
+        boolean bfd_is_local_label_name(bfd *abfd, const char *name);
+
+DESCRIPTION
+       Return true if a symbol with the name @var{name} in the BFD
+       @var{abfd} is a compiler generated local label, else return
+       false.  This just checks whether the name has the form of a
+       local label.
+
+.#define bfd_is_local_label_name(abfd, name) \
+.     BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))

 */
 
 /*
 */
 
 /*


@@ -483,13 +518,21 @@ static CONST struct section_to_type stt[] =
 {
   {"*DEBUG*", 'N'},
   {".bss", 'b'},
 {
   {"*DEBUG*", 'N'},
   {".bss", 'b'},

+  {"zerovars", 'b'},           /* MRI .bss */

   {".data", 'd'},
   {".data", 'd'},

+  {"vars", 'd'},               /* MRI .data */

   {".rdata", 'r'},             /* Read only data.  */
   {".rodata", 'r'},            /* Read only data.  */
   {".sbss", 's'},              /* Small BSS (uninitialized data).  */
   {".scommon", 'c'},           /* Small common.  */
   {".sdata", 'g'},             /* Small initialized data.  */
   {".text", 't'},
   {".rdata", 'r'},             /* Read only data.  */
   {".rodata", 'r'},            /* Read only data.  */
   {".sbss", 's'},              /* Small BSS (uninitialized data).  */
   {".scommon", 'c'},           /* Small common.  */
   {".sdata", 'g'},             /* Small initialized data.  */
   {".text", 't'},

+  {"code", 't'},               /* MRI .text */
+  {".drectve", 'i'},            /* MSVC's .drective section */
+  {".idata", 'i'},              /* MSVC's .idata (import) section */
+  {".edata", 'e'},              /* MSVC's .edata (export) section */
+  {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
+  {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */

   {0, 0}
 };
 
   {0, 0}
 };
 


@@ -501,7 +544,7 @@ static CONST struct section_to_type stt[] =
 
 static char
 coff_section_type (s)
 
 static char
 coff_section_type (s)

-     char *s;
+     const char *s;

 {
   CONST struct section_to_type *t;
 
 {
   CONST struct section_to_type *t;
 


@@ -539,11 +582,30 @@ bfd_decode_symclass (symbol)
   if (bfd_is_com_section (symbol->section))
     return 'C';
   if (bfd_is_und_section (symbol->section))
   if (bfd_is_com_section (symbol->section))
     return 'C';
   if (bfd_is_und_section (symbol->section))

-    return 'U';
+    {
+      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 (bfd_is_ind_section (symbol->section))
     return 'I';
   if (symbol->flags & BSF_WEAK)

-    return 'W';
+    {
+      /* 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 (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
     return '?';
 


@@ -567,6 +629,26 @@ bfd_decode_symclass (symbol)
      */
 }
 
      */
 }
 

+/*
+FUNCTION
+       bfd_is_undefined_symclass 
+
+DESCRIPTION
+       Returns non-zero if the class symbol returned by
+       bfd_decode_symclass represents an undefined symbol.
+       Returns zero otherwise.
+
+SYNOPSIS
+       boolean bfd_is_undefined_symclass (int symclass);
+*/
+
+boolean
+bfd_is_undefined_symclass (symclass)
+     int symclass;
+{
+  return symclass == 'U' || symclass == 'w' || symclass == 'v';
+}
+

 /*
 FUNCTION
        bfd_symbol_info
 /*
 FUNCTION
        bfd_symbol_info


@@ -586,19 +668,15 @@ bfd_symbol_info (symbol, ret)
      symbol_info *ret;
 {
   ret->type = bfd_decode_symclass (symbol);
      symbol_info *ret;
 {
   ret->type = bfd_decode_symclass (symbol);

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

     ret->value = 0;
     ret->value = 0;

+  else
+    ret->value = symbol->value + symbol->section->vma;
+  

   ret->name = symbol->name;
 }
 
   ret->name = symbol->name;
 }
 

-void
-bfd_symbol_is_absolute ()
-{
-  abort ();
-}
-

 /*
 FUNCTION
        bfd_copy_private_symbol_data
 /*
 FUNCTION
        bfd_copy_private_symbol_data


@@ -616,7 +694,7 @@ DESCRIPTION
        Not enough memory exists to create private data for @var{osec}.
 
 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
        Not enough memory exists to create private data for @var{osec}.
 
 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \

-.     BFD_SEND (ibfd, _bfd_copy_private_symbol_data, \
+.     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \

 .              (ibfd, isymbol, obfd, osymbol))
 
 */
 .              (ibfd, isymbol, obfd, osymbol))
 
 */


@@ -671,10 +749,10 @@ _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
 /*ARGSUSED*/
 asymbol *
 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
 /*ARGSUSED*/
 asymbol *
 _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)

-     bfd *abfd;
-     boolean dynamic;
+     bfd *abfd ATTRIBUTE_UNUSED;
+     boolean dynamic ATTRIBUTE_UNUSED;

      const PTR minisym;
      const PTR minisym;

-     asymbol *sym;
+     asymbol *sym ATTRIBUTE_UNUSED;

 {
   return *(asymbol **) minisym;
 }
 {
   return *(asymbol **) minisym;
 }


@@ -688,6 +766,42 @@ _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
    placed in *pinfo should be saved with the BFD, and passed back each
    time this function is called.  */
 
    placed in *pinfo should be saved with the BFD, and passed back each
    time this function is called.  */
 

+/* We use a cache by default.  */
+
+#define ENABLE_CACHING
+
+/* We keep an array of indexentry structures to record where in the
+   stabs section we should look to find line number information for a
+   particular address.  */
+
+struct indexentry
+{
+  bfd_vma val;
+  bfd_byte *stab;
+  bfd_byte *str;
+  char *directory_name;
+  char *file_name;
+  char *function_name;
+};
+
+/* Compare two indexentry structures.  This is called via qsort.  */
+
+static int
+cmpindexentry (a, b)
+     const PTR *a;
+     const PTR *b;
+{
+  const struct indexentry *contestantA = (const struct indexentry *) a;
+  const struct indexentry *contestantB = (const struct indexentry *) b;
+
+  if (contestantA->val < contestantB->val)
+    return -1;
+  else if (contestantA->val > contestantB->val)
+    return 1;
+  else
+    return 0;
+}
+

 /* A pointer to this structure is stored in *pinfo.  */
 
 struct stab_find_info
 /* A pointer to this structure is stored in *pinfo.  */
 
 struct stab_find_info


@@ -700,13 +814,22 @@ struct stab_find_info
   bfd_byte *stabs;
   /* The contents of the .stabstr section.  */
   bfd_byte *strs;
   bfd_byte *stabs;
   /* The contents of the .stabstr section.  */
   bfd_byte *strs;

-  /* An malloc buffer to hold the file name.  */
-  char *filename;
+
+  /* A table that indexes stabs by memory address.  */
+  struct indexentry *indextable;
+  /* The number of entries in indextable.  */
+  int indextablesize;
+
+#ifdef ENABLE_CACHING

   /* Cached values to restart quickly.  */
   /* Cached values to restart quickly.  */

+  struct indexentry *cached_indexentry;

   bfd_vma cached_offset;
   bfd_byte *cached_stab;
   bfd_vma cached_offset;
   bfd_byte *cached_stab;

-  bfd_byte *cached_str;
-  bfd_size_type cached_stroff;
+  char *cached_file_name;
+#endif
+
+  /* Saved ptr to malloc'ed filename.  */
+  char *filename;

 };
 
 boolean
 };
 
 boolean


@@ -724,18 +847,38 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
 {
   struct stab_find_info *info;
   bfd_size_type stabsize, strsize;
 {
   struct stab_find_info *info;
   bfd_size_type stabsize, strsize;

-  bfd_byte *stab, *stabend, *str;
+  bfd_byte *stab, *str;
+  bfd_byte *last_stab = NULL;

   bfd_size_type stroff;
   bfd_size_type stroff;

-  bfd_vma fnaddr;
-  char *directory_name, *main_file_name, *current_file_name, *line_file_name;
-  char *fnname;
-  bfd_vma low_func_vma, low_line_vma;
+  struct indexentry *indexentry;
+  char *directory_name, *file_name;
+  int saw_fun;

 
   *pfound = false;
   *pfilename = bfd_get_filename (abfd);
   *pfnname = NULL;
   *pline = 0;
 
 
   *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 = (struct stab_find_info *) *pinfo;
   if (info != NULL)
     {
   info = (struct stab_find_info *) *pinfo;
   if (info != NULL)
     {


@@ -752,6 +895,11 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
     {
       long reloc_size, reloc_count;
       arelent **reloc_vector;
     {
       long reloc_size, reloc_count;
       arelent **reloc_vector;

+      int i;
+      char *name;
+      char *file_name;
+      char *directory_name;
+      char *function_name;

 
       info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info);
       if (info == NULL)
 
       info = (struct stab_find_info *) bfd_zalloc (abfd, sizeof *info);
       if (info == NULL)


@@ -768,7 +916,7 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
        {
          /* No stabs debugging information.  Set *pinfo so that we
              can return quickly in the info != NULL case above.  */
        {
          /* No stabs debugging information.  Set *pinfo so that we
              can return quickly in the info != NULL case above.  */

-         *pinfo = info;
+         *pinfo = (PTR) info;

          return true;
        }
 
          return true;
        }
 


@@ -823,7 +971,7 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
                  || r->howto->dst_mask != 0xffffffff)
                {
                  (*_bfd_error_handler)
                  || r->howto->dst_mask != 0xffffffff)
                {
                  (*_bfd_error_handler)

-                   ("Unsupported .stab relocation");
+                   (_("Unsupported .stab relocation"));

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


@@ -841,138 +989,244 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
       if (reloc_vector != NULL)
        free (reloc_vector);
 
       if (reloc_vector != NULL)
        free (reloc_vector);
 

-      *pinfo = info;
-    }
+      /* 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.  */

 
 

-  /* We are passed a section relative offset.  The offsets in the
-     stabs information are absolute.  */
-  offset += bfd_get_section_vma (abfd, section);
+      info->indextablesize = 0;
+      saw_fun = 1;
+      for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
+       {
+         if (stab[TYPEOFF] == N_SO)
+           {
+             /* N_SO with null name indicates EOF */
+             if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
+               continue;

 
 

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

 
 

-     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.  */
+             saw_fun = 0;

 
 

-#define STRDXOFF (0)
-#define TYPEOFF (4)
-#define OTHEROFF (5)
-#define DESCOFF (6)
-#define VALOFF (8)
-#define STABSIZE (12)
-
-  /* It would be nice if we could skip ahead to the stabs symbols for
-     the next compilation unit to quickly scan through the compilation
-     units.  Unfortunately, since each line number gets a separate
-     stabs entry, it is entirely plausible that a large source file
-     will overflow the 16 bit count of stabs entries.  */
-  fnaddr = 0;
-  directory_name = NULL;
-  main_file_name = NULL;
-  current_file_name = NULL;
-  line_file_name = NULL;
-  fnname = NULL;
-  low_func_vma = 0;
-  low_line_vma = 0;
-
-  stabend = info->stabs + stabsize;
-
-  if (info->cached_stab == NULL || offset < info->cached_offset)
-    {
-      stab = info->stabs;
-      str = info->strs;
-      stroff = 0;
-    }
-  else
-    {
-      stab = info->cached_stab;
-      str = info->cached_str;
-      stroff = info->cached_stroff;
-    }
-
-  info->cached_offset = offset;
+             /* two N_SO's in a row is a filename and directory. Skip */
+             if (stab + STABSIZE < info->stabs + stabsize
+                 && *(stab + STABSIZE + TYPEOFF) == N_SO)
+               {
+                 stab += STABSIZE;
+               }
+           }
+         else if (stab[TYPEOFF] == N_FUN)
+           {
+             saw_fun = 1;
+             ++info->indextablesize;
+           }
+       }

 
 

-  for (; stab < stabend; stab += STABSIZE)
-    {
-      boolean done;
-      bfd_vma val;
-      char *name;
+      if (saw_fun == 0)
+       ++info->indextablesize;
+      
+      if (info->indextablesize == 0)
+       return true;
+      ++info->indextablesize;
+
+      info->indextable = ((struct indexentry *)
+                         bfd_alloc (abfd,
+                                    (sizeof (struct indexentry)
+                                     * info->indextablesize)));
+      if (info->indextable == NULL)
+       return false;

 
 

-      done = false;
+      file_name = NULL;
+      directory_name = NULL;
+      saw_fun = 1;

 
 

-      switch (stab[TYPEOFF])
+      for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
+          i < info->indextablesize && stab < info->stabs + stabsize;
+          stab += STABSIZE)

        {
        {

-       case 0:
-         /* This is the first entry in a compilation unit.  */
-         if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
+         switch (stab[TYPEOFF])

            {
            {

-             done = true;
+           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;
              break;

-           }
-         str += stroff;
-         stroff = bfd_get_32 (abfd, stab + VALOFF);
-         break;

 
 

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

 
 

-         val = bfd_get_32 (abfd, stab + VALOFF);
-         if (val > offset)
-           {
-             done = true;
+             /* 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) != 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;
              break;

-           }

 
 

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

 
 

-         /* An empty string indicates the end of the compilation
-             unit.  */
-         if (*name == '\0')
-           {
-             /* If there are functions in different sections, they
-                 may have addresses larger than val, but we don't want
-                 to forget the file name.  When there are functions in
-                 different cases, there is supposed to be an N_FUN at
-                 the end of the function indicating where it ends.  */
-             if (low_func_vma < val || fnname == NULL)
-               main_file_name = NULL;
+           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;
            }
              break;
            }

+       }

 
 

-         /* We know that we have to get to at least this point in the
-             stabs entries for this offset.  */
-         info->cached_stab = stab;
-         info->cached_str = str;
-         info->cached_stroff = stroff;
+      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;
+       }

 
 

-         current_file_name = name;
+      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;

 
 

-         /* Look ahead to the next symbol.  Two consecutive N_SO
-             symbols are a directory and a file name.  */
-         if (stab + STABSIZE >= stabend
-             || *(stab + STABSIZE + TYPEOFF) != N_SO)
-           directory_name = NULL;
-         else
+      info->indextablesize = i;
+      qsort (info->indextable, i, sizeof (struct indexentry), cmpindexentry);
+
+      *pinfo = (PTR) 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
+    {
+      /* Cache non-existant or invalid.  Do binary search on
+         indextable.  */
+
+      long low, high;
+      long mid = -1;
+
+      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)

            {
            {

-             stab += STABSIZE;
-             directory_name = current_file_name;
-             current_file_name = str + bfd_get_32 (abfd, stab + STRDXOFF);
+             indexentry = &info->indextable[mid];
+             break;

            }
 
            }
 

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

 
 

-         break;
+      if (indexentry == NULL)
+       return true;

 
 

+      stab = indexentry->stab + STABSIZE;
+      file_name = indexentry->file_name;
+    }
+
+  directory_name = indexentry->directory_name;
+  str = indexentry->str;
+
+  for (; stab < (indexentry+1)->stab; stab += STABSIZE)
+    {
+      boolean done;
+      bfd_vma val;
+
+      done = false;
+
+      switch (stab[TYPEOFF])
+       {

        case N_SOL:
          /* The name of an include file.  */
        case N_SOL:
          /* The name of an include file.  */

-         current_file_name = str + bfd_get_32 (abfd, stab + STRDXOFF);
+         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:
          break;
 
        case N_SLINE:


@@ -980,40 +1234,25 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
        case N_BSLINE:
          /* A line number.  The value is relative to the start of the
              current function.  */
        case N_BSLINE:
          /* A line number.  The value is relative to the start of the
              current function.  */

-         val = fnaddr + bfd_get_32 (abfd, stab + VALOFF);
-         if (val >= low_line_vma && val <= offset)
+         val = indexentry->val + bfd_get_32 (abfd, stab + VALOFF);
+         if (val <= offset)

            {
              *pline = bfd_get_16 (abfd, stab + DESCOFF);
            {
              *pline = bfd_get_16 (abfd, stab + DESCOFF);

-             low_line_vma = val;
-             line_file_name = current_file_name;
+
+#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;

          break;
 
        case N_FUN:
          break;
 
        case N_FUN:

-         /* A function name.  */
-         val = bfd_get_32 (abfd, stab + VALOFF);
-         name = str + bfd_get_32 (abfd, stab + STRDXOFF);
-
-         /* An empty string here indicates the end of a function, and
-            the value is relative to fnaddr.  */
-
-         if (*name == '\0')
-           {
-             val += fnaddr;
-             if (val >= low_func_vma && val < offset)
-               fnname = NULL;
-           }
-         else
-           {
-             if (val >= low_func_vma && val <= offset)
-               {
-                 fnname = name;
-                 low_func_vma = val;
-               }
-
-              fnaddr = val;
-            }
-
+       case N_SO:
+         done = true;

          break;
        }
 
          break;
        }
 


@@ -1021,46 +1260,34 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
        break;
     }
 
        break;
     }
 

-  if (main_file_name == NULL)
-    {
-      /* No information found.  */
-      return true;
-    }
-

   *pfound = true;
 
   *pfound = true;
 

-  if (*pline != 0)
-    main_file_name = line_file_name;
-
-  if (main_file_name != NULL)
+  if (file_name[0] == '/' || directory_name == NULL)
+    *pfilename = file_name;
+  else

     {
     {

-      if (main_file_name[0] == '/' || directory_name == NULL)
-       *pfilename = main_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, main_file_name) != 0)
-           {
-             if (info->filename != NULL)
-               free (info->filename);
-             info->filename = (char *) bfd_malloc (dirlen +
-                                                   strlen (main_file_name)
-                                                   + 1);
-             if (info->filename == NULL)
-               return false;
-             strcpy (info->filename, directory_name);
-             strcpy (info->filename + dirlen, main_file_name);
-           }
+      size_t dirlen;

 
 

-         *pfilename = info->filename;
+      dirlen = strlen (directory_name);
+      if (info->filename == NULL
+         || strncmp (info->filename, directory_name, dirlen) != 0
+         || strcmp (info->filename + dirlen, file_name) != 0)
+       {
+         if (info->filename != NULL)
+           free (info->filename);
+         info->filename = (char *) bfd_malloc (dirlen +
+                                               strlen (file_name)
+                                               + 1);
+         if (info->filename == NULL)
+           return false;
+         strcpy (info->filename, directory_name);
+         strcpy (info->filename + dirlen, file_name);

        }
        }

+
+      *pfilename = info->filename;

     }
 
     }
 

-  if (fnname != NULL)
+  if (indexentry->function_name != NULL)

     {
       char *s;
 
     {
       char *s;
 


@@ -1068,11 +1295,11 @@ _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
          to clobber the colon.  It's OK to change the name, since the
          string is in our own local storage anyhow.  */
 
          to clobber the colon.  It's OK to change the name, since the
          string is in our own local storage anyhow.  */
 

-      s = strchr (fnname, ':');
+      s = strchr (indexentry->function_name, ':');

       if (s != NULL)
        *s = '\0';
 
       if (s != NULL)
        *s = '\0';
 

-      *pfnname = fnname;
+      *pfnname = indexentry->function_name;

     }
 
   return true;
     }
 
   return true;