projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
daily update
[deliverable/binutils-gdb.git] / gdb / symtab.c
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 3a4286720e1cf42508149700c08d712813372095..1a123fb4684ae0cdff18651cd6fcc1e86e892771 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1,8 +1,8 @@
 /* Symbol table lookup for the GNU debugger, GDB.
 
    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
 /* Symbol table lookup for the GNU debugger, GDB.
 
    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
-   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
-   Foundation, Inc.
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+   Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -38,9 +38,13 @@
 #include "demangle.h"
 #include "inferior.h"
 #include "linespec.h"
 #include "demangle.h"
 #include "inferior.h"
 #include "linespec.h"
+#include "source.h"
 #include "filenames.h"         /* for FILENAME_CMP */
 
 #include "filenames.h"         /* for FILENAME_CMP */
 
-#include "obstack.h"
+#include "hashtab.h"
+
+#include "gdb_obstack.h"
+#include "block.h"
 
 #include <sys/types.h>
 #include <fcntl.h>
 
 #include <sys/types.h>
 #include <fcntl.h>
@@ -49,11 +53,6 @@
 #include <ctype.h>
 #include "cp-abi.h"
 
 #include <ctype.h>
 #include "cp-abi.h"
 
-/* Prototype for one function in parser-defs.h,
-   instead of including that entire file. */
-
-extern char *find_template_name_end (char *);
-
 /* Prototypes for local functions */
 
 static void completion_list_add_name (char *, char *, int, char *, char *);
 /* Prototypes for local functions */
 
 static void completion_list_add_name (char *, char *, int, char *, char *);
@@ -87,6 +86,41 @@ static struct symbol *lookup_symbol_aux (const char *name,
                                         int *is_a_field_of_this,
                                         struct symtab **symtab);
 
                                         int *is_a_field_of_this,
                                         struct symtab **symtab);
 
+static
+struct symbol *lookup_symbol_aux_local (const char *name,
+                                       const char *mangled_name,
+                                       const struct block *block,
+                                       const namespace_enum namespace,
+                                       struct symtab **symtab,
+                                       const struct block **static_block);
+
+static
+struct symbol *lookup_symbol_aux_block (const char *name,
+                                       const char *mangled_name,
+                                       const struct block *block,
+                                       const namespace_enum namespace,
+                                       struct symtab **symtab);
+
+static
+struct symbol *lookup_symbol_aux_symtabs (int block_index,
+                                         const char *name,
+                                         const char *mangled_name,
+                                         const namespace_enum namespace,
+                                         struct symtab **symtab);
+
+static
+struct symbol *lookup_symbol_aux_psymtabs (int block_index,
+                                          const char *name,
+                                          const char *mangled_name,
+                                          const namespace_enum namespace,
+                                          struct symtab **symtab);
+
+static
+struct symbol *lookup_symbol_aux_minsyms (const char *name,
+                                         const char *mangled_name,
+                                         const namespace_enum namespace,
+                                         int *is_a_field_of_this,
+                                         struct symtab **symtab);
 
 static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr);
 
 
 static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr);
 
@@ -120,19 +154,6 @@ struct type *builtin_type_error;
 
 const struct block *block_found;
 
 
 const struct block *block_found;
 
-/* While the C++ support is still in flux, issue a possibly helpful hint on
-   using the new command completion feature on single quoted demangled C++
-   symbols.  Remove when loose ends are cleaned up.   FIXME -fnf */
-
-static void
-cplusplus_hint (char *name)
-{
-  while (*name == '\'')
-    name++;
-  printf_filtered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
-  printf_filtered ("(Note leading single quote.)\n");
-}
-
 /* Check for a symtab of a specific name; first in symtabs, then in
    psymtabs.  *If* there is no '/' in the name, a match after a '/'
    in the symtab filename will also work.  */
 /* Check for a symtab of a specific name; first in symtabs, then in
    psymtabs.  *If* there is no '/' in the name, a match after a '/'
    in the symtab filename will also work.  */
@@ -384,22 +405,55 @@ gdb_mangle_name (struct type *type, int method_id, int signature_id)
 }
 
 \f
 }
 
 \f
-/* Initialize a symbol's mangled name.  */
+/* Initialize the language dependent portion of a symbol
+   depending upon the language for the symbol. */
+void
+symbol_init_language_specific (struct general_symbol_info *gsymbol,
+                              enum language language)
+{
+  gsymbol->language = language;
+  if (gsymbol->language == language_cplus
+      || gsymbol->language == language_java
+      || gsymbol->language == language_objc)
+    {
+      gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+    }
+  else
+    {
+      memset (&gsymbol->language_specific, 0,
+             sizeof (gsymbol->language_specific));
+    }
+}
+
+/* Functions to initialize a symbol's mangled name.  */
+
+/* Create the hash table used for demangled names.  Each hash entry is
+   a pair of strings; one for the mangled name and one for the demangled
+   name.  The entry is hashed via just the mangled name.  */
+
+static void
+create_demangled_names_hash (struct objfile *objfile)
+{
+  /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
+     The hash table code will round this up to the next prime number. 
+     Choosing a much larger table size wastes memory, and saves only about
+     1% in symbol reading.  */
+
+  objfile->demangled_names_hash = htab_create_alloc_ex
+    (256, htab_hash_string, (int (*) (const void *, const void *)) streq,
+     NULL, objfile->md, xmcalloc, xmfree);
+}
 
 
-/* Try to initialize the demangled name for a symbol, based on the
+/* Try to determine the demangled name for a symbol, based on the
    language of that symbol.  If the language is set to language_auto,
    it will attempt to find any demangling algorithm that works and
    language of that symbol.  If the language is set to language_auto,
    it will attempt to find any demangling algorithm that works and
-   then set the language appropriately.  If no demangling of any kind
-   is found, the language is set back to language_unknown, so we can
-   avoid doing this work again the next time we encounter the symbol.
-   Any required space to store the name is obtained from the specified
-   obstack. */
+   then set the language appropriately.  The returned name is allocated
+   by the demangler and should be xfree'd.  */
 
 
-void
-symbol_init_demangled_name (struct general_symbol_info *gsymbol,
-                            struct obstack *obstack)
+static char *
+symbol_find_demangled_name (struct general_symbol_info *gsymbol,
+                           const char *mangled)
 {
 {
-  char *mangled = gsymbol->name;
   char *demangled = NULL;
 
   if (gsymbol->language == language_unknown)
   char *demangled = NULL;
 
   if (gsymbol->language == language_unknown)
@@ -408,57 +462,143 @@ symbol_init_demangled_name (struct general_symbol_info *gsymbol,
       || gsymbol->language == language_auto)
     {
       demangled =
       || gsymbol->language == language_auto)
     {
       demangled =
-        cplus_demangle (gsymbol->name, DMGL_PARAMS | DMGL_ANSI);
+        cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
       if (demangled != NULL)
       if (demangled != NULL)
-        {
-          gsymbol->language = language_cplus;
-          gsymbol->language_specific.cplus_specific.demangled_name =
-            obsavestring (demangled, strlen (demangled), obstack);
-          xfree (demangled);
-        }
-      else
-        {
-          gsymbol->language_specific.cplus_specific.demangled_name = NULL;
-        }
+       {
+         gsymbol->language = language_cplus;
+         return demangled;
+       }
     }
   if (gsymbol->language == language_java)
     {
       demangled =
     }
   if (gsymbol->language == language_java)
     {
       demangled =
-        cplus_demangle (gsymbol->name,
+        cplus_demangle (mangled,
                         DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
       if (demangled != NULL)
                         DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
       if (demangled != NULL)
-        {
-          gsymbol->language = language_java;
-          gsymbol->language_specific.cplus_specific.demangled_name =
-            obsavestring (demangled, strlen (demangled), obstack);
-          xfree (demangled);
-        }
+       {
+         gsymbol->language = language_java;
+         return demangled;
+       }
+    }
+  return NULL;
+}
+
+/* Set both the mangled and demangled (if any) names for GSYMBOL based on
+   NAME and LEN.  The hash table corresponding to OBJFILE is used, and the
+   memory comes from that objfile's symbol_obstack.  NAME is copied, so the
+   pointer can be discarded after calling this function.  */
+
+void
+symbol_set_names (struct general_symbol_info *gsymbol,
+                 const char *name, int len, struct objfile *objfile)
+{
+  char **slot;
+  const char *tmpname;
+
+  if (objfile->demangled_names_hash == NULL)
+    create_demangled_names_hash (objfile);
+
+  /* The stabs reader generally provides names that are not NULL-terminated;
+     most of the other readers don't do this, so we can just use the given
+     copy.  */
+  if (name[len] != 0)
+    {
+      char *alloc_name = alloca (len + 1);
+      memcpy (alloc_name, name, len);
+      alloc_name[len] = 0;
+      tmpname = alloc_name;
+    }
+  else
+    tmpname = name;
+
+  slot = (char **) htab_find_slot (objfile->demangled_names_hash, tmpname, INSERT);
+
+  /* If this name is not in the hash table, add it.  */
+  if (*slot == NULL)
+    {
+      char *demangled_name = symbol_find_demangled_name (gsymbol, tmpname);
+      int demangled_len = demangled_name ? strlen (demangled_name) : 0;
+
+      /* If there is a demangled name, place it right after the mangled name.
+        Otherwise, just place a second zero byte after the end of the mangled
+        name.  */
+      *slot = obstack_alloc (&objfile->symbol_obstack,
+                            len + demangled_len + 2);
+      memcpy (*slot, tmpname, len + 1);
+      if (demangled_name)
+       {
+         memcpy (*slot + len + 1, demangled_name, demangled_len + 1);
+         xfree (demangled_name);
+       }
       else
       else
-        {
-          gsymbol->language_specific.cplus_specific.demangled_name = NULL;
-        }
+       (*slot)[len + 1] = 0;
     }
     }
-  if (demangled == NULL
-      && (gsymbol->language == language_chill
-          || gsymbol->language == language_auto))
+
+  gsymbol->name = *slot;
+  if ((*slot)[len + 1])
+    gsymbol->language_specific.cplus_specific.demangled_name
+      = &(*slot)[len + 1];
+  else
+    gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+}
+
+/* Initialize the demangled name of GSYMBOL if possible.  Any required space
+   to store the name is obtained from the specified obstack.  The function
+   symbol_set_names, above, should be used instead where possible for more
+   efficient memory usage.  */
+
+void
+symbol_init_demangled_name (struct general_symbol_info *gsymbol,
+                            struct obstack *obstack)
+{
+  char *mangled = gsymbol->name;
+  char *demangled = NULL;
+
+  demangled = symbol_find_demangled_name (gsymbol, mangled);
+  if (gsymbol->language == language_cplus
+      || gsymbol->language == language_java)
     {
     {
-      demangled =
-        chill_demangle (gsymbol->name);
-      if (demangled != NULL)
-        {
-          gsymbol->language = language_chill;
-          gsymbol->language_specific.chill_specific.demangled_name =
-            obsavestring (demangled, strlen (demangled), obstack);
-          xfree (demangled);
-        }
+      if (demangled)
+       {
+         gsymbol->language_specific.cplus_specific.demangled_name
+           = obsavestring (demangled, strlen (demangled), obstack);
+         xfree (demangled);
+       }
       else
       else
-        {
-          gsymbol->language_specific.chill_specific.demangled_name = NULL;
-        }
+       gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+    }
+  else
+    {
+      /* Unknown language; just clean up quietly.  */
+      if (demangled)
+       xfree (demangled);
     }
 }
 
     }
 }
 
+/* Return the demangled name for a symbol based on the language for
+   that symbol.  If no demangled name exists, return NULL. */
+char *
+symbol_demangled_name (struct general_symbol_info *gsymbol)
+{
+  if (gsymbol->language == language_cplus
+      || gsymbol->language == language_java
+      || gsymbol->language == language_objc)
+    return gsymbol->language_specific.cplus_specific.demangled_name;
+
+  else 
+    return NULL;
+}
 
 
+/* Initialize the structure fields to zero values.  */
+void
+init_sal (struct symtab_and_line *sal)
+{
+  sal->symtab = 0;
+  sal->section = 0;
+  sal->line = 0;
+  sal->pc = 0;
+  sal->end = 0;
+}
 \f
 
 
 \f
 
 
@@ -668,23 +808,38 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
    attractive to put in some QUIT's (though I'm not really sure
    whether it can run long enough to be really important).  But there
    are a few calls for which it would appear to be bad news to quit
    attractive to put in some QUIT's (though I'm not really sure
    whether it can run long enough to be really important).  But there
    are a few calls for which it would appear to be bad news to quit
-   out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c, and
-   nindy_frame_chain_valid in nindy-tdep.c.  (Note that there is C++
-   code below which can error(), but that probably doesn't affect
-   these calls since they are looking for a known variable and thus
-   can probably assume it will never hit the C++ code).  */
+   out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c.  (Note
+   that there is C++ code below which can error(), but that probably
+   doesn't affect these calls since they are looking for a known
+   variable and thus can probably assume it will never hit the C++
+   code).  */
 
 struct symbol *
 lookup_symbol (const char *name, const struct block *block,
               const namespace_enum namespace, int *is_a_field_of_this,
               struct symtab **symtab)
 {
 
 struct symbol *
 lookup_symbol (const char *name, const struct block *block,
               const namespace_enum namespace, int *is_a_field_of_this,
               struct symtab **symtab)
 {
-  char *modified_name = NULL;
-  char *modified_name2 = NULL;
+  char *demangled_name = NULL;
+  const char *modified_name = NULL;
   const char *mangled_name = NULL;
   int needtofreename = 0;
   struct symbol *returnval;
 
   const char *mangled_name = NULL;
   int needtofreename = 0;
   struct symbol *returnval;
 
+  modified_name = name;
+
+  /* If we are using C++ language, demangle the name before doing a lookup, so
+     we can always binary search. */
+  if (current_language->la_language == language_cplus)
+    {
+      demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
+      if (demangled_name)
+       {
+         mangled_name = name;
+         modified_name = demangled_name;
+         needtofreename = 1;
+       }
+    }
+
   if (case_sensitivity == case_sensitive_off)
     {
       char *copy;
   if (case_sensitivity == case_sensitive_off)
     {
       char *copy;
@@ -697,26 +852,11 @@ lookup_symbol (const char *name, const struct block *block,
       copy[len] = 0;
       modified_name = copy;
     }
       copy[len] = 0;
       modified_name = copy;
     }
-  else 
-      modified_name = (char *) name;
-
-  /* If we are using C++ language, demangle the name before doing a lookup, so
-     we can always binary search. */
-  if (current_language->la_language == language_cplus)
-    {
-      modified_name2 = cplus_demangle (modified_name, DMGL_ANSI | DMGL_PARAMS);
-      if (modified_name2)
-       {
-         mangled_name = name;
-         modified_name = modified_name2;
-         needtofreename = 1;
-       }
-    }
 
   returnval = lookup_symbol_aux (modified_name, mangled_name, block,
                                 namespace, is_a_field_of_this, symtab);
   if (needtofreename)
 
   returnval = lookup_symbol_aux (modified_name, mangled_name, block,
                                 namespace, is_a_field_of_this, symtab);
   if (needtofreename)
-    xfree (modified_name2);
+    xfree (demangled_name);
 
   return returnval;     
 }
 
   return returnval;     
 }
@@ -726,43 +866,21 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
                   const struct block *block, const namespace_enum namespace,
                   int *is_a_field_of_this, struct symtab **symtab)
 {
                   const struct block *block, const namespace_enum namespace,
                   int *is_a_field_of_this, struct symtab **symtab)
 {
-  register struct symbol *sym;
-  register struct symtab *s = NULL;
-  register struct partial_symtab *ps;
-  register struct blockvector *bv;
-  register struct objfile *objfile = NULL;
-  register struct block *b;
-  register struct minimal_symbol *msymbol;
+  struct symbol *sym;
+  const struct block *static_block;
 
 
+  /* Search specified block and its superiors.  Don't search
+     STATIC_BLOCK or GLOBAL_BLOCK.  */
 
 
-  /* Search specified block and its superiors.  */
-
-  while (block != 0)
-    {
-      sym = lookup_block_symbol (block, name, mangled_name, namespace);
-      if (sym)
-       {
-         block_found = block;
-         if (symtab != NULL)
-           {
-             /* Search the list of symtabs for one which contains the
-                address of the start of this block.  */
-             ALL_SYMTABS (objfile, s)
-             {
-               bv = BLOCKVECTOR (s);
-               b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-               if (BLOCK_START (b) <= BLOCK_START (block)
-                   && BLOCK_END (b) > BLOCK_START (block))
-                 goto found;
-             }
-           found:
-             *symtab = s;
-           }
+  sym = lookup_symbol_aux_local (name, mangled_name, block, namespace,
+                                symtab, &static_block);
+  if (sym != NULL)
+    return sym;
 
 
-         return fixup_symbol_section (sym, objfile);
-       }
-      block = BLOCK_SUPERBLOCK (block);
-    }
+#if 0
+  /* NOTE: carlton/2002-11-05: At the time that this code was
+     #ifdeffed out, the value of 'block' was always NULL at this
+     point, hence the bemused comments below.  */
 
   /* FIXME: this code is never executed--block is always NULL at this
      point.  What is it trying to do, anyway?  We already should have
 
   /* FIXME: this code is never executed--block is always NULL at this
      point.  What is it trying to do, anyway?  We already should have
@@ -803,7 +921,7 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
          }
       }
     }
          }
       }
     }
-
+#endif /* 0 */
 
   /* C++: If requested to do so by the caller, 
      check to see if NAME is a field of `this'. */
 
   /* C++: If requested to do so by the caller, 
      check to see if NAME is a field of `this'. */
@@ -821,24 +939,47 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
        }
     }
 
        }
     }
 
+  /* If there's a static block to search, search it next.  */
+
+  /* NOTE: carlton/2002-12-05: There is a question as to whether or
+     not it would be appropriate to search the current global block
+     here as well.  (That's what this code used to do before the
+     is_a_field_of_this check was moved up.)  On the one hand, it's
+     redundant with the lookup_symbol_aux_symtabs search that happens
+     next.  On the other hand, if decode_line_1 is passed an argument
+     like filename:var, then the user presumably wants 'var' to be
+     searched for in filename.  On the third hand, there shouldn't be
+     multiple global variables all of which are named 'var', and it's
+     not like decode_line_1 has ever restricted its search to only
+     global variables in a single filename.  All in all, only
+     searching the static block here seems best: it's correct and it's
+     cleanest.  */
+
+  /* NOTE: carlton/2002-12-05: There's also a possible performance
+     issue here: if you usually search for global symbols in the
+     current file, then it would be slightly better to search the
+     current global block before searching all the symtabs.  But there
+     are other factors that have a much greater effect on performance
+     than that one, so I don't think we should worry about that for
+     now.  */
+
+  if (static_block != NULL)
+    {
+      sym = lookup_symbol_aux_block (name, mangled_name, static_block,
+                                    namespace, symtab);
+      if (sym != NULL)
+       return sym;
+    }
+
   /* Now search all global blocks.  Do the symtab's first, then
      check the psymtab's. If a psymtab indicates the existence
      of the desired name as a global, then do psymtab-to-symtab
      conversion on the fly and return the found symbol. */
 
   /* Now search all global blocks.  Do the symtab's first, then
      check the psymtab's. If a psymtab indicates the existence
      of the desired name as a global, then do psymtab-to-symtab
      conversion on the fly and return the found symbol. */
 
-  ALL_SYMTABS (objfile, s)
-  {
-    bv = BLOCKVECTOR (s);
-    block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-    sym = lookup_block_symbol (block, name, mangled_name, namespace);
-    if (sym)
-      {
-       block_found = block;
-       if (symtab != NULL)
-         *symtab = s;
-       return fixup_symbol_section (sym, objfile);
-      }
-  }
+  sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, mangled_name,
+                                  namespace, symtab);
+  if (sym != NULL)
+    return sym;
 
 #ifndef HPUXHPPA
 
 
 #ifndef HPUXHPPA
 
@@ -846,103 +987,166 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
      a mangled variable that is stored in one of the minimal symbol tables.
      Eventually, all global symbols might be resolved in this way.  */
 
      a mangled variable that is stored in one of the minimal symbol tables.
      Eventually, all global symbols might be resolved in this way.  */
 
-  if (namespace == VAR_NAMESPACE)
+  sym = lookup_symbol_aux_minsyms (name, mangled_name,
+                                  namespace, is_a_field_of_this,
+                                  symtab);
+  
+  if (sym != NULL)
+    return sym;
+
+#endif
+
+  sym = lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, mangled_name,
+                                   namespace, symtab);
+  if (sym != NULL)
+    return sym;
+
+  /* Now search all static file-level symbols.  Not strictly correct,
+     but more useful than an error.  Do the symtabs first, then check
+     the psymtabs.  If a psymtab indicates the existence of the
+     desired name as a file-level static, then do psymtab-to-symtab
+     conversion on the fly and return the found symbol. */
+
+  sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, mangled_name,
+                                  namespace, symtab);
+  if (sym != NULL)
+    return sym;
+  
+  sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, mangled_name,
+                                   namespace, symtab);
+  if (sym != NULL)
+    return sym;
+
+#ifdef HPUXHPPA
+
+  /* Check for the possibility of the symbol being a function or
+     a global variable that is stored in one of the minimal symbol tables.
+     The "minimal symbol table" is built from linker-supplied info.
+
+     RT: I moved this check to last, after the complete search of
+     the global (p)symtab's and static (p)symtab's. For HP-generated
+     symbol tables, this check was causing a premature exit from
+     lookup_symbol with NULL return, and thus messing up symbol lookups
+     of things like "c::f". It seems to me a check of the minimal
+     symbol table ought to be a last resort in any case. I'm vaguely
+     worried about the comment below which talks about FORTRAN routines "foo_"
+     though... is it saying we need to do the "minsym" check before
+     the static check in this case? 
+   */
+
+
+  sym = lookup_symbol_aux_minsyms (name, mangled_name,
+                                  namespace, is_a_field_of_this,
+                                  symtab);
+  
+  if (sym != NULL)
+    return sym;
+
+#endif
+
+  if (symtab != NULL)
+    *symtab = NULL;
+  return NULL;
+}
+
+/* Check to see if the symbol is defined in BLOCK or its superiors.
+   Don't search STATIC_BLOCK or GLOBAL_BLOCK.  If we don't find a
+   match, store the address of STATIC_BLOCK in static_block.  */
+
+static struct symbol *
+lookup_symbol_aux_local (const char *name, const char *mangled_name,
+                        const struct block *block,
+                        const namespace_enum namespace,
+                        struct symtab **symtab,
+                        const struct block **static_block)
+{
+  struct symbol *sym;
+  
+  /* Check if either no block is specified or it's a global block.  */
+
+  if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
     {
     {
-      msymbol = lookup_minimal_symbol (name, NULL, NULL);
-      if (msymbol != NULL)
-       {
-         s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
-                                  SYMBOL_BFD_SECTION (msymbol));
-         if (s != NULL)
-           {
-             /* This is a function which has a symtab for its address.  */
-             bv = BLOCKVECTOR (s);
-             block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-             sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
-                                        mangled_name, namespace);
-             /* We kept static functions in minimal symbol table as well as
-                in static scope. We want to find them in the symbol table. */
-             if (!sym)
-               {
-                 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-                 sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
-                                            mangled_name, namespace);
-               }
+      *static_block = NULL;
+      return NULL;
+    }
 
 
-             /* sym == 0 if symbol was found in the minimal symbol table
-                but not in the symtab.
-                Return 0 to use the msymbol definition of "foo_".
+  while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
+    {
+      sym = lookup_symbol_aux_block (name, mangled_name, block, namespace,
+                                    symtab);
+      if (sym != NULL)
+       return sym;
+      block = BLOCK_SUPERBLOCK (block);
+    }
 
 
-                This happens for Fortran  "foo_" symbols,
-                which are "foo" in the symtab.
+  /* We've reached the static block.  */
 
 
-                This can also happen if "asm" is used to make a
-                regular symbol but not a debugging symbol, e.g.
-                asm(".globl _main");
-                asm("_main:");
-              */
+  *static_block = block;
+  return NULL;
+}
 
 
-             if (symtab != NULL)
-               *symtab = s;
-             return fixup_symbol_section (sym, objfile);
-           }
-         else if (MSYMBOL_TYPE (msymbol) != mst_text
-                  && MSYMBOL_TYPE (msymbol) != mst_file_text
-                  && !STREQ (name, SYMBOL_NAME (msymbol)))
+/* Look up a symbol in a block; if found, locate its symtab, fixup the
+   symbol, and set block_found appropriately.  */
+
+static struct symbol *
+lookup_symbol_aux_block (const char *name, const char *mangled_name,
+                        const struct block *block,
+                        const namespace_enum namespace,
+                        struct symtab **symtab)
+{
+  struct symbol *sym;
+  struct objfile *objfile = NULL;
+  struct blockvector *bv;
+  struct block *b;
+  struct symtab *s = NULL;
+
+  sym = lookup_block_symbol (block, name, mangled_name, namespace);
+  if (sym)
+    {
+      block_found = block;
+      if (symtab != NULL)
+       {
+         /* Search the list of symtabs for one which contains the
+            address of the start of this block.  */
+         ALL_SYMTABS (objfile, s)
            {
            {
-             /* This is a mangled variable, look it up by its
-                mangled name.  */
-             return lookup_symbol_aux (SYMBOL_NAME (msymbol), mangled_name, block,
-                                       namespace, is_a_field_of_this, symtab);
+             bv = BLOCKVECTOR (s);
+             b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+             if (BLOCK_START (b) <= BLOCK_START (block)
+                 && BLOCK_END (b) > BLOCK_START (block))
+               goto found;
            }
            }
-         /* There are no debug symbols for this file, or we are looking
-            for an unmangled variable.
-            Try to find a matching static symbol below. */
+       found:
+         *symtab = s;
        }
        }
+      
+      return fixup_symbol_section (sym, objfile);
     }
 
     }
 
-#endif
+  return NULL;
+}
 
 
-  ALL_PSYMTABS (objfile, ps)
-  {
-    if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
-      {
-       s = PSYMTAB_TO_SYMTAB (ps);
-       bv = BLOCKVECTOR (s);
-       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-       sym = lookup_block_symbol (block, name, mangled_name, namespace);
-       if (!sym)
-         {
-           /* This shouldn't be necessary, but as a last resort
-            * try looking in the statics even though the psymtab
-            * claimed the symbol was global. It's possible that
-            * the psymtab gets it wrong in some cases.
-            */
-           block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-           sym = lookup_block_symbol (block, name, mangled_name, namespace);
-           if (!sym)
-             error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
-%s may be an inlined function, or may be a template function\n\
-(if a template, try specifying an instantiation: %s<type>).",
-                    name, ps->filename, name, name);
-         }
-       if (symtab != NULL)
-         *symtab = s;
-       return fixup_symbol_section (sym, objfile);
-      }
-  }
+/* Check to see if the symbol is defined in one of the symtabs.
+   BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
+   depending on whether or not we want to search global symbols or
+   static symbols.  */
 
 
-  /* Now search all static file-level symbols.
-     Not strictly correct, but more useful than an error.
-     Do the symtabs first, then check the psymtabs.
-     If a psymtab indicates the existence
-     of the desired name as a file-level static, then do psymtab-to-symtab
-     conversion on the fly and return the found symbol. */
+static struct symbol *
+lookup_symbol_aux_symtabs (int block_index,
+                          const char *name, const char *mangled_name,
+                          const namespace_enum namespace,
+                          struct symtab **symtab)
+{
+  struct symbol *sym;
+  struct objfile *objfile;
+  struct blockvector *bv;
+  const struct block *block;
+  struct symtab *s;
 
   ALL_SYMTABS (objfile, s)
   {
     bv = BLOCKVECTOR (s);
 
   ALL_SYMTABS (objfile, s)
   {
     bv = BLOCKVECTOR (s);
-    block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+    block = BLOCKVECTOR_BLOCK (bv, block_index);
     sym = lookup_block_symbol (block, name, mangled_name, namespace);
     if (sym)
       {
     sym = lookup_block_symbol (block, name, mangled_name, namespace);
     if (sym)
       {
@@ -953,27 +1157,57 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
       }
   }
 
       }
   }
 
+  return NULL;
+}
+
+/* Check to see if the symbol is defined in one of the partial
+   symtabs.  BLOCK_INDEX should be either GLOBAL_BLOCK or
+   STATIC_BLOCK, depending on whether or not we want to search global
+   symbols or static symbols.  */
+
+static struct symbol *
+lookup_symbol_aux_psymtabs (int block_index, const char *name,
+                           const char *mangled_name,
+                           const namespace_enum namespace,
+                           struct symtab **symtab)
+{
+  struct symbol *sym;
+  struct objfile *objfile;
+  struct blockvector *bv;
+  const struct block *block;
+  struct partial_symtab *ps;
+  struct symtab *s;
+  const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
+
   ALL_PSYMTABS (objfile, ps)
   {
   ALL_PSYMTABS (objfile, ps)
   {
-    if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
+    if (!ps->readin
+       && lookup_partial_symbol (ps, name, psymtab_index, namespace))
       {
        s = PSYMTAB_TO_SYMTAB (ps);
        bv = BLOCKVECTOR (s);
       {
        s = PSYMTAB_TO_SYMTAB (ps);
        bv = BLOCKVECTOR (s);
-       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+       block = BLOCKVECTOR_BLOCK (bv, block_index);
        sym = lookup_block_symbol (block, name, mangled_name, namespace);
        if (!sym)
          {
        sym = lookup_block_symbol (block, name, mangled_name, namespace);
        if (!sym)
          {
-           /* This shouldn't be necessary, but as a last resort
-            * try looking in the globals even though the psymtab
-            * claimed the symbol was static. It's possible that
-            * the psymtab gets it wrong in some cases.
-            */
-           block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+           /* This shouldn't be necessary, but as a last resort try
+              looking in the statics even though the psymtab claimed
+              the symbol was global, or vice-versa. It's possible
+              that the psymtab gets it wrong in some cases.  */
+
+           /* FIXME: carlton/2002-09-30: Should we really do that?
+              If that happens, isn't it likely to be a GDB error, in
+              which case we should fix the GDB error rather than
+              silently dealing with it here?  So I'd vote for
+              removing the check for the symbol in the other
+              block.  */
+           block = BLOCKVECTOR_BLOCK (bv,
+                                      block_index == GLOBAL_BLOCK ?
+                                      STATIC_BLOCK : GLOBAL_BLOCK);
            sym = lookup_block_symbol (block, name, mangled_name, namespace);
            if (!sym)
            sym = lookup_block_symbol (block, name, mangled_name, namespace);
            if (!sym)
-             error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
-%s may be an inlined function, or may be a template function\n\
-(if a template, try specifying an instantiation: %s<type>).",
+             error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>).",
+                    block_index == GLOBAL_BLOCK ? "global" : "static",
                     name, ps->filename, name, name);
          }
        if (symtab != NULL)
                     name, ps->filename, name, name);
          }
        if (symtab != NULL)
@@ -982,66 +1216,99 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
       }
   }
 
       }
   }
 
-#ifdef HPUXHPPA
+  return NULL;
+}
 
 
-  /* Check for the possibility of the symbol being a function or
-     a global variable that is stored in one of the minimal symbol tables.
-     The "minimal symbol table" is built from linker-supplied info.
+/* Check for the possibility of the symbol being a function or a
+   mangled variable that is stored in one of the minimal symbol
+   tables.  Eventually, all global symbols might be resolved in this
+   way.  */
 
 
-     RT: I moved this check to last, after the complete search of
-     the global (p)symtab's and static (p)symtab's. For HP-generated
-     symbol tables, this check was causing a premature exit from
-     lookup_symbol with NULL return, and thus messing up symbol lookups
-     of things like "c::f". It seems to me a check of the minimal
-     symbol table ought to be a last resort in any case. I'm vaguely
-     worried about the comment below which talks about FORTRAN routines "foo_"
-     though... is it saying we need to do the "minsym" check before
-     the static check in this case? 
-   */
+/* NOTE: carlton/2002-12-05: At one point, this function was part of
+   lookup_symbol_aux, and what are now 'return' statements within
+   lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
+   sym was NULL.  As far as I can tell, this was basically accidental;
+   it didn't happen every time that msymbol was non-NULL, but only if
+   some additional conditions held as well, and it caused problems
+   with HP-generated symbol tables.  */
+
+static struct symbol *
+lookup_symbol_aux_minsyms (const char *name,
+                          const char *mangled_name,
+                          const namespace_enum namespace,
+                          int *is_a_field_of_this,
+                          struct symtab **symtab)
+{
+  struct symbol *sym;
+  struct blockvector *bv;
+  const struct block *block;
+  struct minimal_symbol *msymbol;
+  struct symtab *s;
 
   if (namespace == VAR_NAMESPACE)
     {
       msymbol = lookup_minimal_symbol (name, NULL, NULL);
 
   if (namespace == VAR_NAMESPACE)
     {
       msymbol = lookup_minimal_symbol (name, NULL, NULL);
+
       if (msymbol != NULL)
        {
       if (msymbol != NULL)
        {
-         /* OK, we found a minimal symbol in spite of not
-          * finding any symbol. There are various possible
-          * explanations for this. One possibility is the symbol
-          * exists in code not compiled -g. Another possibility
-          * is that the 'psymtab' isn't doing its job.
-          * A third possibility, related to #2, is that we were confused 
-          * by name-mangling. For instance, maybe the psymtab isn't
-          * doing its job because it only know about demangled
-          * names, but we were given a mangled name...
-          */
-
-         /* We first use the address in the msymbol to try to
-          * locate the appropriate symtab. Note that find_pc_symtab()
-          * has a side-effect of doing psymtab-to-symtab expansion,
-          * for the found symtab.
-          */
-         s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
+         /* OK, we found a minimal symbol in spite of not finding any
+            symbol. There are various possible explanations for
+            this. One possibility is the symbol exists in code not
+            compiled -g. Another possibility is that the 'psymtab'
+            isn't doing its job.  A third possibility, related to #2,
+            is that we were confused by name-mangling. For instance,
+            maybe the psymtab isn't doing its job because it only
+            know about demangled names, but we were given a mangled
+            name...  */
+
+         /* We first use the address in the msymbol to try to locate
+            the appropriate symtab. Note that find_pc_sect_symtab()
+            has a side-effect of doing psymtab-to-symtab expansion,
+            for the found symtab.  */
+         s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
+                                  SYMBOL_BFD_SECTION (msymbol));
          if (s != NULL)
            {
          if (s != NULL)
            {
+             /* This is a function which has a symtab for its address.  */
              bv = BLOCKVECTOR (s);
              block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
              bv = BLOCKVECTOR (s);
              block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-             sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
-                                        mangled_name, namespace);
+
+             /* This call used to pass `SYMBOL_NAME (msymbol)' as the
+                `name' argument to lookup_block_symbol.  But the name
+                of a minimal symbol is always mangled, so that seems
+                to be clearly the wrong thing to pass as the
+                unmangled name.  */
+             sym =
+               lookup_block_symbol (block, name, mangled_name, namespace);
              /* We kept static functions in minimal symbol table as well as
                 in static scope. We want to find them in the symbol table. */
              if (!sym)
                {
                  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
              /* We kept static functions in minimal symbol table as well as
                 in static scope. We want to find them in the symbol table. */
              if (!sym)
                {
                  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-                 sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
+                 sym = lookup_block_symbol (block, name,
                                             mangled_name, namespace);
                }
                                             mangled_name, namespace);
                }
-             /* If we found one, return it */
-             if (sym)
-               {
-                 if (symtab != NULL)
-                   *symtab = s;
-                 return sym;
-               }
+
+             /* NOTE: carlton/2002-12-04: The following comment was
+                taken from a time when two versions of this function
+                were part of the body of lookup_symbol_aux: this
+                comment was taken from the version of the function
+                that was #ifdef HPUXHPPA, and the comment was right
+                before the 'return NULL' part of lookup_symbol_aux.
+                (Hence the "Fall through and return 0" comment.)
+                Elena did some digging into the situation for
+                Fortran, and she reports:
+
+                "I asked around (thanks to Jeff Knaggs), and I think
+                the story for Fortran goes like this:
+
+                "Apparently, in older Fortrans, '_' was not part of
+                the user namespace.  g77 attached a final '_' to
+                procedure names as the exported symbols for linkage
+                (foo_) , but the symbols went in the debug info just
+                like 'foo'. The rationale behind this is not
+                completely clear, and maybe it was done to other
+                symbols as well, not just procedures."  */
 
              /* If we get here with sym == 0, the symbol was 
                 found in the minimal symbol table
 
              /* If we get here with sym == 0, the symbol was 
                 found in the minimal symbol table
@@ -1060,30 +1327,27 @@ lookup_symbol_aux (const char *name, const char *mangled_name,
                 asm(".globl _main");
                 asm("_main:");
               */
                 asm(".globl _main");
                 asm("_main:");
               */
-           }
 
 
-         /* If the lookup-by-address fails, try repeating the
-          * entire lookup process with the symbol name from
-          * the msymbol (if different from the original symbol name).
-          */
+             if (symtab != NULL && sym != NULL)
+               *symtab = s;
+             return fixup_symbol_section (sym, s->objfile);
+           }
          else if (MSYMBOL_TYPE (msymbol) != mst_text
                   && MSYMBOL_TYPE (msymbol) != mst_file_text
                   && !STREQ (name, SYMBOL_NAME (msymbol)))
            {
          else if (MSYMBOL_TYPE (msymbol) != mst_text
                   && MSYMBOL_TYPE (msymbol) != mst_file_text
                   && !STREQ (name, SYMBOL_NAME (msymbol)))
            {
+             /* This is a mangled variable, look it up by its
+                mangled name.  */
              return lookup_symbol_aux (SYMBOL_NAME (msymbol), mangled_name,
              return lookup_symbol_aux (SYMBOL_NAME (msymbol), mangled_name,
-                                       block, namespace, is_a_field_of_this,
+                                       NULL, namespace, is_a_field_of_this,
                                        symtab);
            }
        }
     }
 
                                        symtab);
            }
        }
     }
 
-#endif
-
-  if (symtab != NULL)
-    *symtab = NULL;
-  return 0;
+  return NULL;
 }
 }
-                                                               
+
 /* Look, in partial_symtab PST, for symbol NAME.  Check the global
    symbols if GLOBAL, the static symbols if not */
 
 /* Look, in partial_symtab PST, for symbol NAME.  Check the global
    symbols if GLOBAL, the static symbols if not */
 
@@ -1093,7 +1357,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, int global,
 {
   struct partial_symbol *temp;
   struct partial_symbol **start, **psym;
 {
   struct partial_symbol *temp;
   struct partial_symbol **start, **psym;
-  struct partial_symbol **top, **bottom, **center;
+  struct partial_symbol **top, **real_top, **bottom, **center;
   int length = (global ? pst->n_global_syms : pst->n_static_syms);
   int do_linear_search = 1;
   
   int length = (global ? pst->n_global_syms : pst->n_static_syms);
   int do_linear_search = 1;
   
@@ -1116,6 +1380,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, int global,
 
       bottom = start;
       top = start + length - 1;
 
       bottom = start;
       top = start + length - 1;
+      real_top = top;
       while (top > bottom)
        {
          center = bottom + (top - bottom) / 2;
       while (top > bottom)
        {
          center = bottom + (top - bottom) / 2;
@@ -1126,7 +1391,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, int global,
            {
              do_linear_search = 1;
            }
            {
              do_linear_search = 1;
            }
-         if (strcmp (SYMBOL_SOURCE_NAME (*center), name) >= 0)
+         if (strcmp (SYMBOL_PRINT_NAME (*center), name) >= 0)
            {
              top = center;
            }
            {
              top = center;
            }
@@ -1141,7 +1406,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name, int global,
       /* djb - 2000-06-03 - Use SYMBOL_MATCHES_NAME, not a strcmp, so
         we don't have to force a linear search on C++. Probably holds true
         for JAVA as well, no way to check.*/
       /* djb - 2000-06-03 - Use SYMBOL_MATCHES_NAME, not a strcmp, so
         we don't have to force a linear search on C++. Probably holds true
         for JAVA as well, no way to check.*/
-      while (SYMBOL_MATCHES_NAME (*top,name))
+      while (top <= real_top && SYMBOL_MATCHES_NAME (*top,name))
        {
          if (SYMBOL_NAMESPACE (*top) == namespace)
            {
        {
          if (SYMBOL_NAMESPACE (*top) == namespace)
            {
@@ -1328,6 +1593,22 @@ lookup_block_symbol (register const struct block *block, const char *name,
   register struct symbol *sym_found = NULL;
   register int do_linear_search = 1;
 
   register struct symbol *sym_found = NULL;
   register int do_linear_search = 1;
 
+  if (BLOCK_HASHTABLE (block))
+    {
+      unsigned int hash_index;
+      hash_index = msymbol_hash_iw (name);
+      hash_index = hash_index % BLOCK_BUCKETS (block);
+      for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next)
+       {
+         if (SYMBOL_NAMESPACE (sym) == namespace 
+             && (mangled_name
+                 ? strcmp (SYMBOL_NAME (sym), mangled_name) == 0
+                 : SYMBOL_MATCHES_NAME (sym, name)))
+           return sym;
+       }
+      return NULL;
+    }
+
   /* If the blocks's symbols were sorted, start with a binary search.  */
 
   if (BLOCK_SHOULD_SORT (block))
   /* If the blocks's symbols were sorted, start with a binary search.  */
 
   if (BLOCK_SHOULD_SORT (block))
@@ -1356,15 +1637,15 @@ lookup_block_symbol (register const struct block *block, const char *name,
            {
              do_linear_search = 1;
            }
            {
              do_linear_search = 1;
            }
-         if (SYMBOL_SOURCE_NAME (sym)[0] < name[0])
+         if (SYMBOL_PRINT_NAME (sym)[0] < name[0])
            {
              bot = inc;
            }
            {
              bot = inc;
            }
-         else if (SYMBOL_SOURCE_NAME (sym)[0] > name[0])
+         else if (SYMBOL_PRINT_NAME (sym)[0] > name[0])
            {
              top = inc;
            }
            {
              top = inc;
            }
-         else if (strcmp (SYMBOL_SOURCE_NAME (sym), name) < 0)
+         else if (strcmp (SYMBOL_PRINT_NAME (sym), name) < 0)
            {
              bot = inc;
            }
            {
              bot = inc;
            }
@@ -1396,7 +1677,7 @@ lookup_block_symbol (register const struct block *block, const char *name,
            {
              return sym;
            }
            {
              return sym;
            }
-          if (SYMBOL_SOURCE_NAME (sym)[0] > name[0])
+          if (SYMBOL_PRINT_NAME (sym)[0] > name[0])
             {
               break;
             }
             {
               break;
             }
@@ -1458,7 +1739,8 @@ lookup_block_symbol (register const struct block *block, const char *name,
                  SYMBOL_CLASS (sym) != LOC_REF_ARG &&
                  SYMBOL_CLASS (sym) != LOC_REGPARM &&
                  SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
                  SYMBOL_CLASS (sym) != LOC_REF_ARG &&
                  SYMBOL_CLASS (sym) != LOC_REGPARM &&
                  SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
-                 SYMBOL_CLASS (sym) != LOC_BASEREG_ARG)
+                 SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
+                 SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
                {
                  break;
                }
                {
                  break;
                }
@@ -1501,18 +1783,6 @@ find_active_alias (struct symbol *sym, CORE_ADDR addr)
 }
 \f
 
 }
 \f
 
-/* Return the symbol for the function which contains a specified
-   lexical block, described by a struct block BL.  */
-
-struct symbol *
-block_function (struct block *bl)
-{
-  while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
-    bl = BLOCK_SUPERBLOCK (bl);
-
-  return BLOCK_FUNCTION (bl);
-}
-
 /* Find the symtab associated with PC and SECTION.  Look through the
    psymtabs and read in another symtab if necessary. */
 
 /* Find the symtab associated with PC and SECTION.  Look through the
    psymtabs and read in another symtab if necessary. */
 
@@ -1582,14 +1852,15 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section)
        if (section != 0)
          {
            int i;
        if (section != 0)
          {
            int i;
+           struct symbol *sym = NULL;
 
 
-           for (i = 0; i < b->nsyms; i++)
+           ALL_BLOCK_SYMBOLS (b, i, sym)
              {
              {
-               fixup_symbol_section (b->sym[i], objfile);
-               if (section == SYMBOL_BFD_SECTION (b->sym[i]))
+               fixup_symbol_section (sym, objfile);
+               if (section == SYMBOL_BFD_SECTION (sym))
                  break;
              }
                  break;
              }
-           if (i >= b->nsyms)
+           if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL))
              continue;         /* no symbol in this symtab matches section */
          }
        distance = BLOCK_END (b) - BLOCK_START (b);
              continue;         /* no symbol in this symtab matches section */
          }
        distance = BLOCK_END (b) - BLOCK_START (b);
@@ -1626,96 +1897,6 @@ find_pc_symtab (CORE_ADDR pc)
 }
 \f
 
 }
 \f
 
-#if 0
-
-/* Find the closest symbol value (of any sort -- function or variable)
-   for a given address value.  Slow but complete.  (currently unused,
-   mainly because it is too slow.  We could fix it if each symtab and
-   psymtab had contained in it the addresses ranges of each of its
-   sections, which also would be required to make things like "info
-   line *0x2345" cause psymtabs to be converted to symtabs).  */
-
-struct symbol *
-find_addr_symbol (CORE_ADDR addr, struct symtab **symtabp, CORE_ADDR *symaddrp)
-{
-  struct symtab *symtab, *best_symtab;
-  struct objfile *objfile;
-  register int bot, top;
-  register struct symbol *sym;
-  register CORE_ADDR sym_addr;
-  struct block *block;
-  int blocknum;
-
-  /* Info on best symbol seen so far */
-
-  register CORE_ADDR best_sym_addr = 0;
-  struct symbol *best_sym = 0;
-
-  /* FIXME -- we should pull in all the psymtabs, too!  */
-  ALL_SYMTABS (objfile, symtab)
-  {
-    /* Search the global and static blocks in this symtab for
-       the closest symbol-address to the desired address.  */
-
-    for (blocknum = GLOBAL_BLOCK; blocknum <= STATIC_BLOCK; blocknum++)
-      {
-       QUIT;
-       block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), blocknum);
-       top = BLOCK_NSYMS (block);
-       for (bot = 0; bot < top; bot++)
-         {
-           sym = BLOCK_SYM (block, bot);
-           switch (SYMBOL_CLASS (sym))
-             {
-             case LOC_STATIC:
-             case LOC_LABEL:
-               sym_addr = SYMBOL_VALUE_ADDRESS (sym);
-               break;
-
-             case LOC_INDIRECT:
-               sym_addr = SYMBOL_VALUE_ADDRESS (sym);
-               /* An indirect symbol really lives at *sym_addr,
-                * so an indirection needs to be done.
-                * However, I am leaving this commented out because it's
-                * expensive, and it's possible that symbolization
-                * could be done without an active process (in
-                * case this read_memory will fail). RT
-                sym_addr = read_memory_unsigned_integer
-                (sym_addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-                */
-               break;
-
-             case LOC_BLOCK:
-               sym_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
-               break;
-
-             default:
-               continue;
-             }
-
-           if (sym_addr <= addr)
-             if (sym_addr > best_sym_addr)
-               {
-                 /* Quit if we found an exact match.  */
-                 best_sym = sym;
-                 best_sym_addr = sym_addr;
-                 best_symtab = symtab;
-                 if (sym_addr == addr)
-                   goto done;
-               }
-         }
-      }
-  }
-
-done:
-  if (symtabp)
-    *symtabp = best_symtab;
-  if (symaddrp)
-    *symaddrp = best_sym_addr;
-  return best_sym;
-}
-#endif /* 0 */
-
 /* Find the source file and line number for a given PC value and SECTION.
    Return a structure containing a symtab pointer, a line number,
    and a pc range for the entire source line.
 /* Find the source file and line number for a given PC value and SECTION.
    Return a structure containing a symtab pointer, a line number,
    and a pc range for the entire source line.
@@ -1770,7 +1951,7 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
      But what we want is the statement containing the instruction.
      Fudge the pc to make sure we get that.  */
 
      But what we want is the statement containing the instruction.
      Fudge the pc to make sure we get that.  */
 
-  INIT_SAL (&val);             /* initialize to zeroes */
+  init_sal (&val);             /* initialize to zeroes */
 
   /* It's tempting to assume that, if we can't find debugging info for
      any function enclosing PC, that we shouldn't search for line
 
   /* It's tempting to assume that, if we can't find debugging info for
      any function enclosing PC, that we shouldn't search for line
@@ -1912,9 +2093,11 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
          the first line, prev will not be set.  */
 
       /* Is this file's best line closer than the best in the other files?
          the first line, prev will not be set.  */
 
       /* Is this file's best line closer than the best in the other files?
-         If so, record this file, and its best line, as best so far.  */
+         If so, record this file, and its best line, as best so far.  Don't
+         save prev if it represents the end of a function (i.e. line number
+         0) instead of a real line.  */
 
 
-      if (prev && (!best || prev->pc > best->pc))
+      if (prev && prev->line && (!best || prev->pc > best->pc))
        {
          best = prev;
          best_symtab = s;
        {
          best = prev;
          best_symtab = s;
@@ -2550,8 +2733,8 @@ compare_search_syms (const void *sa, const void *sb)
   struct symbol_search **sym_a = (struct symbol_search **) sa;
   struct symbol_search **sym_b = (struct symbol_search **) sb;
 
   struct symbol_search **sym_a = (struct symbol_search **) sa;
   struct symbol_search **sym_b = (struct symbol_search **) sb;
 
-  return strcmp (SYMBOL_SOURCE_NAME ((*sym_a)->symbol),
-                SYMBOL_SOURCE_NAME ((*sym_b)->symbol));
+  return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
+                SYMBOL_PRINT_NAME ((*sym_b)->symbol));
 }
 
 /* Sort the ``nfound'' symbols in the list after prevtail.  Leave
 }
 
 /* Sort the ``nfound'' symbols in the list after prevtail.  Leave
@@ -2769,6 +2952,12 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[],
              {
                if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
                  {
              {
                if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
                  {
+                   /* FIXME: carlton/2003-02-04: Given that the
+                      semantics of lookup_symbol keeps on changing
+                      slightly, it would be a nice idea if we had a
+                      function lookup_symbol_minsym that found the
+                      symbol associated to a given minimal symbol (if
+                      any).  */
                    if (kind == FUNCTIONS_NAMESPACE
                        || lookup_symbol (SYMBOL_NAME (msymbol),
                                          (struct block *) NULL,
                    if (kind == FUNCTIONS_NAMESPACE
                        || lookup_symbol (SYMBOL_NAME (msymbol),
                                          (struct block *) NULL,
@@ -2795,10 +2984,9 @@ search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[],
          struct symbol_search *prevtail = tail;
          int nfound = 0;
          b = BLOCKVECTOR_BLOCK (bv, i);
          struct symbol_search *prevtail = tail;
          int nfound = 0;
          b = BLOCKVECTOR_BLOCK (bv, i);
-         for (j = 0; j < BLOCK_NSYMS (b); j++)
+         ALL_BLOCK_SYMBOLS (b, j, sym)
            {
              QUIT;
            {
              QUIT;
-             sym = BLOCK_SYM (b, j);
              if (file_matches (s->filename, files, nfiles)
                  && ((regexp == NULL || SYMBOL_MATCHES_REGEXP (sym))
                      && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (sym) != LOC_TYPEDEF
              if (file_matches (s->filename, files, nfiles)
                  && ((regexp == NULL || SYMBOL_MATCHES_REGEXP (sym))
                      && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (sym) != LOC_TYPEDEF
@@ -2921,35 +3109,11 @@ print_symbol_info (namespace_enum kind, struct symtab *s, struct symbol *sym,
     {
       type_print (SYMBOL_TYPE (sym),
                  (SYMBOL_CLASS (sym) == LOC_TYPEDEF
     {
       type_print (SYMBOL_TYPE (sym),
                  (SYMBOL_CLASS (sym) == LOC_TYPEDEF
-                  ? "" : SYMBOL_SOURCE_NAME (sym)),
+                  ? "" : SYMBOL_PRINT_NAME (sym)),
                  gdb_stdout, 0);
 
       printf_filtered (";\n");
     }
                  gdb_stdout, 0);
 
       printf_filtered (";\n");
     }
-  else
-    {
-#if 0
-      /* Tiemann says: "info methods was never implemented."  */
-      char *demangled_name;
-      c_type_print_base (TYPE_FN_FIELD_TYPE (t, block),
-                        gdb_stdout, 0, 0);
-      c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (t, block),
-                                  gdb_stdout, 0);
-      if (TYPE_FN_FIELD_STUB (t, block))
-       check_stub_method (TYPE_DOMAIN_TYPE (type), j, block);
-      demangled_name =
-       cplus_demangle (TYPE_FN_FIELD_PHYSNAME (t, block),
-                       DMGL_ANSI | DMGL_PARAMS);
-      if (demangled_name == NULL)
-       fprintf_filtered (stream, "<badly mangled name %s>",
-                         TYPE_FN_FIELD_PHYSNAME (t, block));
-      else
-       {
-         fputs_filtered (demangled_name, stream);
-         xfree (demangled_name);
-       }
-#endif
-    }
 }
 
 /* This help function for symtab_symbol_info() prints information
 }
 
 /* This help function for symtab_symbol_info() prints information
@@ -2961,14 +3125,14 @@ print_msymbol_info (struct minimal_symbol *msymbol)
   char *tmp;
 
   if (TARGET_ADDR_BIT <= 32)
   char *tmp;
 
   if (TARGET_ADDR_BIT <= 32)
-    tmp = longest_local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
-                                          & (CORE_ADDR) 0xffffffff,
-                                          "08l");
+    tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
+                                  & (CORE_ADDR) 0xffffffff,
+                                  "08l");
   else
   else
-    tmp = longest_local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
-                                          "016l");
+    tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
+                                  "016l");
   printf_filtered ("%s  %s\n",
   printf_filtered ("%s  %s\n",
-                  tmp, SYMBOL_SOURCE_NAME (msymbol));
+                  tmp, SYMBOL_PRINT_NAME (msymbol));
 }
 
 /* This is the guts of the commands "info functions", "info types", and
 }
 
 /* This is the guts of the commands "info functions", "info types", and
@@ -3043,15 +3207,6 @@ types_info (char *regexp, int from_tty)
   symtab_symbol_info (regexp, TYPES_NAMESPACE, from_tty);
 }
 
   symtab_symbol_info (regexp, TYPES_NAMESPACE, from_tty);
 }
 
-#if 0
-/* Tiemann says: "info methods was never implemented."  */
-static void
-methods_info (char *regexp)
-{
-  symtab_symbol_info (regexp, METHODS_NAMESPACE, 0, from_tty);
-}
-#endif /* 0 */
-
 /* Breakpoint all functions matching regular expression. */
 
 void
 /* Breakpoint all functions matching regular expression. */
 
 void
@@ -3092,7 +3247,7 @@ rbreak_command (char *regexp, int from_tty)
        {
          break_command (SYMBOL_NAME (p->msymbol), from_tty);
          printf_filtered ("<function, no debug info> %s;\n",
        {
          break_command (SYMBOL_NAME (p->msymbol), from_tty);
          printf_filtered ("<function, no debug info> %s;\n",
-                          SYMBOL_SOURCE_NAME (p->msymbol));
+                          SYMBOL_PRINT_NAME (p->msymbol));
        }
     }
 
        }
     }
 
@@ -3100,19 +3255,6 @@ rbreak_command (char *regexp, int from_tty)
 }
 \f
 
 }
 \f
 
-/* Return Nonzero if block a is lexically nested within block b,
-   or if a and b have the same pc range.
-   Return zero otherwise. */
-int
-contained_in (struct block *a, struct block *b)
-{
-  if (!a || !b)
-    return 0;
-  return BLOCK_START (a) >= BLOCK_START (b)
-    && BLOCK_END (a) <= BLOCK_END (b);
-}
-\f
-
 /* Helper routine for make_symbol_completion_list.  */
 
 static int return_val_size;
 /* Helper routine for make_symbol_completion_list.  */
 
 static int return_val_size;
@@ -3719,6 +3861,49 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
 
 
 /* Begin overload resolution functions */
 
 
 /* Begin overload resolution functions */
+
+static char *
+remove_params (const char *demangled_name)
+{
+  const char *argp;
+  char *new_name;
+  int depth;
+
+  if (demangled_name == NULL)
+    return NULL;
+
+  /* First find the end of the arg list.  */
+  argp = strrchr (demangled_name, ')');
+  if (argp == NULL)
+    return NULL;
+
+  /* Back up to the beginning.  */
+  depth = 1;
+
+  while (argp-- > demangled_name)
+    {
+      if (*argp == ')')
+       depth ++;
+      else if (*argp == '(')
+       {
+         depth --;
+
+         if (depth == 0)
+           break;
+       }
+    }
+  if (depth != 0)
+    internal_error (__FILE__, __LINE__,
+                   "bad demangled name %s\n", demangled_name);
+  while (argp[-1] == ' ' && argp > demangled_name)
+    argp --;
+
+  new_name = xmalloc (argp - demangled_name + 1);
+  memcpy (new_name, demangled_name, argp - demangled_name);
+  new_name[argp - demangled_name] = '\0';
+  return new_name;
+}
+
 /* Helper routine for make_symbol_completion_list.  */
 
 static int sym_return_val_size;
 /* Helper routine for make_symbol_completion_list.  */
 
 static int sym_return_val_size;
@@ -3734,14 +3919,21 @@ overload_list_add_symbol (struct symbol *sym, char *oload_name)
 {
   int newsize;
   int i;
 {
   int newsize;
   int i;
+  char *sym_name;
+
+  /* If there is no type information, we can't do anything, so skip */
+  if (SYMBOL_TYPE (sym) == NULL)
+    return;
+
+  /* skip any symbols that we've already considered. */
+  for (i = 0; i < sym_return_val_index; ++i)
+    if (!strcmp (SYMBOL_NAME (sym), SYMBOL_NAME (sym_return_val[i])))
+      return;
 
   /* Get the demangled name without parameters */
 
   /* Get the demangled name without parameters */
-  char *sym_name = cplus_demangle (SYMBOL_NAME (sym), DMGL_ARM | DMGL_ANSI);
+  sym_name = remove_params (SYMBOL_DEMANGLED_NAME (sym));
   if (!sym_name)
   if (!sym_name)
-    {
-      sym_name = (char *) xmalloc (strlen (SYMBOL_NAME (sym)) + 1);
-      strcpy (sym_name, SYMBOL_NAME (sym));
-    }
+    return;
 
   /* skip symbols that cannot match */
   if (strcmp (sym_name, oload_name) != 0)
 
   /* skip symbols that cannot match */
   if (strcmp (sym_name, oload_name) != 0)
@@ -3750,14 +3942,7 @@ overload_list_add_symbol (struct symbol *sym, char *oload_name)
       return;
     }
 
       return;
     }
 
-  /* If there is no type information, we can't do anything, so skip */
-  if (SYMBOL_TYPE (sym) == NULL)
-    return;
-
-  /* skip any symbols that we've already considered. */
-  for (i = 0; i < sym_return_val_index; ++i)
-    if (!strcmp (SYMBOL_NAME (sym), SYMBOL_NAME (sym_return_val[i])))
-      return;
+  xfree (sym_name);
 
   /* We have a match for an overload instance, so add SYM to the current list
    * of overload instances */
 
   /* We have a match for an overload instance, so add SYM to the current list
    * of overload instances */
@@ -3768,8 +3953,6 @@ overload_list_add_symbol (struct symbol *sym, char *oload_name)
     }
   sym_return_val[sym_return_val_index++] = sym;
   sym_return_val[sym_return_val_index] = NULL;
     }
   sym_return_val[sym_return_val_index++] = sym;
   sym_return_val[sym_return_val_index] = NULL;
-
-  xfree (sym_name);
 }
 
 /* Return a null-terminated list of pointers to function symbols that
 }
 
 /* Return a null-terminated list of pointers to function symbols that
@@ -3792,14 +3975,17 @@ make_symbol_overload_list (struct symbol *fsym)
   /* Length of name.  */
   int oload_name_len = 0;
 
   /* Length of name.  */
   int oload_name_len = 0;
 
-  /* Look for the symbol we are supposed to complete on.
-   * FIXME: This should be language-specific.  */
+  /* Look for the symbol we are supposed to complete on.  */
 
 
-  oload_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_ARM | DMGL_ANSI);
+  oload_name = remove_params (SYMBOL_DEMANGLED_NAME (fsym));
   if (!oload_name)
     {
   if (!oload_name)
     {
-      oload_name = (char *) xmalloc (strlen (SYMBOL_NAME (fsym)) + 1);
-      strcpy (oload_name, SYMBOL_NAME (fsym));
+      sym_return_val_size = 1;
+      sym_return_val = (struct symbol **) xmalloc (2 * sizeof (struct symbol *));
+      sym_return_val[0] = fsym;
+      sym_return_val[1] = NULL;
+
+      return sym_return_val;
     }
   oload_name_len = strlen (oload_name);
 
     }
   oload_name_len = strlen (oload_name);
 
@@ -3898,11 +4084,19 @@ struct symtabs_and_lines
 decode_line_spec (char *string, int funfirstline)
 {
   struct symtabs_and_lines sals;
 decode_line_spec (char *string, int funfirstline)
 {
   struct symtabs_and_lines sals;
+  struct symtab_and_line cursal;
+  
   if (string == 0)
     error ("Empty line specification.");
   if (string == 0)
     error ("Empty line specification.");
+    
+  /* We use whatever is set as the current source line. We do not try
+     and get a default  or it will recursively call us! */  
+  cursal = get_current_source_symtab_and_line ();
+  
   sals = decode_line_1 (&string, funfirstline,
   sals = decode_line_1 (&string, funfirstline,
-                       current_source_symtab, current_source_line,
+                       cursal.symtab, cursal.line,
                        (char ***) NULL);
                        (char ***) NULL);
+
   if (*string)
     error ("Junk at end of line specification: %s", string);
   return sals;
   if (*string)
     error ("Junk at end of line specification: %s", string);
   return sals;
@@ -3959,13 +4153,6 @@ _initialize_symtab (void)
   add_info ("types", types_info,
            "All type names, or those matching REGEXP.");
 
   add_info ("types", types_info,
            "All type names, or those matching REGEXP.");
 
-#if 0
-  add_info ("methods", methods_info,
-           "All method names, or those matching REGEXP::REGEXP.\n\
-If the class qualifier is omitted, it is assumed to be the current scope.\n\
-If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
-are listed.");
-#endif
   add_info ("sources", sources_info,
            "Source files in the program.");
 
   add_info ("sources", sources_info,
            "Source files in the program.");
 
GDB Binutils - Deliverables
This page took 0.041963 seconds and 4 git commands to generate.