gdb/minsyms.c

   1 /* GDB routines for manipulating the minimal symbol tables.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5    Contributed by Cygnus Support, using pieces from other GDB modules.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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 "value.h"
  50 #include "cp-abi.h"
  51 #include "target.h"
  52 #include "cp-support.h"
  53 #include "language.h"
  54
  55 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
  56    At the end, copy them all into one newly allocated location on an objfile's
  57    symbol obstack.  */
  58
  59 #define BUNCH_SIZE 127
  60
  61 struct msym_bunch
  62   {
  63     struct msym_bunch *next;
  64     struct minimal_symbol contents[BUNCH_SIZE];
  65   };
  66
  67 /* Bunch currently being filled up.
  68    The next field points to chain of filled bunches.  */
  69
  70 static struct msym_bunch *msym_bunch;
  71
  72 /* Number of slots filled in current bunch.  */
  73
  74 static int msym_bunch_index;
  75
  76 /* Total number of minimal symbols recorded so far for the objfile.  */
  77
  78 static int msym_count;
  79
  80 /* Compute a hash code based using the same criteria as `strcmp_iw'.  */
  81
  82 unsigned int
  83 msymbol_hash_iw (const char *string)
  84 {
  85   unsigned int hash = 0;
  86
  87   while (*string && *string != '(')
  88     {
  89       while (isspace (*string))
  90         ++string;
  91       if (*string && *string != '(')
  92         {
  93           hash = hash * 67 + *string - 113;
  94           ++string;
  95         }
  96     }
  97   return hash;
  98 }
  99
 100 /* Compute a hash code for a string.  */
 101
 102 unsigned int
 103 msymbol_hash (const char *string)
 104 {
 105   unsigned int hash = 0;
 106
 107   for (; *string; ++string)
 108     hash = hash * 67 + *string - 113;
 109   return hash;
 110 }
 111
 112 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE.  */
 113 void
 114 add_minsym_to_hash_table (struct minimal_symbol *sym,
 115                           struct minimal_symbol **table)
 116 {
 117   if (sym->hash_next == NULL)
 118     {
 119       unsigned int hash
 120         = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
 121
 122       sym->hash_next = table[hash];
 123       table[hash] = sym;
 124     }
 125 }
 126
 127 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
 128    TABLE.  */
 129 static void
 130 add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
 131                                   struct minimal_symbol **table)
 132 {
 133   if (sym->demangled_hash_next == NULL)
 134     {
 135       unsigned int hash = msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym))
 136         % MINIMAL_SYMBOL_HASH_SIZE;
 137
 138       sym->demangled_hash_next = table[hash];
 139       table[hash] = sym;
 140     }
 141 }
 142
 143
 144 /* Return OBJFILE where minimal symbol SYM is defined.  */
 145 struct objfile *
 146 msymbol_objfile (struct minimal_symbol *sym)
 147 {
 148   struct objfile *objf;
 149   struct minimal_symbol *tsym;
 150
 151   unsigned int hash
 152     = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
 153
 154   for (objf = object_files; objf; objf = objf->next)
 155     for (tsym = objf->msymbol_hash[hash]; tsym; tsym = tsym->hash_next)
 156       if (tsym == sym)
 157         return objf;
 158
 159   /* We should always be able to find the objfile ...  */
 160   internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 161 }
 162
 163
 164 /* Look through all the current minimal symbol tables and find the
 165    first minimal symbol that matches NAME.  If OBJF is non-NULL, limit
 166    the search to that objfile.  If SFILE is non-NULL, the only file-scope
 167    symbols considered will be from that source file (global symbols are
 168    still preferred).  Returns a pointer to the minimal symbol that
 169    matches, or NULL if no match is found.
 170
 171    Note:  One instance where there may be duplicate minimal symbols with
 172    the same name is when the symbol tables for a shared library and the
 173    symbol tables for an executable contain global symbols with the same
 174    names (the dynamic linker deals with the duplication).
 175
 176    It's also possible to have minimal symbols with different mangled
 177    names, but identical demangled names.  For example, the GNU C++ v3
 178    ABI requires the generation of two (or perhaps three) copies of
 179    constructor functions --- "in-charge", "not-in-charge", and
 180    "allocate" copies; destructors may be duplicated as well.
 181    Obviously, there must be distinct mangled names for each of these,
 182    but the demangled names are all the same: S::S or S::~S.  */
 183
 184 struct minimal_symbol *
 185 lookup_minimal_symbol (const char *name, const char *sfile,
 186                        struct objfile *objf)
 187 {
 188   struct objfile *objfile;
 189   struct minimal_symbol *msymbol;
 190   struct minimal_symbol *found_symbol = NULL;
 191   struct minimal_symbol *found_file_symbol = NULL;
 192   struct minimal_symbol *trampoline_symbol = NULL;
 193
 194   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 195   unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
 196
 197   int needtofreename = 0;
 198   const char *modified_name;
 199
 200   if (sfile != NULL)
 201     sfile = lbasename (sfile);
 202
 203   /* For C++, canonicalize the input name.  */
 204   modified_name = name;
 205   if (current_language->la_language == language_cplus)
 206     {
 207       char *cname = cp_canonicalize_string (name);
 208
 209       if (cname)
 210         {
 211           modified_name = cname;
 212           needtofreename = 1;
 213         }
 214     }
 215
 216   for (objfile = object_files;
 217        objfile != NULL && found_symbol == NULL;
 218        objfile = objfile->next)
 219     {
 220       if (objf == NULL || objf == objfile
 221           || objf == objfile->separate_debug_objfile_backlink)
 222         {
 223           /* Do two passes: the first over the ordinary hash table,
 224              and the second over the demangled hash table.  */
 225         int pass;
 226
 227         for (pass = 1; pass <= 2 && found_symbol == NULL; pass++)
 228             {
 229             /* Select hash list according to pass.  */
 230             if (pass == 1)
 231               msymbol = objfile->msymbol_hash[hash];
 232             else
 233               msymbol = objfile->msymbol_demangled_hash[dem_hash];
 234
 235             while (msymbol != NULL && found_symbol == NULL)
 236                 {
 237                   int match;
 238
 239                   if (pass == 1)
 240                     {
 241                       match = strcmp (SYMBOL_LINKAGE_NAME (msymbol),
 242                                       modified_name) == 0;
 243                     }
 244                   else
 245                     {
 246                       match = SYMBOL_MATCHES_SEARCH_NAME (msymbol,
 247                                                           modified_name);
 248                     }
 249
 250                   if (match)
 251                     {
 252                     switch (MSYMBOL_TYPE (msymbol))
 253                       {
 254                       case mst_file_text:
 255                       case mst_file_data:
 256                       case mst_file_bss:
 257                         if (sfile == NULL
 258                             || strcmp (msymbol->filename, sfile) == 0)
 259                           found_file_symbol = msymbol;
 260                         break;
 261
 262                       case mst_solib_trampoline:
 263
 264                         /* If a trampoline symbol is found, we prefer to
 265                            keep looking for the *real* symbol.  If the
 266                            actual symbol is not found, then we'll use the
 267                            trampoline entry.  */
 268                         if (trampoline_symbol == NULL)
 269                           trampoline_symbol = msymbol;
 270                         break;
 271
 272                       case mst_unknown:
 273                       default:
 274                         found_symbol = msymbol;
 275                         break;
 276                       }
 277                     }
 278
 279                 /* Find the next symbol on the hash chain.  */
 280                 if (pass == 1)
 281                   msymbol = msymbol->hash_next;
 282                 else
 283                   msymbol = msymbol->demangled_hash_next;
 284                 }
 285             }
 286         }
 287     }
 288
 289   if (needtofreename)
 290     xfree ((void *) modified_name);
 291
 292   /* External symbols are best.  */
 293   if (found_symbol)
 294     return found_symbol;
 295
 296   /* File-local symbols are next best.  */
 297   if (found_file_symbol)
 298     return found_file_symbol;
 299
 300   /* Symbols for shared library trampolines are next best.  */
 301   if (trampoline_symbol)
 302     return trampoline_symbol;
 303
 304   return NULL;
 305 }
 306
 307 /* Look through all the current minimal symbol tables and find the
 308    first minimal symbol that matches NAME and has text type.  If OBJF
 309    is non-NULL, limit the search to that objfile.  Returns a pointer
 310    to the minimal symbol that matches, or NULL if no match is found.
 311
 312    This function only searches the mangled (linkage) names.  */
 313
 314 struct minimal_symbol *
 315 lookup_minimal_symbol_text (const char *name, struct objfile *objf)
 316 {
 317   struct objfile *objfile;
 318   struct minimal_symbol *msymbol;
 319   struct minimal_symbol *found_symbol = NULL;
 320   struct minimal_symbol *found_file_symbol = NULL;
 321
 322   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 323
 324   for (objfile = object_files;
 325        objfile != NULL && found_symbol == NULL;
 326        objfile = objfile->next)
 327     {
 328       if (objf == NULL || objf == objfile
 329           || objf == objfile->separate_debug_objfile_backlink)
 330         {
 331           for (msymbol = objfile->msymbol_hash[hash];
 332                msymbol != NULL && found_symbol == NULL;
 333                msymbol = msymbol->hash_next)
 334             {
 335               if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
 336                   (MSYMBOL_TYPE (msymbol) == mst_text ||
 337                    MSYMBOL_TYPE (msymbol) == mst_file_text))
 338                 {
 339                   switch (MSYMBOL_TYPE (msymbol))
 340                     {
 341                     case mst_file_text:
 342                       found_file_symbol = msymbol;
 343                       break;
 344                     default:
 345                       found_symbol = msymbol;
 346                       break;
 347                     }
 348                 }
 349             }
 350         }
 351     }
 352   /* External symbols are best.  */
 353   if (found_symbol)
 354     return found_symbol;
 355
 356   /* File-local symbols are next best.  */
 357   if (found_file_symbol)
 358     return found_file_symbol;
 359
 360   return NULL;
 361 }
 362
 363 /* Look through all the current minimal symbol tables and find the
 364    first minimal symbol that matches NAME and PC.  If OBJF is non-NULL,
 365    limit the search to that objfile.  Returns a pointer to the minimal
 366    symbol that matches, or NULL if no match is found.  */
 367
 368 struct minimal_symbol *
 369 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
 370                                   struct objfile *objf)
 371 {
 372   struct objfile *objfile;
 373   struct minimal_symbol *msymbol;
 374
 375   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 376
 377   for (objfile = object_files;
 378        objfile != NULL;
 379        objfile = objfile->next)
 380     {
 381       if (objf == NULL || objf == objfile
 382           || objf == objfile->separate_debug_objfile_backlink)
 383         {
 384           for (msymbol = objfile->msymbol_hash[hash];
 385                msymbol != NULL;
 386                msymbol = msymbol->hash_next)
 387             {
 388               if (SYMBOL_VALUE_ADDRESS (msymbol) == pc
 389                   && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0)
 390                 return msymbol;
 391             }
 392         }
 393     }
 394
 395   return NULL;
 396 }
 397
 398 /* Look through all the current minimal symbol tables and find the
 399    first minimal symbol that matches NAME and is a solib trampoline.
 400    If OBJF is non-NULL, limit the search to that objfile.  Returns a
 401    pointer to the minimal symbol that matches, or NULL if no match is
 402    found.
 403
 404    This function only searches the mangled (linkage) names.  */
 405
 406 struct minimal_symbol *
 407 lookup_minimal_symbol_solib_trampoline (const char *name,
 408                                         struct objfile *objf)
 409 {
 410   struct objfile *objfile;
 411   struct minimal_symbol *msymbol;
 412   struct minimal_symbol *found_symbol = NULL;
 413
 414   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 415
 416   for (objfile = object_files;
 417        objfile != NULL && found_symbol == NULL;
 418        objfile = objfile->next)
 419     {
 420       if (objf == NULL || objf == objfile
 421           || objf == objfile->separate_debug_objfile_backlink)
 422         {
 423           for (msymbol = objfile->msymbol_hash[hash];
 424                msymbol != NULL && found_symbol == NULL;
 425                msymbol = msymbol->hash_next)
 426             {
 427               if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
 428                   MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
 429                 return msymbol;
 430             }
 431         }
 432     }
 433
 434   return NULL;
 435 }
 436
 437 /* Search through the minimal symbol table for each objfile and find
 438    the symbol whose address is the largest address that is still less
 439    than or equal to PC, and matches SECTION (which is not NULL).
 440    Returns a pointer to the minimal symbol if such a symbol is found,
 441    or NULL if PC is not in a suitable range.
 442    Note that we need to look through ALL the minimal symbol tables
 443    before deciding on the symbol that comes closest to the specified PC.
 444    This is because objfiles can overlap, for example objfile A has .text
 445    at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
 446    .data at 0x40048.
 447
 448    If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
 449    there are text and trampoline symbols at the same address.
 450    Otherwise prefer mst_text symbols.  */
 451
 452 static struct minimal_symbol *
 453 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 454                                        struct obj_section *section,
 455                                        int want_trampoline)
 456 {
 457   int lo;
 458   int hi;
 459   int new;
 460   struct objfile *objfile;
 461   struct minimal_symbol *msymbol;
 462   struct minimal_symbol *best_symbol = NULL;
 463   enum minimal_symbol_type want_type, other_type;
 464
 465   want_type = want_trampoline ? mst_solib_trampoline : mst_text;
 466   other_type = want_trampoline ? mst_text : mst_solib_trampoline;
 467
 468   /* We can not require the symbol found to be in section, because
 469      e.g. IRIX 6.5 mdebug relies on this code returning an absolute
 470      symbol - but find_pc_section won't return an absolute section and
 471      hence the code below would skip over absolute symbols.  We can
 472      still take advantage of the call to find_pc_section, though - the
 473      object file still must match.  In case we have separate debug
 474      files, search both the file and its separate debug file.  There's
 475      no telling which one will have the minimal symbols.  */
 476
 477   gdb_assert (section != NULL);
 478
 479   for (objfile = section->objfile;
 480        objfile != NULL;
 481        objfile = objfile_separate_debug_iterate (section->objfile, objfile))
 482     {
 483       /* If this objfile has a minimal symbol table, go search it using
 484          a binary search.  Note that a minimal symbol table always consists
 485          of at least two symbols, a "real" symbol and the terminating
 486          "null symbol".  If there are no real symbols, then there is no
 487          minimal symbol table at all.  */
 488
 489       if (objfile->minimal_symbol_count > 0)
 490         {
 491           int best_zero_sized = -1;
 492
 493           msymbol = objfile->msymbols;
 494           lo = 0;
 495           hi = objfile->minimal_symbol_count - 1;
 496
 497           /* This code assumes that the minimal symbols are sorted by
 498              ascending address values.  If the pc value is greater than or
 499              equal to the first symbol's address, then some symbol in this
 500              minimal symbol table is a suitable candidate for being the
 501              "best" symbol.  This includes the last real symbol, for cases
 502              where the pc value is larger than any address in this vector.
 503
 504              By iterating until the address associated with the current
 505              hi index (the endpoint of the test interval) is less than
 506              or equal to the desired pc value, we accomplish two things:
 507              (1) the case where the pc value is larger than any minimal
 508              symbol address is trivially solved, (2) the address associated
 509              with the hi index is always the one we want when the interation
 510              terminates.  In essence, we are iterating the test interval
 511              down until the pc value is pushed out of it from the high end.
 512
 513              Warning: this code is trickier than it would appear at first.  */
 514
 515           /* Should also require that pc is <= end of objfile.  FIXME!  */
 516           if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
 517             {
 518               while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
 519                 {
 520                   /* pc is still strictly less than highest address.  */
 521                   /* Note "new" will always be >= lo.  */
 522                   new = (lo + hi) / 2;
 523                   if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
 524                       (lo == new))
 525                     {
 526                       hi = new;
 527                     }
 528                   else
 529                     {
 530                       lo = new;
 531                     }
 532                 }
 533
 534               /* If we have multiple symbols at the same address, we want
 535                  hi to point to the last one.  That way we can find the
 536                  right symbol if it has an index greater than hi.  */
 537               while (hi < objfile->minimal_symbol_count - 1
 538                      && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
 539                          == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
 540                 hi++;
 541
 542               /* Skip various undesirable symbols.  */
 543               while (hi >= 0)
 544                 {
 545                   /* Skip any absolute symbols.  This is apparently
 546                      what adb and dbx do, and is needed for the CM-5.
 547                      There are two known possible problems: (1) on
 548                      ELF, apparently end, edata, etc. are absolute.
 549                      Not sure ignoring them here is a big deal, but if
 550                      we want to use them, the fix would go in
 551                      elfread.c.  (2) I think shared library entry
 552                      points on the NeXT are absolute.  If we want
 553                      special handling for this it probably should be
 554                      triggered by a special mst_abs_or_lib or some
 555                      such.  */
 556
 557                   if (MSYMBOL_TYPE (&msymbol[hi]) == mst_abs)
 558                     {
 559                       hi--;
 560                       continue;
 561                     }
 562
 563                   /* If SECTION was specified, skip any symbol from
 564                      wrong section.  */
 565                   if (section
 566                       /* Some types of debug info, such as COFF,
 567                          don't fill the bfd_section member, so don't
 568                          throw away symbols on those platforms.  */
 569                       && SYMBOL_OBJ_SECTION (&msymbol[hi]) != NULL
 570                       && (!matching_obj_sections
 571                           (SYMBOL_OBJ_SECTION (&msymbol[hi]), section)))
 572                     {
 573                       hi--;
 574                       continue;
 575                     }
 576
 577                   /* If we are looking for a trampoline and this is a
 578                      text symbol, or the other way around, check the
 579                      preceeding symbol too.  If they are otherwise
 580                      identical prefer that one.  */
 581                   if (hi > 0
 582                       && MSYMBOL_TYPE (&msymbol[hi]) == other_type
 583                       && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
 584                       && (MSYMBOL_SIZE (&msymbol[hi])
 585                           == MSYMBOL_SIZE (&msymbol[hi - 1]))
 586                       && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
 587                           == SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
 588                       && (SYMBOL_OBJ_SECTION (&msymbol[hi])
 589                           == SYMBOL_OBJ_SECTION (&msymbol[hi - 1])))
 590                     {
 591                       hi--;
 592                       continue;
 593                     }
 594
 595                   /* If the minimal symbol has a zero size, save it
 596                      but keep scanning backwards looking for one with
 597                      a non-zero size.  A zero size may mean that the
 598                      symbol isn't an object or function (e.g. a
 599                      label), or it may just mean that the size was not
 600                      specified.  */
 601                   if (MSYMBOL_SIZE (&msymbol[hi]) == 0
 602                       && best_zero_sized == -1)
 603                     {
 604                       best_zero_sized = hi;
 605                       hi--;
 606                       continue;
 607                     }
 608
 609                   /* If we are past the end of the current symbol, try
 610                      the previous symbol if it has a larger overlapping
 611                      size.  This happens on i686-pc-linux-gnu with glibc;
 612                      the nocancel variants of system calls are inside
 613                      the cancellable variants, but both have sizes.  */
 614                   if (hi > 0
 615                       && MSYMBOL_SIZE (&msymbol[hi]) != 0
 616                       && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
 617                                 + MSYMBOL_SIZE (&msymbol[hi]))
 618                       && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
 619                                + MSYMBOL_SIZE (&msymbol[hi - 1])))
 620                     {
 621                       hi--;
 622                       continue;
 623                     }
 624
 625                   /* Otherwise, this symbol must be as good as we're going
 626                      to get.  */
 627                   break;
 628                 }
 629
 630               /* If HI has a zero size, and best_zero_sized is set,
 631                  then we had two or more zero-sized symbols; prefer
 632                  the first one we found (which may have a higher
 633                  address).  Also, if we ran off the end, be sure
 634                  to back up.  */
 635               if (best_zero_sized != -1
 636                   && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0))
 637                 hi = best_zero_sized;
 638
 639               /* If the minimal symbol has a non-zero size, and this
 640                  PC appears to be outside the symbol's contents, then
 641                  refuse to use this symbol.  If we found a zero-sized
 642                  symbol with an address greater than this symbol's,
 643                  use that instead.  We assume that if symbols have
 644                  specified sizes, they do not overlap.  */
 645
 646               if (hi >= 0
 647                   && MSYMBOL_SIZE (&msymbol[hi]) != 0
 648                   && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
 649                             + MSYMBOL_SIZE (&msymbol[hi])))
 650                 {
 651                   if (best_zero_sized != -1)
 652                     hi = best_zero_sized;
 653                   else
 654                     /* Go on to the next object file.  */
 655                     continue;
 656                 }
 657
 658               /* The minimal symbol indexed by hi now is the best one in this
 659                  objfile's minimal symbol table.  See if it is the best one
 660                  overall.  */
 661
 662               if (hi >= 0
 663                   && ((best_symbol == NULL) ||
 664                       (SYMBOL_VALUE_ADDRESS (best_symbol) <
 665                        SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
 666                 {
 667                   best_symbol = &msymbol[hi];
 668                 }
 669             }
 670         }
 671     }
 672   return (best_symbol);
 673 }
 674
 675 struct minimal_symbol *
 676 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
 677 {
 678   if (section == NULL)
 679     {
 680       /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
 681          force the section but that (well unless you're doing overlay
 682          debugging) always returns NULL making the call somewhat useless.  */
 683       section = find_pc_section (pc);
 684       if (section == NULL)
 685         return NULL;
 686     }
 687   return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
 688 }
 689
 690 /* Backward compatibility: search through the minimal symbol table
 691    for a matching PC (no section given).  */
 692
 693 struct minimal_symbol *
 694 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
 695 {
 696   return lookup_minimal_symbol_by_pc_section (pc, NULL);
 697 }
 698
 699 /* Find the minimal symbol named NAME, and return both the minsym
 700    struct and its objfile.  This only checks the linkage name.  Sets
 701    *OBJFILE_P and returns the minimal symbol, if it is found.  If it
 702    is not found, returns NULL.  */
 703
 704 struct minimal_symbol *
 705 lookup_minimal_symbol_and_objfile (const char *name,
 706                                    struct objfile **objfile_p)
 707 {
 708   struct objfile *objfile;
 709   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
 710
 711   ALL_OBJFILES (objfile)
 712     {
 713       struct minimal_symbol *msym;
 714
 715       for (msym = objfile->msymbol_hash[hash];
 716            msym != NULL;
 717            msym = msym->hash_next)
 718         {
 719           if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
 720             {
 721               *objfile_p = objfile;
 722               return msym;
 723             }
 724         }
 725     }
 726
 727   return 0;
 728 }
 729 \f
 730
 731 /* Return leading symbol character for a BFD.  If BFD is NULL,
 732    return the leading symbol character from the main objfile.  */
 733
 734 static int get_symbol_leading_char (bfd *);
 735
 736 static int
 737 get_symbol_leading_char (bfd *abfd)
 738 {
 739   if (abfd != NULL)
 740     return bfd_get_symbol_leading_char (abfd);
 741   if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
 742     return bfd_get_symbol_leading_char (symfile_objfile->obfd);
 743   return 0;
 744 }
 745
 746 /* Prepare to start collecting minimal symbols.  Note that presetting
 747    msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
 748    symbol to allocate the memory for the first bunch.  */
 749
 750 void
 751 init_minimal_symbol_collection (void)
 752 {
 753   msym_count = 0;
 754   msym_bunch = NULL;
 755   msym_bunch_index = BUNCH_SIZE;
 756 }
 757
 758 void
 759 prim_record_minimal_symbol (const char *name, CORE_ADDR address,
 760                             enum minimal_symbol_type ms_type,
 761                             struct objfile *objfile)
 762 {
 763   int section;
 764
 765   switch (ms_type)
 766     {
 767     case mst_text:
 768     case mst_file_text:
 769     case mst_solib_trampoline:
 770       section = SECT_OFF_TEXT (objfile);
 771       break;
 772     case mst_data:
 773     case mst_file_data:
 774       section = SECT_OFF_DATA (objfile);
 775       break;
 776     case mst_bss:
 777     case mst_file_bss:
 778       section = SECT_OFF_BSS (objfile);
 779       break;
 780     default:
 781       section = -1;
 782     }
 783
 784   prim_record_minimal_symbol_and_info (name, address, ms_type,
 785                                        section, NULL, objfile);
 786 }
 787
 788 /* Record a minimal symbol in the msym bunches.  Returns the symbol
 789    newly created.  */
 790
 791 struct minimal_symbol *
 792 prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
 793                                  CORE_ADDR address,
 794                                  enum minimal_symbol_type ms_type,
 795                                  int section,
 796                                  asection *bfd_section,
 797                                  struct objfile *objfile)
 798 {
 799   struct obj_section *obj_section;
 800   struct msym_bunch *new;
 801   struct minimal_symbol *msymbol;
 802
 803   /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
 804      the minimal symbols, because if there is also another symbol
 805      at the same address (e.g. the first function of the file),
 806      lookup_minimal_symbol_by_pc would have no way of getting the
 807      right one.  */
 808   if (ms_type == mst_file_text && name[0] == 'g'
 809       && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
 810           || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
 811     return (NULL);
 812
 813   /* It's safe to strip the leading char here once, since the name
 814      is also stored stripped in the minimal symbol table.  */
 815   if (name[0] == get_symbol_leading_char (objfile->obfd))
 816     {
 817       ++name;
 818       --name_len;
 819     }
 820
 821   if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
 822     return (NULL);
 823
 824   if (msym_bunch_index == BUNCH_SIZE)
 825     {
 826       new = XCALLOC (1, struct msym_bunch);
 827       msym_bunch_index = 0;
 828       new->next = msym_bunch;
 829       msym_bunch = new;
 830     }
 831   msymbol = &msym_bunch->contents[msym_bunch_index];
 832   SYMBOL_SET_LANGUAGE (msymbol, language_auto);
 833   SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
 834
 835   SYMBOL_VALUE_ADDRESS (msymbol) = address;
 836   SYMBOL_SECTION (msymbol) = section;
 837   SYMBOL_OBJ_SECTION (msymbol) = NULL;
 838
 839   /* Find obj_section corresponding to bfd_section.  */
 840   if (bfd_section)
 841     ALL_OBJFILE_OSECTIONS (objfile, obj_section)
 842       {
 843         if (obj_section->the_bfd_section == bfd_section)
 844           {
 845             SYMBOL_OBJ_SECTION (msymbol) = obj_section;
 846             break;
 847           }
 848       }
 849
 850   MSYMBOL_TYPE (msymbol) = ms_type;
 851   MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
 852   MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
 853   MSYMBOL_SIZE (msymbol) = 0;
 854
 855   /* The hash pointers must be cleared! If they're not,
 856      add_minsym_to_hash_table will NOT add this msymbol to the hash table.  */
 857   msymbol->hash_next = NULL;
 858   msymbol->demangled_hash_next = NULL;
 859
 860   msym_bunch_index++;
 861   msym_count++;
 862   OBJSTAT (objfile, n_minsyms++);
 863   return msymbol;
 864 }
 865
 866 /* Record a minimal symbol in the msym bunches.  Returns the symbol
 867    newly created.  */
 868
 869 struct minimal_symbol *
 870 prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address,
 871                                      enum minimal_symbol_type ms_type,
 872                                      int section,
 873                                      asection *bfd_section,
 874                                      struct objfile *objfile)
 875 {
 876   return prim_record_minimal_symbol_full (name, strlen (name), 1,
 877                                           address, ms_type, section,
 878                                           bfd_section, objfile);
 879 }
 880
 881 /* Compare two minimal symbols by address and return a signed result based
 882    on unsigned comparisons, so that we sort into unsigned numeric order.
 883    Within groups with the same address, sort by name.  */
 884
 885 static int
 886 compare_minimal_symbols (const void *fn1p, const void *fn2p)
 887 {
 888   const struct minimal_symbol *fn1;
 889   const struct minimal_symbol *fn2;
 890
 891   fn1 = (const struct minimal_symbol *) fn1p;
 892   fn2 = (const struct minimal_symbol *) fn2p;
 893
 894   if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
 895     {
 896       return (-1);              /* addr 1 is less than addr 2.  */
 897     }
 898   else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
 899     {
 900       return (1);               /* addr 1 is greater than addr 2.  */
 901     }
 902   else
 903     /* addrs are equal: sort by name */
 904     {
 905       char *name1 = SYMBOL_LINKAGE_NAME (fn1);
 906       char *name2 = SYMBOL_LINKAGE_NAME (fn2);
 907
 908       if (name1 && name2)       /* both have names */
 909         return strcmp (name1, name2);
 910       else if (name2)
 911         return 1;               /* fn1 has no name, so it is "less".  */
 912       else if (name1)           /* fn2 has no name, so it is "less".  */
 913         return -1;
 914       else
 915         return (0);             /* Neither has a name, so they're equal.  */
 916     }
 917 }
 918
 919 /* Discard the currently collected minimal symbols, if any.  If we wish
 920    to save them for later use, we must have already copied them somewhere
 921    else before calling this function.
 922
 923    FIXME:  We could allocate the minimal symbol bunches on their own
 924    obstack and then simply blow the obstack away when we are done with
 925    it.  Is it worth the extra trouble though?  */
 926
 927 static void
 928 do_discard_minimal_symbols_cleanup (void *arg)
 929 {
 930   struct msym_bunch *next;
 931
 932   while (msym_bunch != NULL)
 933     {
 934       next = msym_bunch->next;
 935       xfree (msym_bunch);
 936       msym_bunch = next;
 937     }
 938 }
 939
 940 struct cleanup *
 941 make_cleanup_discard_minimal_symbols (void)
 942 {
 943   return make_cleanup (do_discard_minimal_symbols_cleanup, 0);
 944 }
 945
 946
 947
 948 /* Compact duplicate entries out of a minimal symbol table by walking
 949    through the table and compacting out entries with duplicate addresses
 950    and matching names.  Return the number of entries remaining.
 951
 952    On entry, the table resides between msymbol[0] and msymbol[mcount].
 953    On exit, it resides between msymbol[0] and msymbol[result_count].
 954
 955    When files contain multiple sources of symbol information, it is
 956    possible for the minimal symbol table to contain many duplicate entries.
 957    As an example, SVR4 systems use ELF formatted object files, which
 958    usually contain at least two different types of symbol tables (a
 959    standard ELF one and a smaller dynamic linking table), as well as
 960    DWARF debugging information for files compiled with -g.
 961
 962    Without compacting, the minimal symbol table for gdb itself contains
 963    over a 1000 duplicates, about a third of the total table size.  Aside
 964    from the potential trap of not noticing that two successive entries
 965    identify the same location, this duplication impacts the time required
 966    to linearly scan the table, which is done in a number of places.  So we
 967    just do one linear scan here and toss out the duplicates.
 968
 969    Note that we are not concerned here about recovering the space that
 970    is potentially freed up, because the strings themselves are allocated
 971    on the objfile_obstack, and will get automatically freed when the symbol
 972    table is freed.  The caller can free up the unused minimal symbols at
 973    the end of the compacted region if their allocation strategy allows it.
 974
 975    Also note we only go up to the next to last entry within the loop
 976    and then copy the last entry explicitly after the loop terminates.
 977
 978    Since the different sources of information for each symbol may
 979    have different levels of "completeness", we may have duplicates
 980    that have one entry with type "mst_unknown" and the other with a
 981    known type.  So if the one we are leaving alone has type mst_unknown,
 982    overwrite its type with the type from the one we are compacting out.  */
 983
 984 static int
 985 compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
 986                          struct objfile *objfile)
 987 {
 988   struct minimal_symbol *copyfrom;
 989   struct minimal_symbol *copyto;
 990
 991   if (mcount > 0)
 992     {
 993       copyfrom = copyto = msymbol;
 994       while (copyfrom < msymbol + mcount - 1)
 995         {
 996           if (SYMBOL_VALUE_ADDRESS (copyfrom)
 997               == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
 998               && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
 999                          SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
1000             {
1001               if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
1002                 {
1003                   MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
1004                 }
1005               copyfrom++;
1006             }
1007           else
1008             *copyto++ = *copyfrom++;
1009         }
1010       *copyto++ = *copyfrom++;
1011       mcount = copyto - msymbol;
1012     }
1013   return (mcount);
1014 }
1015
1016 /* Build (or rebuild) the minimal symbol hash tables.  This is necessary
1017    after compacting or sorting the table since the entries move around
1018    thus causing the internal minimal_symbol pointers to become jumbled.  */
1019
1020 static void
1021 build_minimal_symbol_hash_tables (struct objfile *objfile)
1022 {
1023   int i;
1024   struct minimal_symbol *msym;
1025
1026   /* Clear the hash tables.  */
1027   for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
1028     {
1029       objfile->msymbol_hash[i] = 0;
1030       objfile->msymbol_demangled_hash[i] = 0;
1031     }
1032
1033   /* Now, (re)insert the actual entries.  */
1034   for (i = objfile->minimal_symbol_count, msym = objfile->msymbols;
1035        i > 0;
1036        i--, msym++)
1037     {
1038       msym->hash_next = 0;
1039       add_minsym_to_hash_table (msym, objfile->msymbol_hash);
1040
1041       msym->demangled_hash_next = 0;
1042       if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
1043         add_minsym_to_demangled_hash_table (msym,
1044                                             objfile->msymbol_demangled_hash);
1045     }
1046 }
1047
1048 /* Add the minimal symbols in the existing bunches to the objfile's official
1049    minimal symbol table.  In most cases there is no minimal symbol table yet
1050    for this objfile, and the existing bunches are used to create one.  Once
1051    in a while (for shared libraries for example), we add symbols (e.g. common
1052    symbols) to an existing objfile.
1053
1054    Because of the way minimal symbols are collected, we generally have no way
1055    of knowing what source language applies to any particular minimal symbol.
1056    Specifically, we have no way of knowing if the minimal symbol comes from a
1057    C++ compilation unit or not.  So for the sake of supporting cached
1058    demangled C++ names, we have no choice but to try and demangle each new one
1059    that comes in.  If the demangling succeeds, then we assume it is a C++
1060    symbol and set the symbol's language and demangled name fields
1061    appropriately.  Note that in order to avoid unnecessary demanglings, and
1062    allocating obstack space that subsequently can't be freed for the demangled
1063    names, we mark all newly added symbols with language_auto.  After
1064    compaction of the minimal symbols, we go back and scan the entire minimal
1065    symbol table looking for these new symbols.  For each new symbol we attempt
1066    to demangle it, and if successful, record it as a language_cplus symbol
1067    and cache the demangled form on the symbol obstack.  Symbols which don't
1068    demangle are marked as language_unknown symbols, which inhibits future
1069    attempts to demangle them if we later add more minimal symbols.  */
1070
1071 void
1072 install_minimal_symbols (struct objfile *objfile)
1073 {
1074   int bindex;
1075   int mcount;
1076   struct msym_bunch *bunch;
1077   struct minimal_symbol *msymbols;
1078   int alloc_count;
1079
1080   if (msym_count > 0)
1081     {
1082       /* Allocate enough space in the obstack, into which we will gather the
1083          bunches of new and existing minimal symbols, sort them, and then
1084          compact out the duplicate entries.  Once we have a final table,
1085          we will give back the excess space.  */
1086
1087       alloc_count = msym_count + objfile->minimal_symbol_count + 1;
1088       obstack_blank (&objfile->objfile_obstack,
1089                      alloc_count * sizeof (struct minimal_symbol));
1090       msymbols = (struct minimal_symbol *)
1091         obstack_base (&objfile->objfile_obstack);
1092
1093       /* Copy in the existing minimal symbols, if there are any.  */
1094
1095       if (objfile->minimal_symbol_count)
1096         memcpy ((char *) msymbols, (char *) objfile->msymbols,
1097             objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
1098
1099       /* Walk through the list of minimal symbol bunches, adding each symbol
1100          to the new contiguous array of symbols.  Note that we start with the
1101          current, possibly partially filled bunch (thus we use the current
1102          msym_bunch_index for the first bunch we copy over), and thereafter
1103          each bunch is full.  */
1104
1105       mcount = objfile->minimal_symbol_count;
1106
1107       for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
1108         {
1109           for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
1110             msymbols[mcount] = bunch->contents[bindex];
1111           msym_bunch_index = BUNCH_SIZE;
1112         }
1113
1114       /* Sort the minimal symbols by address.  */
1115
1116       qsort (msymbols, mcount, sizeof (struct minimal_symbol),
1117              compare_minimal_symbols);
1118
1119       /* Compact out any duplicates, and free up whatever space we are
1120          no longer using.  */
1121
1122       mcount = compact_minimal_symbols (msymbols, mcount, objfile);
1123
1124       obstack_blank (&objfile->objfile_obstack,
1125                (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
1126       msymbols = (struct minimal_symbol *)
1127         obstack_finish (&objfile->objfile_obstack);
1128
1129       /* We also terminate the minimal symbol table with a "null symbol",
1130          which is *not* included in the size of the table.  This makes it
1131          easier to find the end of the table when we are handed a pointer
1132          to some symbol in the middle of it.  Zero out the fields in the
1133          "null symbol" allocated at the end of the array.  Note that the
1134          symbol count does *not* include this null symbol, which is why it
1135          is indexed by mcount and not mcount-1.  */
1136
1137       SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL;
1138       SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
1139       MSYMBOL_TARGET_FLAG_1 (&msymbols[mcount]) = 0;
1140       MSYMBOL_TARGET_FLAG_2 (&msymbols[mcount]) = 0;
1141       MSYMBOL_SIZE (&msymbols[mcount]) = 0;
1142       MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
1143       SYMBOL_SET_LANGUAGE (&msymbols[mcount], language_unknown);
1144
1145       /* Attach the minimal symbol table to the specified objfile.
1146          The strings themselves are also located in the objfile_obstack
1147          of this objfile.  */
1148
1149       objfile->minimal_symbol_count = mcount;
1150       objfile->msymbols = msymbols;
1151
1152       /* Try to guess the appropriate C++ ABI by looking at the names
1153          of the minimal symbols in the table.  */
1154       {
1155         int i;
1156
1157         for (i = 0; i < mcount; i++)
1158           {
1159             /* If a symbol's name starts with _Z and was successfully
1160                demangled, then we can assume we've found a GNU v3 symbol.
1161                For now we set the C++ ABI globally; if the user is
1162                mixing ABIs then the user will need to "set cp-abi"
1163                manually.  */
1164             const char *name = SYMBOL_LINKAGE_NAME (&objfile->msymbols[i]);
1165
1166             if (name[0] == '_' && name[1] == 'Z'
1167                 && SYMBOL_DEMANGLED_NAME (&objfile->msymbols[i]) != NULL)
1168               {
1169                 set_cp_abi_as_auto_default ("gnu-v3");
1170                 break;
1171               }
1172           }
1173       }
1174
1175       /* Now build the hash tables; we can't do this incrementally
1176          at an earlier point since we weren't finished with the obstack
1177          yet.  (And if the msymbol obstack gets moved, all the internal
1178          pointers to other msymbols need to be adjusted.)  */
1179       build_minimal_symbol_hash_tables (objfile);
1180     }
1181 }
1182
1183 /* Sort all the minimal symbols in OBJFILE.  */
1184
1185 void
1186 msymbols_sort (struct objfile *objfile)
1187 {
1188   qsort (objfile->msymbols, objfile->minimal_symbol_count,
1189          sizeof (struct minimal_symbol), compare_minimal_symbols);
1190   build_minimal_symbol_hash_tables (objfile);
1191 }
1192
1193 /* Check if PC is in a shared library trampoline code stub.
1194    Return minimal symbol for the trampoline entry or NULL if PC is not
1195    in a trampoline code stub.  */
1196
1197 struct minimal_symbol *
1198 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
1199 {
1200   struct obj_section *section = find_pc_section (pc);
1201   struct minimal_symbol *msymbol;
1202
1203   if (section == NULL)
1204     return NULL;
1205   msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
1206
1207   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
1208     return msymbol;
1209   return NULL;
1210 }
1211
1212 /* If PC is in a shared library trampoline code stub, return the
1213    address of the `real' function belonging to the stub.
1214    Return 0 if PC is not in a trampoline code stub or if the real
1215    function is not found in the minimal symbol table.
1216
1217    We may fail to find the right function if a function with the
1218    same name is defined in more than one shared library, but this
1219    is considered bad programming style.  We could return 0 if we find
1220    a duplicate function in case this matters someday.  */
1221
1222 CORE_ADDR
1223 find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
1224 {
1225   struct objfile *objfile;
1226   struct minimal_symbol *msymbol;
1227   struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1228
1229   if (tsymbol != NULL)
1230     {
1231       ALL_MSYMBOLS (objfile, msymbol)
1232       {
1233         if (MSYMBOL_TYPE (msymbol) == mst_text
1234             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1235                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1236           return SYMBOL_VALUE_ADDRESS (msymbol);
1237
1238         /* Also handle minimal symbols pointing to function descriptors.  */
1239         if (MSYMBOL_TYPE (msymbol) == mst_data
1240             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1241                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1242           {
1243             CORE_ADDR func;
1244
1245             func = gdbarch_convert_from_func_ptr_addr
1246                     (get_objfile_arch (objfile),
1247                      SYMBOL_VALUE_ADDRESS (msymbol),
1248                      &current_target);
1249
1250             /* Ignore data symbols that are not function descriptors.  */
1251             if (func != SYMBOL_VALUE_ADDRESS (msymbol))
1252               return func;
1253           }
1254       }
1255     }
1256   return 0;
1257 }