* symtab.h (SYMBOL_SEARCH_NAME): New definition.

(SYMBOL_MATCHES_SEARCH_NAME): New definition.
(symbol_search_name): Declare.

* dictionary.c (iter_name_first_hashed): Match on SYMBOL_SEARCH_NAME.
(iter_name_next_hashed): Ditto.
(iter_name_next_linear): Ditto.
(insert_symbol_hashed): Hash on SYMBOL_SEARCH_NAME.

* symtab.c (lookup_partial_symbol): Assume symbols ordered by
search name, using SYMBOL_SEARCH_NAME and SYMBOL_MATCHES_SEARCH_NAME.
(symbol_search_name): New function.

* symfile.c (compare_psymbols): Order by SYMBOL_SEARCH_NAME.

* minsyms.c (build_minimal_symbol_hash_tables): Change
test for adding to demangled hash table to check for difference
between SYMBOL_SEARCH_NAME and SYMBOL_LINKAGE_NAME.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b2de0b5c77cf567f1cf8dc286f6bec9c601c4777..4ff565e55578d29c185511351376b0737c68f63d 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,24 @@
+2004-05-20  Paul N. Hilfinger  <hilfinger@gnat.com>
+
+       * symtab.h (SYMBOL_SEARCH_NAME): New definition.
+       (SYMBOL_MATCHES_SEARCH_NAME): New definition.
+       (symbol_search_name): Declare.
+       
+       * dictionary.c (iter_name_first_hashed): Match on SYMBOL_SEARCH_NAME.
+       (iter_name_next_hashed): Ditto.
+       (iter_name_next_linear): Ditto.
+       (insert_symbol_hashed): Hash on SYMBOL_SEARCH_NAME.
+
+       * symtab.c (lookup_partial_symbol): Assume symbols ordered by 
+       search name, using SYMBOL_SEARCH_NAME and SYMBOL_MATCHES_SEARCH_NAME.
+       (symbol_search_name): New function.
+       
+       * symfile.c (compare_psymbols): Order by SYMBOL_SEARCH_NAME.
+       
+       * minsyms.c (build_minimal_symbol_hash_tables): Change
+       test for adding to demangled hash table to check for difference
+       between SYMBOL_SEARCH_NAME and SYMBOL_LINKAGE_NAME.
+       
 2004-05-19  Jim Blandy  <jimb@redhat.com>
 
        Use a constructor function to create regset structures.

diff --git a/gdb/dictionary.c b/gdb/dictionary.c
index 3802000763710e6f2c26e4924d9b02edf1277619..a5f1a0e89e395162c0145c66a3feb050287ce916 100644 (file)
--- a/gdb/dictionary.c
+++ b/gdb/dictionary.c
@@ -636,7 +636,7 @@ iter_name_first_hashed (const struct dictionary *dict,
        sym = sym->hash_next)
     {
       /* Warning: the order of arguments to strcmp_iw matters!  */
-      if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0)
+      if (strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
        {
          break;
        }
@@ -656,7 +656,7 @@ iter_name_next_hashed (const char *name, struct dict_iterator *iterator)
        next != NULL;
        next = next->hash_next)
     {
-      if (strcmp_iw (SYMBOL_NATURAL_NAME (next), name) == 0)
+      if (strcmp_iw (SYMBOL_SEARCH_NAME (next), name) == 0)
        break;
     }
 
@@ -674,7 +674,7 @@ insert_symbol_hashed (struct dictionary *dict,
   unsigned int hash_index;
   struct symbol **buckets = DICT_HASHED_BUCKETS (dict);
 
-  hash_index = (msymbol_hash_iw (SYMBOL_NATURAL_NAME (sym))
+  hash_index = (msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym))
                % DICT_HASHED_NBUCKETS (dict));
   sym->hash_next = buckets[hash_index];
   buckets[hash_index] = sym;
@@ -789,7 +789,7 @@ iter_name_next_linear (const char *name, struct dict_iterator *iterator)
   for (i = DICT_ITERATOR_INDEX (iterator) + 1; i < nsyms; ++i)
     {
       sym = DICT_LINEAR_SYM (dict, i);
-      if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0)
+      if (strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
        {
          retval = sym;
          break;

diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index b06c3f09d63b8719d88d0b7824f1fe7b2884ab8a..3aeda7d08159439f8206fc67ba415a4d8732e104 100644 (file)
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -791,7 +791,7 @@ build_minimal_symbol_hash_tables (struct objfile *objfile)
       add_minsym_to_hash_table (msym, objfile->msymbol_hash);
 
       msym->demangled_hash_next = 0;
-      if (SYMBOL_DEMANGLED_NAME (msym) != NULL)
+      if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
        add_minsym_to_demangled_hash_table (msym,
                                             objfile->msymbol_demangled_hash);
     }

diff --git a/gdb/symfile.c b/gdb/symfile.c
index b688cae7eb9237f2c3e5e2064df5d6b9901d0edb..23320377406cb22a533b44ae931fefed8d76416a 100644 (file)
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -207,8 +207,8 @@ compare_psymbols (const void *s1p, const void *s2p)
   struct partial_symbol *const *s1 = s1p;
   struct partial_symbol *const *s2 = s2p;
 
-  return strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*s1),
-                           SYMBOL_NATURAL_NAME (*s2));
+  return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
+                           SYMBOL_SEARCH_NAME (*s2));
 }
 
 void

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 7d1fd83aa43f03984ee1841d45fdf18841ebac0f..31a1635082f4504aaf4da63e53efa56749e156eb 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -659,6 +659,14 @@ symbol_demangled_name (struct general_symbol_info *gsymbol)
     return NULL;
 }
 
+/* Return the search name of a symbol---generally the demangled or
+   linkage name of the symbol, depending on how it will be searched for.
+   If there is no distinct demangled name, then returns the same value 
+   (same pointer) as SYMBOL_LINKAGE_NAME. */
+char *symbol_search_name (const struct general_symbol_info *gsymbol) {
+  return symbol_natural_name (gsymbol);
+}
+
 /* Initialize the structure fields to zero values.  */
 void
 init_sal (struct symtab_and_line *sal)
@@ -1467,7 +1475,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
            {
              do_linear_search = 1;
            }
-         if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0)
+         if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), name) >= 0)
            {
              top = center;
            }
@@ -1482,7 +1490,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
       while (top <= real_top
             && (linkage_name != NULL
                 ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
-                : SYMBOL_MATCHES_NATURAL_NAME (*top,name)))
+                : SYMBOL_MATCHES_SEARCH_NAME (*top,name)))
        {
          if (SYMBOL_DOMAIN (*top) == domain)
            {
@@ -1503,7 +1511,7 @@ lookup_partial_symbol (struct partial_symtab *pst, const char *name,
            {
              if (linkage_name != NULL
                  ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
-                 : SYMBOL_MATCHES_NATURAL_NAME (*psym, name))
+                 : SYMBOL_MATCHES_SEARCH_NAME (*psym, name))
                {
                  return (*psym);
                }

diff --git a/gdb/symtab.h b/gdb/symtab.h
index b30fc89dd75072b37499c8602883bf466563830d..65395241313e93e6045428dd19a360c2b90daf2d 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -258,6 +258,20 @@ extern char *symbol_demangled_name (struct general_symbol_info *symbol);
 #define SYMBOL_MATCHES_NATURAL_NAME(symbol, name)                      \
   (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
 
+/* Macro that returns the name to be used when sorting and searching symbols. 
+   In  C++, Chill, and Java, we search for the demangled form of a name,
+   and so sort symbols accordingly.  In Ada, however, we search by mangled
+   name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
+   returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
+#define SYMBOL_SEARCH_NAME(symbol)                                      \
+   (symbol_search_name (&(symbol)->ginfo))
+extern char *symbol_search_name (const struct general_symbol_info *);
+
+/* Analogous to SYMBOL_MATCHES_NATURAL_NAME, but uses the search
+   name.  */
+#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                       \
+  (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
+
 /* Classification types for a minimal symbol.  These should be taken as
    "advisory only", since if gdb can't easily figure out a
    classification it simply selects mst_unknown.  It may also have to