gdb/minsyms.c

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