Initial revision

1 files changed, 904 insertions, 0 deletions

diff --git a/gdb/minsyms.c b/gdb/minsyms.c
new file mode 100644
index 00000000000..a271c9180c1
--- /dev/null
+++ b/gdb/minsyms.c
@@ -0,0 +1,904 @@
+/* GDB routines for manipulating the minimal symbol tables.
+   Copyright 1992, 93, 94, 96, 97, 1998 Free Software Foundation, Inc.
+   Contributed by Cygnus Support, using pieces from other GDB modules.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+/* This file contains support routines for creating, manipulating, and
+   destroying minimal symbol tables.
+
+   Minimal symbol tables are used to hold some very basic information about
+   all defined global symbols (text, data, bss, abs, etc).  The only two
+   required pieces of information are the symbol's name and the address
+   associated with that symbol.
+
+   In many cases, even if a file was compiled with no special options for
+   debugging at all, as long as was not stripped it will contain sufficient
+   information to build useful minimal symbol tables using this structure.
+   
+   Even when a file contains enough debugging information to build a full
+   symbol table, these minimal symbols are still useful for quickly mapping
+   between names and addresses, and vice versa.  They are also sometimes used
+   to figure out what full symbol table entries need to be read in. */
+
+
+#include "defs.h"
+#include "gdb_string.h"
+#include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "demangle.h"
+#include "gdb-stabs.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
+   symbol obstack.  */
+
+#define BUNCH_SIZE 127
+
+struct msym_bunch
+{
+  struct msym_bunch *next;
+  struct minimal_symbol contents[BUNCH_SIZE];
+};
+
+/* Bunch currently being filled up.
+   The next field points to chain of filled bunches.  */
+
+static struct msym_bunch *msym_bunch;
+
+/* Number of slots filled in current bunch.  */
+
+static int msym_bunch_index;
+
+/* Total number of minimal symbols recorded so far for the objfile.  */
+
+static int msym_count;
+
+/* Prototypes for local functions. */
+
+static int
+compare_minimal_symbols PARAMS ((const void *, const void *));
+
+static int
+compact_minimal_symbols PARAMS ((struct minimal_symbol *, int));
+
+/* Look through all the current minimal symbol tables and find the
+   first minimal symbol that matches NAME.  If OBJF is non-NULL, limit
+   the search to that objfile.  If SFILE is non-NULL, limit the search
+   to that source file.  Returns a pointer to the minimal symbol that
+   matches, or NULL if no match is found.
+
+   Note:  One instance where there may be duplicate minimal symbols with
+   the same name is when the symbol tables for a shared library and the
+   symbol tables for an executable contain global symbols with the same
+   names (the dynamic linker deals with the duplication). */
+
+struct minimal_symbol *
+lookup_minimal_symbol (name, sfile, objf)
+     register const char *name;
+     const char *sfile;
+     struct objfile *objf;
+{
+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;
+  struct minimal_symbol *found_symbol = NULL;
+  struct minimal_symbol *found_file_symbol = NULL;
+  struct minimal_symbol *trampoline_symbol = NULL;
+
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+  if (sfile != NULL)
+    {
+      char *p = strrchr (sfile, '/');
+      if (p != NULL)
+	sfile = p + 1;
+    }
+#endif
+
+  for (objfile = object_files;
+       objfile != NULL && found_symbol == NULL;
+       objfile = objfile -> next)
+    {
+      if (objf == NULL || objf == objfile)
+	{
+	  for (msymbol = objfile -> msymbols;
+	       msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
+	       found_symbol == NULL;
+	       msymbol++)
+	    {
+	      if (SYMBOL_MATCHES_NAME (msymbol, name))
+		{
+		  switch (MSYMBOL_TYPE (msymbol))
+		    {
+		    case mst_file_text:
+		    case mst_file_data:
+		    case mst_file_bss:
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+		      if (sfile == NULL || STREQ (msymbol->filename, sfile))
+			found_file_symbol = msymbol;
+#else
+		      /* We have neither the ability nor the need to
+			 deal with the SFILE parameter.  If we find
+			 more than one symbol, just return the latest
+			 one (the user can't expect useful behavior in
+			 that case).  */
+		      found_file_symbol = msymbol;
+#endif
+		      break;
+
+                    case mst_solib_trampoline:
+
+		      /* If a trampoline symbol is found, we prefer to
+			 keep looking for the *real* symbol. If the
+			 actual symbol is not found, then we'll use the
+			 trampoline entry. */
+		      if (trampoline_symbol == NULL)
+			trampoline_symbol = msymbol;
+		      break;
+
+		    case mst_unknown:
+		    default:
+		      found_symbol = msymbol;
+		      break;
+		    }
+		}
+	    }
+	}
+    }
+  /* External symbols are best.  */
+  if (found_symbol)
+    return found_symbol;
+
+  /* File-local symbols are next best.  */
+  if (found_file_symbol)
+    return found_file_symbol;
+
+  /* Symbols for shared library trampolines are next best.  */
+  if (trampoline_symbol)
+    return trampoline_symbol;
+
+  return NULL;
+}
+
+/* Look through all the current minimal symbol tables and find the
+   first minimal symbol that matches NAME and of text type.  
+   If OBJF is non-NULL, limit
+   the search to that objfile.  If SFILE is non-NULL, limit the search
+   to that source file.  Returns a pointer to the minimal symbol that
+   matches, or NULL if no match is found.
+*/
+   
+struct minimal_symbol *
+lookup_minimal_symbol_text (name, sfile, objf)
+     register const char *name;
+     const char *sfile;
+     struct objfile *objf;
+{
+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;
+  struct minimal_symbol *found_symbol = NULL;
+  struct minimal_symbol *found_file_symbol = NULL;
+
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+  if (sfile != NULL)
+    {
+      char *p = strrchr (sfile, '/');
+      if (p != NULL)
+	sfile = p + 1;
+    }
+#endif
+
+  for (objfile = object_files;
+       objfile != NULL && found_symbol == NULL;
+       objfile = objfile -> next)
+    {
+      if (objf == NULL || objf == objfile)
+	{
+	  for (msymbol = objfile -> msymbols;
+	       msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
+	       found_symbol == NULL;
+	       msymbol++)
+	    {
+	      if (SYMBOL_MATCHES_NAME (msymbol, name) && 
+		  (MSYMBOL_TYPE (msymbol) == mst_text ||
+		   MSYMBOL_TYPE (msymbol) == mst_file_text))
+		{
+		  switch (MSYMBOL_TYPE (msymbol))
+		    {
+		    case mst_file_text:
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+		      if (sfile == NULL || STREQ (msymbol->filename, sfile))
+			found_file_symbol = msymbol;
+#else
+		      /* We have neither the ability nor the need to
+			 deal with the SFILE parameter.  If we find
+			 more than one symbol, just return the latest
+			 one (the user can't expect useful behavior in
+			 that case).  */
+		      found_file_symbol = msymbol;
+#endif
+		      break;
+		    default:
+		      found_symbol = msymbol;
+		      break;
+		    }
+		}
+	    }
+	}
+    }
+  /* External symbols are best.  */
+  if (found_symbol)
+    return found_symbol;
+
+  /* File-local symbols are next best.  */
+  if (found_file_symbol)
+    return found_file_symbol;
+
+  return NULL;
+}
+
+/* Look through all the current minimal symbol tables and find the
+   first minimal symbol that matches NAME and of solib trampoline type.  
+   If OBJF is non-NULL, limit
+   the search to that objfile.  If SFILE is non-NULL, limit the search
+   to that source file.  Returns a pointer to the minimal symbol that
+   matches, or NULL if no match is found.
+*/
+   
+struct minimal_symbol *
+lookup_minimal_symbol_solib_trampoline (name, sfile, objf)
+     register const char *name;
+     const char *sfile;
+     struct objfile *objf;
+{
+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;
+  struct minimal_symbol *found_symbol = NULL;
+
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+  if (sfile != NULL)
+    {
+      char *p = strrchr (sfile, '/');
+      if (p != NULL)
+	sfile = p + 1;
+    }
+#endif
+
+  for (objfile = object_files;
+       objfile != NULL && found_symbol == NULL;
+       objfile = objfile -> next)
+    {
+      if (objf == NULL || objf == objfile)
+	{
+	  for (msymbol = objfile -> msymbols;
+	       msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
+	       found_symbol == NULL;
+	       msymbol++)
+	    {
+	      if (SYMBOL_MATCHES_NAME (msymbol, name) && 
+		  MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
+		return msymbol;
+	    }
+	}
+    }
+
+  return NULL;
+}
+
+
+/* Search through the minimal symbol table for each objfile and find
+   the symbol whose address is the largest address that is still less
+   than or equal to PC, and matches SECTION (if non-null).  Returns a
+   pointer to the minimal symbol if such a symbol is found, or NULL if
+   PC is not in a suitable range.  Note that we need to look through
+   ALL the minimal symbol tables before deciding on the symbol that
+   comes closest to the specified PC.  This is because objfiles can
+   overlap, for example objfile A has .text at 0x100 and .data at
+   0x40000 and objfile B has .text at 0x234 and .data at 0x40048.  */
+
+struct minimal_symbol *
+lookup_minimal_symbol_by_pc_section (pc, section)
+     CORE_ADDR pc;
+     asection *section;
+{
+  int lo;
+  int hi;
+  int new;
+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;
+  struct minimal_symbol *best_symbol = NULL;
+
+  /* pc has to be in a known section. This ensures that anything beyond
+     the end of the last segment doesn't appear to be part of the last
+     function in the last segment.  */
+  if (find_pc_section (pc) == NULL)
+    return NULL;
+
+  for (objfile = object_files;
+       objfile != NULL;
+       objfile = objfile -> next)
+    {
+      /* If this objfile has a minimal symbol table, go search it using
+	 a binary search.  Note that a minimal symbol table always consists
+	 of at least two symbols, a "real" symbol and the terminating
+	 "null symbol".  If there are no real symbols, then there is no
+	 minimal symbol table at all. */
+
+      if ((msymbol = objfile -> msymbols) != NULL)
+	{
+	  lo = 0;
+	  hi = objfile -> minimal_symbol_count - 1;
+
+	  /* This code assumes that the minimal symbols are sorted by
+	     ascending address values.  If the pc value is greater than or
+	     equal to the first symbol's address, then some symbol in this
+	     minimal symbol table is a suitable candidate for being the
+	     "best" symbol.  This includes the last real symbol, for cases
+	     where the pc value is larger than any address in this vector.
+
+	     By iterating until the address associated with the current
+	     hi index (the endpoint of the test interval) is less than
+	     or equal to the desired pc value, we accomplish two things:
+	     (1) the case where the pc value is larger than any minimal
+	     symbol address is trivially solved, (2) the address associated
+	     with the hi index is always the one we want when the interation
+	     terminates.  In essence, we are iterating the test interval
+	     down until the pc value is pushed out of it from the high end.
+
+	     Warning: this code is trickier than it would appear at first. */
+
+	  /* Should also require that pc is <= end of objfile.  FIXME! */
+	  if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
+	    {
+	      while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
+		{
+		  /* pc is still strictly less than highest address */
+		  /* Note "new" will always be >= lo */
+		  new = (lo + hi) / 2;
+		  if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
+		      (lo == new))
+		    {
+		      hi = new;
+		    }
+		  else
+		    {
+		      lo = new;
+		    }
+		}
+
+	      /* If we have multiple symbols at the same address, we want
+		 hi to point to the last one.  That way we can find the
+		 right symbol if it has an index greater than hi.  */
+	      while (hi < objfile -> minimal_symbol_count - 1
+		     && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
+			 == SYMBOL_VALUE_ADDRESS (&msymbol[hi+1])))
+		hi++;
+
+	      /* The minimal symbol indexed by hi now is the best one in this
+		 objfile's minimal symbol table.  See if it is the best one
+		 overall. */
+
+	      /* Skip any absolute symbols.  This is apparently what adb
+		 and dbx do, and is needed for the CM-5.  There are two
+		 known possible problems: (1) on ELF, apparently end, edata,
+		 etc. are absolute.  Not sure ignoring them here is a big
+		 deal, but if we want to use them, the fix would go in
+		 elfread.c.  (2) I think shared library entry points on the
+		 NeXT are absolute.  If we want special handling for this
+		 it probably should be triggered by a special
+		 mst_abs_or_lib or some such.  */
+	      while (hi >= 0
+		     && msymbol[hi].type == mst_abs)
+		--hi;
+
+	      /* If "section" specified, skip any symbol from wrong section */
+	      /* This is the new code that distinguishes it from the old function */
+	      if (section)
+		while (hi >= 0
+		       && SYMBOL_BFD_SECTION (&msymbol[hi]) != section)
+		  --hi;
+
+	      if (hi >= 0
+		  && ((best_symbol == NULL) ||
+		      (SYMBOL_VALUE_ADDRESS (best_symbol) < 
+		       SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
+		{
+		  best_symbol = &msymbol[hi];
+		}
+	    }
+	}
+    }
+  return (best_symbol);
+}
+
+/* Backward compatibility: search through the minimal symbol table 
+   for a matching PC (no section given) */
+
+struct minimal_symbol *
+lookup_minimal_symbol_by_pc (pc)
+     CORE_ADDR pc;
+{
+  return lookup_minimal_symbol_by_pc_section (pc, find_pc_mapped_section (pc));
+}
+
+#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+CORE_ADDR
+find_stab_function_addr (namestring, pst, objfile)
+     char *namestring;
+     struct partial_symtab *pst;
+     struct objfile *objfile;
+{
+  struct minimal_symbol *msym;
+  char *p;
+  int n;
+
+  p = strchr (namestring, ':');
+  if (p == NULL)
+    p = namestring;
+  n = p - namestring;
+  p = alloca (n + 2);
+  strncpy (p, namestring, n);
+  p[n] = 0;
+
+  msym = lookup_minimal_symbol (p, pst->filename, objfile);
+  if (msym == NULL)
+    {
+      /* Sun Fortran appends an underscore to the minimal symbol name,
+	 try again with an appended underscore if the minimal symbol
+	 was not found.  */
+      p[n] = '_';
+      p[n + 1] = 0;
+      msym = lookup_minimal_symbol (p, pst->filename, objfile);
+    }
+  return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
+}
+#endif /* SOFUN_ADDRESS_MAYBE_MISSING */
+
+
+/* Return leading symbol character for a BFD. If BFD is NULL,
+   return the leading symbol character from the main objfile.  */
+
+static int get_symbol_leading_char PARAMS ((bfd *));
+
+static int
+get_symbol_leading_char (abfd)
+     bfd * abfd;
+{
+  if (abfd != NULL)
+    return bfd_get_symbol_leading_char (abfd);
+  if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
+    return bfd_get_symbol_leading_char (symfile_objfile->obfd);
+  return 0;
+}
+
+/* Prepare to start collecting minimal symbols.  Note that presetting
+   msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
+   symbol to allocate the memory for the first bunch. */
+
+void
+init_minimal_symbol_collection ()
+{
+  msym_count = 0;
+  msym_bunch = NULL;
+  msym_bunch_index = BUNCH_SIZE;
+}
+
+void
+prim_record_minimal_symbol (name, address, ms_type, objfile)
+     const char *name;
+     CORE_ADDR address;
+     enum minimal_symbol_type ms_type;
+     struct objfile *objfile;
+{
+  int section;
+
+  switch (ms_type)
+    {
+    case mst_text:
+    case mst_file_text:
+    case mst_solib_trampoline:
+      section = SECT_OFF_TEXT;
+      break;
+    case mst_data:
+    case mst_file_data:
+      section = SECT_OFF_DATA;
+      break;
+    case mst_bss:
+    case mst_file_bss:
+      section = SECT_OFF_BSS;
+      break;
+    default:
+      section = -1;
+    }
+
+  prim_record_minimal_symbol_and_info (name, address, ms_type,
+				       NULL, section, NULL, objfile);
+}
+
+/* Record a minimal symbol in the msym bunches.  Returns the symbol
+   newly created.  */
+
+struct minimal_symbol *
+prim_record_minimal_symbol_and_info (name, address, ms_type, info, section,
+				     bfd_section, objfile)
+     const char *name;
+     CORE_ADDR address;
+     enum minimal_symbol_type ms_type;
+     char *info;
+     int section;
+     asection *bfd_section;
+     struct objfile *objfile;
+{
+  register struct msym_bunch *new;
+  register struct minimal_symbol *msymbol;
+
+  if (ms_type == mst_file_text)
+    {
+      /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
+	 the minimal symbols, because if there is also another symbol
+	 at the same address (e.g. the first function of the file),
+	 lookup_minimal_symbol_by_pc would have no way of getting the
+	 right one.  */
+      if (name[0] == 'g'
+	  && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
+	      || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
+	return (NULL);
+
+      {
+	const char *tempstring = name;
+	if (tempstring[0] == get_symbol_leading_char (objfile->obfd))
+	  ++tempstring;
+	if (STREQN (tempstring, "__gnu_compiled", 14))
+	  return (NULL);
+      }
+    }
+
+  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;
+    }
+  msymbol = &msym_bunch -> contents[msym_bunch_index];
+  SYMBOL_NAME (msymbol) = obsavestring ((char *) name, strlen (name),
+					&objfile->symbol_obstack);
+  SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
+  SYMBOL_VALUE_ADDRESS (msymbol) = address;
+  SYMBOL_SECTION (msymbol) = section;
+  SYMBOL_BFD_SECTION (msymbol) = bfd_section;
+
+  MSYMBOL_TYPE (msymbol) = ms_type;
+  /* FIXME:  This info, if it remains, needs its own field.  */
+  MSYMBOL_INFO (msymbol) = info; /* FIXME! */
+  msym_bunch_index++;
+  msym_count++;
+  OBJSTAT (objfile, n_minsyms++);
+  return msymbol;
+}
+
+/* Compare two minimal symbols by address and return a signed result based
+   on unsigned comparisons, so that we sort into unsigned numeric order.  
+   Within groups with the same address, sort by name.  */
+
+static int
+compare_minimal_symbols (fn1p, fn2p)
+     const PTR fn1p;
+     const PTR fn2p;
+{
+  register const struct minimal_symbol *fn1;
+  register const struct minimal_symbol *fn2;
+
+  fn1 = (const struct minimal_symbol *) fn1p;
+  fn2 = (const struct minimal_symbol *) fn2p;
+
+  if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
+    {
+      return (-1);	/* addr 1 is less than addr 2 */
+    }
+  else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
+    {
+      return (1);	/* addr 1 is greater than addr 2 */
+    }
+  else			/* addrs are equal: sort by name */
+    {
+      char *name1 = SYMBOL_NAME (fn1);
+      char *name2 = SYMBOL_NAME (fn2);
+
+      if (name1 && name2)	/* both have names */
+	return strcmp (name1, name2);
+      else if (name2)
+	return 1;	/* fn1 has no name, so it is "less" */
+      else if (name1)	/* fn2 has no name, so it is "less" */
+	return -1;
+      else
+	return (0);	/* neither has a name, so they're equal. */
+    }
+}
+
+/* Discard the currently collected minimal symbols, if any.  If we wish
+   to save them for later use, we must have already copied them somewhere
+   else before calling this function.
+
+   FIXME:  We could allocate the minimal symbol bunches on their own
+   obstack and then simply blow the obstack away when we are done with
+   it.  Is it worth the extra trouble though? */
+
+/* ARGSUSED */
+void
+discard_minimal_symbols (foo)
+     int foo;
+{
+  register struct msym_bunch *next;
+
+  while (msym_bunch != NULL)
+    {
+      next = msym_bunch -> next;
+      free ((PTR)msym_bunch);
+      msym_bunch = next;
+    }
+}
+
+/* Compact duplicate entries out of a minimal symbol table by walking
+   through the table and compacting out entries with duplicate addresses
+   and matching names.  Return the number of entries remaining.
+
+   On entry, the table resides between msymbol[0] and msymbol[mcount].
+   On exit, it resides between msymbol[0] and msymbol[result_count].
+
+   When files contain multiple sources of symbol information, it is
+   possible for the minimal symbol table to contain many duplicate entries.
+   As an example, SVR4 systems use ELF formatted object files, which
+   usually contain at least two different types of symbol tables (a
+   standard ELF one and a smaller dynamic linking table), as well as
+   DWARF debugging information for files compiled with -g.
+
+   Without compacting, the minimal symbol table for gdb itself contains
+   over a 1000 duplicates, about a third of the total table size.  Aside
+   from the potential trap of not noticing that two successive entries
+   identify the same location, this duplication impacts the time required
+   to linearly scan the table, which is done in a number of places.  So we
+   just do one linear scan here and toss out the duplicates.
+
+   Note that we are not concerned here about recovering the space that
+   is potentially freed up, because the strings themselves are allocated
+   on the symbol_obstack, and will get automatically freed when the symbol
+   table is freed.  The caller can free up the unused minimal symbols at
+   the end of the compacted region if their allocation strategy allows it.
+
+   Also note we only go up to the next to last entry within the loop
+   and then copy the last entry explicitly after the loop terminates.
+
+   Since the different sources of information for each symbol may
+   have different levels of "completeness", we may have duplicates
+   that have one entry with type "mst_unknown" and the other with a
+   known type.  So if the one we are leaving alone has type mst_unknown,
+   overwrite its type with the type from the one we are compacting out.  */
+
+static int
+compact_minimal_symbols (msymbol, mcount)
+     struct minimal_symbol *msymbol;
+     int mcount;
+{
+  struct minimal_symbol *copyfrom;
+  struct minimal_symbol *copyto;
+
+  if (mcount > 0)
+    {
+      copyfrom = copyto = msymbol;
+      while (copyfrom < msymbol + mcount - 1)
+	{
+	  if (SYMBOL_VALUE_ADDRESS (copyfrom) == 
+	      SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) &&
+	      (STREQ (SYMBOL_NAME (copyfrom), SYMBOL_NAME ((copyfrom + 1)))))
+	    {
+	      if (MSYMBOL_TYPE((copyfrom + 1)) == mst_unknown)
+		{
+		  MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
+		}
+	      copyfrom++;
+	    }
+	  else
+	    {
+	      *copyto++ = *copyfrom++;
+	    }
+	}
+      *copyto++ = *copyfrom++;
+      mcount = copyto - msymbol;
+    }
+  return (mcount);
+}
+
+/* Add the minimal symbols in the existing bunches to the objfile's official
+   minimal symbol table.  In most cases there is no minimal symbol table yet
+   for this objfile, and the existing bunches are used to create one.  Once
+   in a while (for shared libraries for example), we add symbols (e.g. common
+   symbols) to an existing objfile.
+
+   Because of the way minimal symbols are collected, we generally have no way
+   of knowing what source language applies to any particular minimal symbol.
+   Specifically, we have no way of knowing if the minimal symbol comes from a
+   C++ compilation unit or not.  So for the sake of supporting cached
+   demangled C++ names, we have no choice but to try and demangle each new one
+   that comes in.  If the demangling succeeds, then we assume it is a C++
+   symbol and set the symbol's language and demangled name fields
+   appropriately.  Note that in order to avoid unnecessary demanglings, and
+   allocating obstack space that subsequently can't be freed for the demangled
+   names, we mark all newly added symbols with language_auto.  After
+   compaction of the minimal symbols, we go back and scan the entire minimal
+   symbol table looking for these new symbols.  For each new symbol we attempt
+   to demangle it, and if successful, record it as a language_cplus symbol
+   and cache the demangled form on the symbol obstack.  Symbols which don't
+   demangle are marked as language_unknown symbols, which inhibits future
+   attempts to demangle them if we later add more minimal symbols. */
+
+void
+install_minimal_symbols (objfile)
+     struct objfile *objfile;
+{
+  register int bindex;
+  register int mcount;
+  register struct msym_bunch *bunch;
+  register struct minimal_symbol *msymbols;
+  int alloc_count;
+  register char leading_char;
+
+  if (msym_count > 0)
+    {
+      /* Allocate enough space in the obstack, into which we will gather the
+	 bunches of new and existing minimal symbols, sort them, and then
+	 compact out the duplicate entries.  Once we have a final table,
+	 we will give back the excess space.  */
+
+      alloc_count = msym_count + objfile->minimal_symbol_count + 1;
+      obstack_blank (&objfile->symbol_obstack,
+		     alloc_count * sizeof (struct minimal_symbol));
+      msymbols = (struct minimal_symbol *)
+		 obstack_base (&objfile->symbol_obstack);
+
+      /* Copy in the existing minimal symbols, if there are any.  */
+
+      if (objfile->minimal_symbol_count)
+        memcpy ((char *)msymbols, (char *)objfile->msymbols, 
+		objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
+
+      /* Walk through the list of minimal symbol bunches, adding each symbol
+	 to the new contiguous array of symbols.  Note that we start with the
+	 current, possibly partially filled bunch (thus we use the current
+	 msym_bunch_index for the first bunch we copy over), and thereafter
+	 each bunch is full. */
+      
+      mcount = objfile->minimal_symbol_count;
+      leading_char = get_symbol_leading_char (objfile->obfd);
+      
+      for (bunch = msym_bunch; bunch != NULL; bunch = bunch -> next)
+	{
+	  for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
+	    {
+	      msymbols[mcount] = bunch -> contents[bindex];
+	      SYMBOL_LANGUAGE (&msymbols[mcount]) = language_auto;
+	      if (SYMBOL_NAME (&msymbols[mcount])[0] == leading_char)
+		{
+		  SYMBOL_NAME(&msymbols[mcount])++;
+		}
+	    }
+	  msym_bunch_index = BUNCH_SIZE;
+	}
+
+      /* Sort the minimal symbols by address.  */
+      
+      qsort (msymbols, mcount, sizeof (struct minimal_symbol),
+	     compare_minimal_symbols);
+      
+      /* Compact out any duplicates, and free up whatever space we are
+	 no longer using.  */
+      
+      mcount = compact_minimal_symbols (msymbols, mcount);
+
+      obstack_blank (&objfile->symbol_obstack,
+	(mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
+      msymbols = (struct minimal_symbol *)
+	obstack_finish (&objfile->symbol_obstack);
+
+      /* We also terminate the minimal symbol table with a "null symbol",
+	 which is *not* included in the size of the table.  This makes it
+	 easier to find the end of the table when we are handed a pointer
+	 to some symbol in the middle of it.  Zero out the fields in the
+	 "null symbol" allocated at the end of the array.  Note that the
+	 symbol count does *not* include this null symbol, which is why it
+	 is indexed by mcount and not mcount-1. */
+
+      SYMBOL_NAME (&msymbols[mcount]) = NULL;
+      SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
+      MSYMBOL_INFO (&msymbols[mcount]) = NULL;
+      MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
+      SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols[mcount], language_unknown);
+
+      /* Attach the minimal symbol table to the specified objfile.
+	 The strings themselves are also located in the symbol_obstack
+	 of this objfile.  */
+
+      objfile -> minimal_symbol_count = mcount;
+      objfile -> msymbols = msymbols;
+
+      /* Now walk through all the minimal symbols, selecting the newly added
+	 ones and attempting to cache their C++ demangled names. */
+
+      for ( ; mcount-- > 0 ; msymbols++)
+	{
+	  SYMBOL_INIT_DEMANGLED_NAME (msymbols, &objfile->symbol_obstack);
+	}
+    }
+}
+
+/* Sort all the minimal symbols in OBJFILE.  */
+
+void
+msymbols_sort (objfile)
+     struct objfile *objfile;
+{
+  qsort (objfile->msymbols, objfile->minimal_symbol_count,
+	 sizeof (struct minimal_symbol), compare_minimal_symbols);
+}
+
+/* Check if PC is in a shared library trampoline code stub.
+   Return minimal symbol for the trampoline entry or NULL if PC is not
+   in a trampoline code stub.  */
+
+struct minimal_symbol *
+lookup_solib_trampoline_symbol_by_pc (pc)
+     CORE_ADDR pc;
+{
+  struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
+
+  if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
+    return msymbol;
+  return NULL;
+}
+
+/* If PC is in a shared library trampoline code stub, return the
+   address of the `real' function belonging to the stub.
+   Return 0 if PC is not in a trampoline code stub or if the real
+   function is not found in the minimal symbol table.
+
+   We may fail to find the right function if a function with the
+   same name is defined in more than one shared library, but this
+   is considered bad programming style. We could return 0 if we find
+   a duplicate function in case this matters someday.  */
+
+CORE_ADDR
+find_solib_trampoline_target (pc)
+     CORE_ADDR pc;
+{
+  struct objfile *objfile;
+  struct minimal_symbol *msymbol;
+  struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
+
+  if (tsymbol != NULL)
+    {
+      ALL_MSYMBOLS (objfile, msymbol)
+	{
+	  if (MSYMBOL_TYPE (msymbol) == mst_text
+	      && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (tsymbol)))
+	    return SYMBOL_VALUE_ADDRESS (msymbol);
+	}
+    }
+  return 0;
+}
+