gdb/minsyms.c

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