gdb/minsyms.c

   1 /* GDB routines for manipulating the minimal symbol tables.
   2    Copyright 1992, 93, 94, 96, 97, 1998 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* This file contains support routines for creating, manipulating, and
  24    destroying minimal symbol tables.
  25
  26    Minimal symbol tables are used to hold some very basic information about
  27    all defined global symbols (text, data, bss, abs, etc).  The only two
  28    required pieces of information are the symbol's name and the address
  29    associated with that symbol.
  30
  31    In many cases, even if a file was compiled with no special options for
  32    debugging at all, as long as was not stripped it will contain sufficient
  33    information to build useful minimal symbol tables using this structure.
  34
  35    Even when a file contains enough debugging information to build a full
  36    symbol table, these minimal symbols are still useful for quickly mapping
  37    between names and addresses, and vice versa.  They are also sometimes used
  38    to figure out what full symbol table entries need to be read in. */
  39
  40
  41 #include "defs.h"
  42 #include <ctype.h>
  43 #include "gdb_string.h"
  44 #include "symtab.h"
  45 #include "bfd.h"
  46 #include "symfile.h"
  47 #include "objfiles.h"
  48 #include "demangle.h"
  49 #include "gdb-stabs.h"
  50
  51 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
  52    At the end, copy them all into one newly allocated location on an objfile's
  53    symbol obstack.  */
  54
  55 #define BUNCH_SIZE 127
  56
  57 struct msym_bunch
  58   {
  59     struct msym_bunch *next;
  60     struct minimal_symbol contents[BUNCH_SIZE];
  61   };
  62
  63 /* Bunch currently being filled up.
  64    The next field points to chain of filled bunches.  */
  65
  66 static struct msym_bunch *msym_bunch;
  67
  68 /* Number of slots filled in current bunch.  */
  69
  70 static int msym_bunch_index;
  71
  72 /* Total number of minimal symbols recorded so far for the objfile.  */
  73
  74 static int msym_count;
  75
  76 /* Prototypes for local functions. */
  77
  78 static int
  79 compare_minimal_symbols PARAMS ((const void *, const void *));
  80
  81 static int
  82 compact_minimal_symbols PARAMS ((struct minimal_symbol *, int,
  83                                  struct objfile *));
  84
  85 static void add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
  86                                                 struct minimal_symbol **table);
  87
  88 /* Compute a hash code based using the same criteria as `strcmp_iw'.  */
  89
  90 unsigned int
  91 msymbol_hash_iw (const char *string)
  92 {
  93   unsigned int hash = 0;
  94   while (*string && *string != '(')
  95     {
  96       while (isspace (*string))
  97         ++string;
  98       if (*string && *string != '(')
  99         hash = (31 * hash) + *string;
 100       ++string;
 101     }
 102   return hash % MINIMAL_SYMBOL_HASH_SIZE;
 103 }
 104
 105 /* Compute a hash code for a string.  */
 106
 107 unsigned int
 108 msymbol_hash (const char *string)
 109 {
 110   unsigned int hash = 0;
 111   for (; *string; ++string)
 112     hash = (31 * hash) + *string;
 113   return hash % MINIMAL_SYMBOL_HASH_SIZE;
 114 }
 115
 116 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE.  */
 117 void
 118 add_minsym_to_hash_table (struct minimal_symbol *sym,
 119                           struct minimal_symbol **table)
 120 {
 121   if (sym->hash_next == NULL)
 122     {
 123       unsigned int hash = msymbol_hash (SYMBOL_NAME (sym));
 124       sym->hash_next = table[hash];
 125       table[hash] = sym;
 126     }
 127 }
 128
 129 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
 130    TABLE.  */
 131 static void
 132 add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
 133                                   struct minimal_symbol **table)
 134 {
 135   if (sym->demangled_hash_next == NULL)
 136     {
 137       unsigned int hash = msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym));
 138       sym->demangled_hash_next = table[hash];
 139       table[hash] = sym;
 140     }
 141 }
 142
 143
 144 /* Look through all the current minimal symbol tables and find the
 145    first minimal symbol that matches NAME.  If OBJF is non-NULL, limit
 146    the search to that objfile.  If SFILE is non-NULL, limit the search
 147    to that source file.  Returns a pointer to the minimal symbol that
 148    matches, or NULL if no match is found.
 149
 150    Note:  One instance where there may be duplicate minimal symbols with
 151    the same name is when the symbol tables for a shared library and the
 152    symbol tables for an executable contain global symbols with the same
 153    names (the dynamic linker deals with the duplication). */
 154
 155 struct minimal_symbol *
 156 lookup_minimal_symbol (name, sfile, objf)
 157      register const char *name;
 158      const char *sfile;
 159      struct objfile *objf;
 160 {
 161   struct objfile *objfile;
 162   struct minimal_symbol *msymbol;
 163   struct minimal_symbol *found_symbol = NULL;
 164   struct minimal_symbol *found_file_symbol = NULL;
 165   struct minimal_symbol *trampoline_symbol = NULL;
 166
 167   unsigned int hash = msymbol_hash (name);
 168   unsigned int dem_hash = msymbol_hash_iw (name);
 169
 170 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 171   if (sfile != NULL)
 172     {
 173       char *p = strrchr (sfile, '/');
 174       if (p != NULL)
 175         sfile = p + 1;
 176     }
 177 #endif
 178
 179   for (objfile = object_files;
 180        objfile != NULL && found_symbol == NULL;
 181        objfile = objfile->next)
 182     {
 183       if (objf == NULL || objf == objfile)
 184         {
 185           /* Do two passes: the first over the ordinary hash table,
 186              and the second over the demangled hash table.  */
 187         int pass;
 188
 189         for (pass = 1; pass <= 2 && found_symbol == NULL; pass++)
 190             {
 191             /* Select hash list according to pass.  */
 192             if (pass == 1)
 193               msymbol = objfile->msymbol_hash[hash];
 194             else
 195               msymbol = objfile->msymbol_demangled_hash[dem_hash];
 196
 197             while (msymbol != NULL && found_symbol == NULL)
 198                 {
 199                 if (SYMBOL_MATCHES_NAME (msymbol, name))
 200                     {
 201                     switch (MSYMBOL_TYPE (msymbol))
 202                       {
 203                       case mst_file_text:
 204                       case mst_file_data:
 205                       case mst_file_bss:
 206 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 207                         if (sfile == NULL || STREQ (msymbol->filename, sfile))
 208                           found_file_symbol = msymbol;
 209 #else
 210                         /* We have neither the ability nor the need to
 211                            deal with the SFILE parameter.  If we find
 212                            more than one symbol, just return the latest
 213                            one (the user can't expect useful behavior in
 214                            that case).  */
 215                         found_file_symbol = msymbol;
 216 #endif
 217                         break;
 218
 219                       case mst_solib_trampoline:
 220
 221                         /* If a trampoline symbol is found, we prefer to
 222                            keep looking for the *real* symbol. If the
 223                            actual symbol is not found, then we'll use the
 224                            trampoline entry. */
 225                         if (trampoline_symbol == NULL)
 226                           trampoline_symbol = msymbol;
 227                         break;
 228
 229                       case mst_unknown:
 230                       default:
 231                         found_symbol = msymbol;
 232                         break;
 233                       }
 234                     }
 235
 236                 /* Find the next symbol on the hash chain.  */
 237                 if (pass == 1)
 238                   msymbol = msymbol->hash_next;
 239                 else
 240                   msymbol = msymbol->demangled_hash_next;
 241                 }
 242             }
 243         }
 244     }
 245   /* External symbols are best.  */
 246   if (found_symbol)
 247     return found_symbol;
 248
 249   /* File-local symbols are next best.  */
 250   if (found_file_symbol)
 251     return found_file_symbol;
 252
 253   /* Symbols for shared library trampolines are next best.  */
 254   if (trampoline_symbol)
 255     return trampoline_symbol;
 256
 257   return NULL;
 258 }
 259
 260 /* Look through all the current minimal symbol tables and find the
 261    first minimal symbol that matches NAME and of text type.
 262    If OBJF is non-NULL, limit
 263    the search to that objfile.  If SFILE is non-NULL, limit the search
 264    to that source file.  Returns a pointer to the minimal symbol that
 265    matches, or NULL if no match is found.
 266  */
 267
 268 struct minimal_symbol *
 269 lookup_minimal_symbol_text (name, sfile, objf)
 270      register const char *name;
 271      const char *sfile;
 272      struct objfile *objf;
 273 {
 274   struct objfile *objfile;
 275   struct minimal_symbol *msymbol;
 276   struct minimal_symbol *found_symbol = NULL;
 277   struct minimal_symbol *found_file_symbol = NULL;
 278
 279 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 280   if (sfile != NULL)
 281     {
 282       char *p = strrchr (sfile, '/');
 283       if (p != NULL)
 284         sfile = p + 1;
 285     }
 286 #endif
 287
 288   for (objfile = object_files;
 289        objfile != NULL && found_symbol == NULL;
 290        objfile = objfile->next)
 291     {
 292       if (objf == NULL || objf == objfile)
 293         {
 294           for (msymbol = objfile->msymbols;
 295                msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
 296                found_symbol == NULL;
 297                msymbol++)
 298             {
 299               if (SYMBOL_MATCHES_NAME (msymbol, name) &&
 300                   (MSYMBOL_TYPE (msymbol) == mst_text ||
 301                    MSYMBOL_TYPE (msymbol) == mst_file_text))
 302                 {
 303                   switch (MSYMBOL_TYPE (msymbol))
 304                     {
 305                     case mst_file_text:
 306 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 307                       if (sfile == NULL || STREQ (msymbol->filename, sfile))
 308                         found_file_symbol = msymbol;
 309 #else
 310                       /* We have neither the ability nor the need to
 311                          deal with the SFILE parameter.  If we find
 312                          more than one symbol, just return the latest
 313                          one (the user can't expect useful behavior in
 314                          that case).  */
 315                       found_file_symbol = msymbol;
 316 #endif
 317                       break;
 318                     default:
 319                       found_symbol = msymbol;
 320                       break;
 321                     }
 322                 }
 323             }
 324         }
 325     }
 326   /* External symbols are best.  */
 327   if (found_symbol)
 328     return found_symbol;
 329
 330   /* File-local symbols are next best.  */
 331   if (found_file_symbol)
 332     return found_file_symbol;
 333
 334   return NULL;
 335 }
 336
 337 /* Look through all the current minimal symbol tables and find the
 338    first minimal symbol that matches NAME and of solib trampoline type.
 339    If OBJF is non-NULL, limit
 340    the search to that objfile.  If SFILE is non-NULL, limit the search
 341    to that source file.  Returns a pointer to the minimal symbol that
 342    matches, or NULL if no match is found.
 343  */
 344
 345 struct minimal_symbol *
 346 lookup_minimal_symbol_solib_trampoline (name, sfile, objf)
 347      register const char *name;
 348      const char *sfile;
 349      struct objfile *objf;
 350 {
 351   struct objfile *objfile;
 352   struct minimal_symbol *msymbol;
 353   struct minimal_symbol *found_symbol = NULL;
 354
 355 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 356   if (sfile != NULL)
 357     {
 358       char *p = strrchr (sfile, '/');
 359       if (p != NULL)
 360         sfile = p + 1;
 361     }
 362 #endif
 363
 364   for (objfile = object_files;
 365        objfile != NULL && found_symbol == NULL;
 366        objfile = objfile->next)
 367     {
 368       if (objf == NULL || objf == objfile)
 369         {
 370           for (msymbol = objfile->msymbols;
 371                msymbol != NULL && SYMBOL_NAME (msymbol) != NULL &&
 372                found_symbol == NULL;
 373                msymbol++)
 374             {
 375               if (SYMBOL_MATCHES_NAME (msymbol, name) &&
 376                   MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
 377                 return msymbol;
 378             }
 379         }
 380     }
 381
 382   return NULL;
 383 }
 384
 385
 386 /* Search through the minimal symbol table for each objfile and find
 387    the symbol whose address is the largest address that is still less
 388    than or equal to PC, and matches SECTION (if non-null).  Returns a
 389    pointer to the minimal symbol if such a symbol is found, or NULL if
 390    PC is not in a suitable range.  Note that we need to look through
 391    ALL the minimal symbol tables before deciding on the symbol that
 392    comes closest to the specified PC.  This is because objfiles can
 393    overlap, for example objfile A has .text at 0x100 and .data at
 394    0x40000 and objfile B has .text at 0x234 and .data at 0x40048.  */
 395
 396 struct minimal_symbol *
 397 lookup_minimal_symbol_by_pc_section (pc, section)
 398      CORE_ADDR pc;
 399      asection *section;
 400 {
 401   int lo;
 402   int hi;
 403   int new;
 404   struct objfile *objfile;
 405   struct minimal_symbol *msymbol;
 406   struct minimal_symbol *best_symbol = NULL;
 407
 408   /* pc has to be in a known section. This ensures that anything beyond
 409      the end of the last segment doesn't appear to be part of the last
 410      function in the last segment.  */
 411   if (find_pc_section (pc) == NULL)
 412     return NULL;
 413
 414   for (objfile = object_files;
 415        objfile != NULL;
 416        objfile = objfile->next)
 417     {
 418       /* If this objfile has a minimal symbol table, go search it using
 419          a binary search.  Note that a minimal symbol table always consists
 420          of at least two symbols, a "real" symbol and the terminating
 421          "null symbol".  If there are no real symbols, then there is no
 422          minimal symbol table at all. */
 423
 424       if ((msymbol = objfile->msymbols) != NULL)
 425         {
 426           lo = 0;
 427           hi = objfile->minimal_symbol_count - 1;
 428
 429           /* This code assumes that the minimal symbols are sorted by
 430              ascending address values.  If the pc value is greater than or
 431              equal to the first symbol's address, then some symbol in this
 432              minimal symbol table is a suitable candidate for being the
 433              "best" symbol.  This includes the last real symbol, for cases
 434              where the pc value is larger than any address in this vector.
 435
 436              By iterating until the address associated with the current
 437              hi index (the endpoint of the test interval) is less than
 438              or equal to the desired pc value, we accomplish two things:
 439              (1) the case where the pc value is larger than any minimal
 440              symbol address is trivially solved, (2) the address associated
 441              with the hi index is always the one we want when the interation
 442              terminates.  In essence, we are iterating the test interval
 443              down until the pc value is pushed out of it from the high end.
 444
 445              Warning: this code is trickier than it would appear at first. */
 446
 447           /* Should also require that pc is <= end of objfile.  FIXME! */
 448           if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
 449             {
 450               while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
 451                 {
 452                   /* pc is still strictly less than highest address */
 453                   /* Note "new" will always be >= lo */
 454                   new = (lo + hi) / 2;
 455                   if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
 456                       (lo == new))
 457                     {
 458                       hi = new;
 459                     }
 460                   else
 461                     {
 462                       lo = new;
 463                     }
 464                 }
 465
 466               /* If we have multiple symbols at the same address, we want
 467                  hi to point to the last one.  That way we can find the
 468                  right symbol if it has an index greater than hi.  */
 469               while (hi < objfile->minimal_symbol_count - 1
 470                      && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
 471                          == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
 472                 hi++;
 473
 474               /* The minimal symbol indexed by hi now is the best one in this
 475                  objfile's minimal symbol table.  See if it is the best one
 476                  overall. */
 477
 478               /* Skip any absolute symbols.  This is apparently what adb
 479                  and dbx do, and is needed for the CM-5.  There are two
 480                  known possible problems: (1) on ELF, apparently end, edata,
 481                  etc. are absolute.  Not sure ignoring them here is a big
 482                  deal, but if we want to use them, the fix would go in
 483                  elfread.c.  (2) I think shared library entry points on the
 484                  NeXT are absolute.  If we want special handling for this
 485                  it probably should be triggered by a special
 486                  mst_abs_or_lib or some such.  */
 487               while (hi >= 0
 488                      && msymbol[hi].type == mst_abs)
 489                 --hi;
 490
 491               /* If "section" specified, skip any symbol from wrong section */
 492               /* This is the new code that distinguishes it from the old function */
 493               if (section)
 494                 while (hi >= 0
 495                        && SYMBOL_BFD_SECTION (&msymbol[hi]) != section)
 496                   --hi;
 497
 498               if (hi >= 0
 499                   && ((best_symbol == NULL) ||
 500                       (SYMBOL_VALUE_ADDRESS (best_symbol) <
 501                        SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
 502                 {
 503                   best_symbol = &msymbol[hi];
 504                 }
 505             }
 506         }
 507     }
 508   return (best_symbol);
 509 }
 510
 511 /* Backward compatibility: search through the minimal symbol table
 512    for a matching PC (no section given) */
 513
 514 struct minimal_symbol *
 515 lookup_minimal_symbol_by_pc (pc)
 516      CORE_ADDR pc;
 517 {
 518   return lookup_minimal_symbol_by_pc_section (pc, find_pc_mapped_section (pc));
 519 }
 520
 521 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 522 CORE_ADDR
 523 find_stab_function_addr (namestring, filename, objfile)
 524      char *namestring;
 525      char *filename;
 526      struct objfile *objfile;
 527 {
 528   struct minimal_symbol *msym;
 529   char *p;
 530   int n;
 531
 532   p = strchr (namestring, ':');
 533   if (p == NULL)
 534     p = namestring;
 535   n = p - namestring;
 536   p = alloca (n + 2);
 537   strncpy (p, namestring, n);
 538   p[n] = 0;
 539
 540   msym = lookup_minimal_symbol (p, filename, objfile);
 541   if (msym == NULL)
 542     {
 543       /* Sun Fortran appends an underscore to the minimal symbol name,
 544          try again with an appended underscore if the minimal symbol
 545          was not found.  */
 546       p[n] = '_';
 547       p[n + 1] = 0;
 548       msym = lookup_minimal_symbol (p, filename, objfile);
 549     }
 550
 551   if (msym == NULL && filename != NULL)
 552     {
 553       /* Try again without the filename. */
 554       p[n] = 0;
 555       msym = lookup_minimal_symbol (p, 0, objfile);
 556     }
 557   if (msym == NULL && filename != NULL)
 558     {
 559       /* And try again for Sun Fortran, but without the filename. */
 560       p[n] = '_';
 561       p[n + 1] = 0;
 562       msym = lookup_minimal_symbol (p, 0, objfile);
 563     }
 564
 565   return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
 566 }
 567 #endif /* SOFUN_ADDRESS_MAYBE_MISSING */
 568 \f
 569
 570 /* Return leading symbol character for a BFD. If BFD is NULL,
 571    return the leading symbol character from the main objfile.  */
 572
 573 static int get_symbol_leading_char PARAMS ((bfd *));
 574
 575 static int
 576 get_symbol_leading_char (abfd)
 577      bfd *abfd;
 578 {
 579   if (abfd != NULL)
 580     return bfd_get_symbol_leading_char (abfd);
 581   if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
 582     return bfd_get_symbol_leading_char (symfile_objfile->obfd);
 583   return 0;
 584 }
 585
 586 /* Prepare to start collecting minimal symbols.  Note that presetting
 587    msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
 588    symbol to allocate the memory for the first bunch. */
 589
 590 void
 591 init_minimal_symbol_collection ()
 592 {
 593   msym_count = 0;
 594   msym_bunch = NULL;
 595   msym_bunch_index = BUNCH_SIZE;
 596 }
 597
 598 void
 599 prim_record_minimal_symbol (name, address, ms_type, objfile)
 600      const char *name;
 601      CORE_ADDR address;
 602      enum minimal_symbol_type ms_type;
 603      struct objfile *objfile;
 604 {
 605   int section;
 606
 607   switch (ms_type)
 608     {
 609     case mst_text:
 610     case mst_file_text:
 611     case mst_solib_trampoline:
 612       section = SECT_OFF_TEXT (objfile);
 613       break;
 614     case mst_data:
 615     case mst_file_data:
 616       section = SECT_OFF_DATA (objfile);
 617       break;
 618     case mst_bss:
 619     case mst_file_bss:
 620       section = SECT_OFF_BSS (objfile);
 621       break;
 622     default:
 623       section = -1;
 624     }
 625
 626   prim_record_minimal_symbol_and_info (name, address, ms_type,
 627                                        NULL, section, NULL, objfile);
 628 }
 629
 630 /* Record a minimal symbol in the msym bunches.  Returns the symbol
 631    newly created.  */
 632
 633 struct minimal_symbol *
 634 prim_record_minimal_symbol_and_info (name, address, ms_type, info, section,
 635                                      bfd_section, objfile)
 636      const char *name;
 637      CORE_ADDR address;
 638      enum minimal_symbol_type ms_type;
 639      char *info;
 640      int section;
 641      asection *bfd_section;
 642      struct objfile *objfile;
 643 {
 644   register struct msym_bunch *new;
 645   register struct minimal_symbol *msymbol;
 646
 647   if (ms_type == mst_file_text)
 648     {
 649       /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
 650          the minimal symbols, because if there is also another symbol
 651          at the same address (e.g. the first function of the file),
 652          lookup_minimal_symbol_by_pc would have no way of getting the
 653          right one.  */
 654       if (name[0] == 'g'
 655           && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
 656               || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
 657         return (NULL);
 658
 659       {
 660         const char *tempstring = name;
 661         if (tempstring[0] == get_symbol_leading_char (objfile->obfd))
 662           ++tempstring;
 663         if (STREQN (tempstring, "__gnu_compiled", 14))
 664           return (NULL);
 665       }
 666     }
 667
 668   if (msym_bunch_index == BUNCH_SIZE)
 669     {
 670       new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch));
 671       msym_bunch_index = 0;
 672       new->next = msym_bunch;
 673       msym_bunch = new;
 674     }
 675   msymbol = &msym_bunch->contents[msym_bunch_index];
 676   SYMBOL_NAME (msymbol) = obsavestring ((char *) name, strlen (name),
 677                                         &objfile->symbol_obstack);
 678   SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
 679   SYMBOL_VALUE_ADDRESS (msymbol) = address;
 680   SYMBOL_SECTION (msymbol) = section;
 681   SYMBOL_BFD_SECTION (msymbol) = bfd_section;
 682
 683   MSYMBOL_TYPE (msymbol) = ms_type;
 684   /* FIXME:  This info, if it remains, needs its own field.  */
 685   MSYMBOL_INFO (msymbol) = info;        /* FIXME! */
 686
 687   /* The hash pointers must be cleared! If they're not,
 688      add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
 689   msymbol->hash_next = NULL;
 690   msymbol->demangled_hash_next = NULL;
 691
 692   msym_bunch_index++;
 693   msym_count++;
 694   OBJSTAT (objfile, n_minsyms++);
 695   return msymbol;
 696 }
 697
 698 /* Compare two minimal symbols by address and return a signed result based
 699    on unsigned comparisons, so that we sort into unsigned numeric order.
 700    Within groups with the same address, sort by name.  */
 701
 702 static int
 703 compare_minimal_symbols (fn1p, fn2p)
 704      const PTR fn1p;
 705      const PTR fn2p;
 706 {
 707   register const struct minimal_symbol *fn1;
 708   register const struct minimal_symbol *fn2;
 709
 710   fn1 = (const struct minimal_symbol *) fn1p;
 711   fn2 = (const struct minimal_symbol *) fn2p;
 712
 713   if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
 714     {
 715       return (-1);              /* addr 1 is less than addr 2 */
 716     }
 717   else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
 718     {
 719       return (1);               /* addr 1 is greater than addr 2 */
 720     }
 721   else
 722     /* addrs are equal: sort by name */
 723     {
 724       char *name1 = SYMBOL_NAME (fn1);
 725       char *name2 = SYMBOL_NAME (fn2);
 726
 727       if (name1 && name2)       /* both have names */
 728         return strcmp (name1, name2);
 729       else if (name2)
 730         return 1;               /* fn1 has no name, so it is "less" */
 731       else if (name1)           /* fn2 has no name, so it is "less" */
 732         return -1;
 733       else
 734         return (0);             /* neither has a name, so they're equal. */
 735     }
 736 }
 737
 738 /* Discard the currently collected minimal symbols, if any.  If we wish
 739    to save them for later use, we must have already copied them somewhere
 740    else before calling this function.
 741
 742    FIXME:  We could allocate the minimal symbol bunches on their own
 743    obstack and then simply blow the obstack away when we are done with
 744    it.  Is it worth the extra trouble though? */
 745
 746 static void
 747 do_discard_minimal_symbols_cleanup (void *arg)
 748 {
 749   register struct msym_bunch *next;
 750
 751   while (msym_bunch != NULL)
 752     {
 753       next = msym_bunch->next;
 754       free ((PTR) msym_bunch);
 755       msym_bunch = next;
 756     }
 757 }
 758
 759 struct cleanup *
 760 make_cleanup_discard_minimal_symbols (void)
 761 {
 762   return make_cleanup (do_discard_minimal_symbols_cleanup, 0);
 763 }
 764
 765
 766
 767 /* Compact duplicate entries out of a minimal symbol table by walking
 768    through the table and compacting out entries with duplicate addresses
 769    and matching names.  Return the number of entries remaining.
 770
 771    On entry, the table resides between msymbol[0] and msymbol[mcount].
 772    On exit, it resides between msymbol[0] and msymbol[result_count].
 773
 774    When files contain multiple sources of symbol information, it is
 775    possible for the minimal symbol table to contain many duplicate entries.
 776    As an example, SVR4 systems use ELF formatted object files, which
 777    usually contain at least two different types of symbol tables (a
 778    standard ELF one and a smaller dynamic linking table), as well as
 779    DWARF debugging information for files compiled with -g.
 780
 781    Without compacting, the minimal symbol table for gdb itself contains
 782    over a 1000 duplicates, about a third of the total table size.  Aside
 783    from the potential trap of not noticing that two successive entries
 784    identify the same location, this duplication impacts the time required
 785    to linearly scan the table, which is done in a number of places.  So we
 786    just do one linear scan here and toss out the duplicates.
 787
 788    Note that we are not concerned here about recovering the space that
 789    is potentially freed up, because the strings themselves are allocated
 790    on the symbol_obstack, and will get automatically freed when the symbol
 791    table is freed.  The caller can free up the unused minimal symbols at
 792    the end of the compacted region if their allocation strategy allows it.
 793
 794    Also note we only go up to the next to last entry within the loop
 795    and then copy the last entry explicitly after the loop terminates.
 796
 797    Since the different sources of information for each symbol may
 798    have different levels of "completeness", we may have duplicates
 799    that have one entry with type "mst_unknown" and the other with a
 800    known type.  So if the one we are leaving alone has type mst_unknown,
 801    overwrite its type with the type from the one we are compacting out.  */
 802
 803 static int
 804 compact_minimal_symbols (msymbol, mcount, objfile)
 805      struct minimal_symbol *msymbol;
 806      int mcount;
 807      struct objfile *objfile;
 808 {
 809   struct minimal_symbol *copyfrom;
 810   struct minimal_symbol *copyto;
 811
 812   if (mcount > 0)
 813     {
 814       copyfrom = copyto = msymbol;
 815       while (copyfrom < msymbol + mcount - 1)
 816         {
 817           if (SYMBOL_VALUE_ADDRESS (copyfrom) ==
 818               SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) &&
 819               (STREQ (SYMBOL_NAME (copyfrom), SYMBOL_NAME ((copyfrom + 1)))))
 820             {
 821               if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
 822                 {
 823                   MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
 824                 }
 825               copyfrom++;
 826             }
 827           else
 828             {
 829               *copyto++ = *copyfrom++;
 830
 831               add_minsym_to_hash_table (copyto - 1, objfile->msymbol_hash);
 832             }
 833         }
 834       *copyto++ = *copyfrom++;
 835       mcount = copyto - msymbol;
 836     }
 837   return (mcount);
 838 }
 839
 840 /* Add the minimal symbols in the existing bunches to the objfile's official
 841    minimal symbol table.  In most cases there is no minimal symbol table yet
 842    for this objfile, and the existing bunches are used to create one.  Once
 843    in a while (for shared libraries for example), we add symbols (e.g. common
 844    symbols) to an existing objfile.
 845
 846    Because of the way minimal symbols are collected, we generally have no way
 847    of knowing what source language applies to any particular minimal symbol.
 848    Specifically, we have no way of knowing if the minimal symbol comes from a
 849    C++ compilation unit or not.  So for the sake of supporting cached
 850    demangled C++ names, we have no choice but to try and demangle each new one
 851    that comes in.  If the demangling succeeds, then we assume it is a C++
 852    symbol and set the symbol's language and demangled name fields
 853    appropriately.  Note that in order to avoid unnecessary demanglings, and
 854    allocating obstack space that subsequently can't be freed for the demangled
 855    names, we mark all newly added symbols with language_auto.  After
 856    compaction of the minimal symbols, we go back and scan the entire minimal
 857    symbol table looking for these new symbols.  For each new symbol we attempt
 858    to demangle it, and if successful, record it as a language_cplus symbol
 859    and cache the demangled form on the symbol obstack.  Symbols which don't
 860    demangle are marked as language_unknown symbols, which inhibits future
 861    attempts to demangle them if we later add more minimal symbols. */
 862
 863 void
 864 install_minimal_symbols (objfile)
 865      struct objfile *objfile;
 866 {
 867   register int bindex;
 868   register int mcount;
 869   register struct msym_bunch *bunch;
 870   register struct minimal_symbol *msymbols;
 871   int alloc_count;
 872   register char leading_char;
 873
 874   if (msym_count > 0)
 875     {
 876       /* Allocate enough space in the obstack, into which we will gather the
 877          bunches of new and existing minimal symbols, sort them, and then
 878          compact out the duplicate entries.  Once we have a final table,
 879          we will give back the excess space.  */
 880
 881       alloc_count = msym_count + objfile->minimal_symbol_count + 1;
 882       obstack_blank (&objfile->symbol_obstack,
 883                      alloc_count * sizeof (struct minimal_symbol));
 884       msymbols = (struct minimal_symbol *)
 885         obstack_base (&objfile->symbol_obstack);
 886
 887       /* Copy in the existing minimal symbols, if there are any.  */
 888
 889       if (objfile->minimal_symbol_count)
 890         memcpy ((char *) msymbols, (char *) objfile->msymbols,
 891             objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
 892
 893       /* Walk through the list of minimal symbol bunches, adding each symbol
 894          to the new contiguous array of symbols.  Note that we start with the
 895          current, possibly partially filled bunch (thus we use the current
 896          msym_bunch_index for the first bunch we copy over), and thereafter
 897          each bunch is full. */
 898
 899       mcount = objfile->minimal_symbol_count;
 900       leading_char = get_symbol_leading_char (objfile->obfd);
 901
 902       for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
 903         {
 904           for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
 905             {
 906               msymbols[mcount] = bunch->contents[bindex];
 907               SYMBOL_LANGUAGE (&msymbols[mcount]) = language_auto;
 908               if (SYMBOL_NAME (&msymbols[mcount])[0] == leading_char)
 909                 {
 910                   SYMBOL_NAME (&msymbols[mcount])++;
 911                 }
 912             }
 913           msym_bunch_index = BUNCH_SIZE;
 914         }
 915
 916       /* Sort the minimal symbols by address.  */
 917
 918       qsort (msymbols, mcount, sizeof (struct minimal_symbol),
 919              compare_minimal_symbols);
 920
 921       /* Compact out any duplicates, and free up whatever space we are
 922          no longer using.  */
 923
 924       mcount = compact_minimal_symbols (msymbols, mcount, objfile);
 925
 926       obstack_blank (&objfile->symbol_obstack,
 927                (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
 928       msymbols = (struct minimal_symbol *)
 929         obstack_finish (&objfile->symbol_obstack);
 930
 931       /* We also terminate the minimal symbol table with a "null symbol",
 932          which is *not* included in the size of the table.  This makes it
 933          easier to find the end of the table when we are handed a pointer
 934          to some symbol in the middle of it.  Zero out the fields in the
 935          "null symbol" allocated at the end of the array.  Note that the
 936          symbol count does *not* include this null symbol, which is why it
 937          is indexed by mcount and not mcount-1. */
 938
 939       SYMBOL_NAME (&msymbols[mcount]) = NULL;
 940       SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
 941       MSYMBOL_INFO (&msymbols[mcount]) = NULL;
 942       MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
 943       SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols[mcount], language_unknown);
 944
 945       /* Attach the minimal symbol table to the specified objfile.
 946          The strings themselves are also located in the symbol_obstack
 947          of this objfile.  */
 948
 949       objfile->minimal_symbol_count = mcount;
 950       objfile->msymbols = msymbols;
 951
 952       /* Now walk through all the minimal symbols, selecting the newly added
 953          ones and attempting to cache their C++ demangled names. */
 954
 955       for (; mcount-- > 0; msymbols++)
 956         {
 957           SYMBOL_INIT_DEMANGLED_NAME (msymbols, &objfile->symbol_obstack);
 958           if (SYMBOL_DEMANGLED_NAME (msymbols) != NULL)
 959           add_minsym_to_demangled_hash_table (msymbols,
 960                                               objfile->msymbol_demangled_hash);
 961         }
 962     }
 963 }
 964
 965 /* Sort all the minimal symbols in OBJFILE.  */
 966
 967 void
 968 msymbols_sort (objfile)
 969      struct objfile *objfile;
 970 {
 971   qsort (objfile->msymbols, objfile->minimal_symbol_count,
 972          sizeof (struct minimal_symbol), compare_minimal_symbols);
 973 }
 974
 975 /* Check if PC is in a shared library trampoline code stub.
 976    Return minimal symbol for the trampoline entry or NULL if PC is not
 977    in a trampoline code stub.  */
 978
 979 struct minimal_symbol *
 980 lookup_solib_trampoline_symbol_by_pc (pc)
 981      CORE_ADDR pc;
 982 {
 983   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
 984
 985   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
 986     return msymbol;
 987   return NULL;
 988 }
 989
 990 /* If PC is in a shared library trampoline code stub, return the
 991    address of the `real' function belonging to the stub.
 992    Return 0 if PC is not in a trampoline code stub or if the real
 993    function is not found in the minimal symbol table.
 994
 995    We may fail to find the right function if a function with the
 996    same name is defined in more than one shared library, but this
 997    is considered bad programming style. We could return 0 if we find
 998    a duplicate function in case this matters someday.  */
 999
1000 CORE_ADDR
1001 find_solib_trampoline_target (pc)
1002      CORE_ADDR pc;
1003 {
1004   struct objfile *objfile;
1005   struct minimal_symbol *msymbol;
1006   struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1007
1008   if (tsymbol != NULL)
1009     {
1010       ALL_MSYMBOLS (objfile, msymbol)
1011       {
1012         if (MSYMBOL_TYPE (msymbol) == mst_text
1013             && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (tsymbol)))
1014           return SYMBOL_VALUE_ADDRESS (msymbol);
1015       }
1016     }
1017   return 0;
1018 }