* cadillac.c (kernel_dispatch): Make return type void.

[deliverable/binutils-gdb.git] / gdb / minsyms.c

diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index 1d7faaaba1704fda13316bc2e73de52642d44811..164159241b46627a1cbffc8c3efd5fd2aba58428 100644 (file)
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -41,6 +41,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "symtab.h"
 #include "bfd.h"
 #include "symfile.h"
+#include "objfiles.h"
 
 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
    At the end, copy them all into one newly allocated location on an objfile's
@@ -75,42 +76,6 @@ compare_minimal_symbols PARAMS ((const void *, const void *));
 static int
 compact_minimal_symbols PARAMS ((struct minimal_symbol *, int));
 
-/* Call the function specified by FUNC for each currently available minimal
-   symbol, for as long as this function continues to return NULL.  If the
-   function ever returns non-NULL, then the iteration over the minimal
-   symbols is terminated and the result is returned to the caller.
-
-   The function called has full control over the form and content of the
-   information returned via the non-NULL result, which may be as simple as a
-   pointer to the minimal symbol that the iteration terminated on, or as
-   complex as a pointer to a private structure containing multiple results. */
-
-PTR
-iterate_over_msymbols (func, arg1, arg2, arg3)
-     PTR (*func) PARAMS ((struct objfile *, struct minimal_symbol *,
-                         PTR, PTR, PTR));
-     PTR arg1;
-     PTR arg2;
-     PTR arg3;
-{
-  register struct objfile *objfile;
-  register struct minimal_symbol *msymbol;
-  char *result = NULL;
-
-  for (objfile = object_files;
-       objfile != NULL && result == NULL;
-       objfile = objfile -> next)
-    {
-      for (msymbol = objfile -> msymbols;
-          msymbol != NULL && msymbol -> name != NULL && result == NULL;
-          msymbol++)
-       {
-         result = (*func)(objfile, msymbol, arg1, arg2, arg3);
-       }
-    }
-  return (result);
-}
-
 /* Look through all the current minimal symbol tables and find the first
    minimal symbol that matches NAME.  If OBJF is non-NULL, it specifies a
    particular objfile and the search is limited to that objfile.  Returns
@@ -129,7 +94,7 @@ lookup_minimal_symbol (name, objf)
   struct objfile *objfile;
   struct minimal_symbol *msymbol;
   struct minimal_symbol *found_symbol = NULL;
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
   struct minimal_symbol *trampoline_symbol = NULL;
 #endif
 
@@ -146,13 +111,13 @@ lookup_minimal_symbol (name, objf)
            {
              if (strcmp (msymbol -> name, name) == 0)
                {
+#ifdef IBM6000_TARGET
 /* I *think* all platforms using shared libraries (and trampoline code)
  * will suffer this problem. Consider a case where there are 5 shared
  * libraries, each referencing `foo' with a trampoline entry. When someone
  * wants to put a breakpoint on `foo' and the only info we have is minimal
  * symbol vector, we want to use the real `foo', rather than one of those
  * trampoline entries. MGO */  
-#ifdef IBM6000
          /* If a trampoline symbol is found, we prefer to keep looking
             for the *real* symbol. If the actual symbol not found,
             then we'll use the trampoline entry. Sorry for the machine
@@ -172,7 +137,7 @@ lookup_minimal_symbol (name, objf)
            }
        }
     }
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
   return found_symbol ? found_symbol : trampoline_symbol;
 #endif
 
@@ -231,6 +196,7 @@ lookup_minimal_symbol_by_pc (pc)
 
             Warning: this code is trickier than it would appear at first. */
 
+         /* Should also requires that pc is <= end of objfile.  FIXME! */
          if (pc >= msymbol[lo].address)
            {
              while (msymbol[hi].address > pc)
@@ -297,6 +263,32 @@ prim_record_minimal_symbol (name, address, ms_type)
   msym_count++;
 }
 
+void
+prim_record_minimal_symbol_and_info (name, address, ms_type, info)
+     const char *name;
+     CORE_ADDR address;
+     enum minimal_symbol_type ms_type;
+     char *info;
+{
+  register struct msym_bunch *new;
+
+  if (msym_bunch_index == BUNCH_SIZE)
+    {
+      new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch));
+      msym_bunch_index = 0;
+      new -> next = msym_bunch;
+      msym_bunch = new;
+    }
+  msym_bunch -> contents[msym_bunch_index].name = (char *) name;
+  msym_bunch -> contents[msym_bunch_index].address = address;
+  msym_bunch -> contents[msym_bunch_index].info = NULL;
+  msym_bunch -> contents[msym_bunch_index].type = ms_type;
+    /* FIXME:  This info, if it remains, needs its own field.  */
+  msym_bunch -> contents[msym_bunch_index].info = info;  /* FIXME! */
+  msym_bunch_index++;
+  msym_count++;
+}
+
 /* Compare two minimal symbols by address and return a signed result based
    on unsigned comparisons, so that we sort into unsigned numeric order.  */
 
@@ -343,7 +335,7 @@ discard_minimal_symbols (foo)
   while (msym_bunch != NULL)
     {
       next = msym_bunch -> next;
-      free (msym_bunch);
+      free ((PTR)msym_bunch);
       msym_bunch = next;
     }
 }