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