gdb/minsyms.c

   1 /* GDB routines for manipulating the minimal symbol tables.
   2    Copyright 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support, using pieces from other GDB modules.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21
  22 /* This file contains support routines for creating, manipulating, and
  23    destroying minimal symbol tables.
  24
  25    Minimal symbol tables are used to hold some very basic information about
  26    all defined global symbols (text, data, bss, abs, etc).  The only two
  27    required pieces of information are the symbol's name and the address
  28    associated with that symbol.
  29
  30    In many cases, even if a file was compiled with no special options for
  31    debugging at all, as long as was not stripped it will contain sufficient
  32    information to build useful minimal symbol tables using this structure.
  33
  34    Even when a file contains enough debugging information to build a full
  35    symbol table, these minimal symbols are still useful for quickly mapping
  36    between names and addresses, and vice versa.  They are also sometimes used
  37    to figure out what full symbol table entries need to be read in. */
  38
  39
  40 #include "defs.h"
  41 #include "symtab.h"
  42 #include "bfd.h"
  43 #include "symfile.h"
  44 #include "objfiles.h"
  45
  46 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
  47    At the end, copy them all into one newly allocated location on an objfile's
  48    symbol obstack.  */
  49
  50 #define BUNCH_SIZE 127
  51
  52 struct msym_bunch
  53 {
  54   struct msym_bunch *next;
  55   struct minimal_symbol contents[BUNCH_SIZE];
  56 };
  57
  58 /* Bunch currently being filled up.
  59    The next field points to chain of filled bunches.  */
  60
  61 static struct msym_bunch *msym_bunch;
  62
  63 /* Number of slots filled in current bunch.  */
  64
  65 static int msym_bunch_index;
  66
  67 /* Total number of minimal symbols recorded so far for the objfile.  */
  68
  69 static int msym_count;
  70
  71 /* Prototypes for local functions. */
  72
  73 static int
  74 compare_minimal_symbols PARAMS ((const void *, const void *));
  75
  76 static int
  77 compact_minimal_symbols PARAMS ((struct minimal_symbol *, int));
  78
  79 /* Call the function specified by FUNC for each currently available minimal
  80    symbol, for as long as this function continues to return NULL.  If the
  81    function ever returns non-NULL, then the iteration over the minimal
  82    symbols is terminated and the result is returned to the caller.
  83
  84    The function called has full control over the form and content of the
  85    information returned via the non-NULL result, which may be as simple as a
  86    pointer to the minimal symbol that the iteration terminated on, or as
  87    complex as a pointer to a private structure containing multiple results. */
  88
  89 PTR
  90 iterate_over_msymbols (func, arg1, arg2, arg3)
  91      PTR (*func) PARAMS ((struct objfile *, struct minimal_symbol *,
  92                           PTR, PTR, PTR));
  93      PTR arg1;
  94      PTR arg2;
  95      PTR arg3;
  96 {
  97   register struct objfile *objfile;
  98   register struct minimal_symbol *msymbol;
  99   char *result = NULL;
 100
 101   for (objfile = object_files;
 102        objfile != NULL && result == NULL;
 103        objfile = objfile -> next)
 104     {
 105       for (msymbol = objfile -> msymbols;
 106            msymbol != NULL && msymbol -> name != NULL && result == NULL;
 107            msymbol++)
 108         {
 109           result = (*func)(objfile, msymbol, arg1, arg2, arg3);
 110         }
 111     }
 112   return (result);
 113 }
 114
 115 /* Look through all the current minimal symbol tables and find the first
 116    minimal symbol that matches NAME.  If OBJF is non-NULL, it specifies a
 117    particular objfile and the search is limited to that objfile.  Returns
 118    a pointer to the minimal symbol that matches, or NULL if no match is found.
 119
 120    Note:  One instance where there may be duplicate minimal symbols with
 121    the same name is when the symbol tables for a shared library and the
 122    symbol tables for an executable contain global symbols with the same
 123    names (the dynamic linker deals with the duplication). */
 124
 125 struct minimal_symbol *
 126 lookup_minimal_symbol (name, objf)
 127      register const char *name;
 128      struct objfile *objf;
 129 {
 130   struct objfile *objfile;
 131   struct minimal_symbol *msymbol;
 132   struct minimal_symbol *found_symbol = NULL;
 133 #ifdef IBM6000_TARGET
 134   struct minimal_symbol *trampoline_symbol = NULL;
 135 #endif
 136
 137   for (objfile = object_files;
 138        objfile != NULL && found_symbol == NULL;
 139        objfile = objfile -> next)
 140     {
 141       if (objf == NULL || objf == objfile)
 142         {
 143           for (msymbol = objfile -> msymbols;
 144                msymbol != NULL && msymbol -> name != NULL &&
 145                found_symbol == NULL;
 146                msymbol++)
 147             {
 148               if (strcmp (msymbol -> name, name) == 0)
 149                 {
 150 #ifdef IBM6000_TARGET
 151 /* I *think* all platforms using shared libraries (and trampoline code)
 152  * will suffer this problem. Consider a case where there are 5 shared
 153  * libraries, each referencing `foo' with a trampoline entry. When someone
 154  * wants to put a breakpoint on `foo' and the only info we have is minimal
 155  * symbol vector, we want to use the real `foo', rather than one of those
 156  * trampoline entries. MGO */
 157           /* If a trampoline symbol is found, we prefer to keep looking
 158              for the *real* symbol. If the actual symbol not found,
 159              then we'll use the trampoline entry. Sorry for the machine
 160              dependent code here, but I hope this will benefit other
 161              platforms as well. For trampoline entries, we used mst_unknown
 162              earlier. Perhaps we should define a `mst_trampoline' type?? */
 163
 164                   if (msymbol->type != mst_unknown)
 165                     found_symbol = msymbol;
 166                   else if (msymbol->type == mst_unknown && !trampoline_symbol)
 167                     trampoline_symbol = msymbol;
 168
 169 #else
 170                   found_symbol = msymbol;
 171 #endif
 172                 }
 173             }
 174         }
 175     }
 176 #ifdef IBM6000_TARGET
 177   return found_symbol ? found_symbol : trampoline_symbol;
 178 #endif
 179
 180   return (found_symbol);
 181 }
 182
 183
 184 /* Search through the minimal symbol table for each objfile and find the
 185    symbol whose address is the largest address that is still less than or
 186    equal to PC.  Returns a pointer to the minimal symbol if such a symbol
 187    is found, or NULL if PC is not in a suitable range.  Note that we need
 188    to look through ALL the minimal symbol tables before deciding on the
 189    symbol that comes closest to the specified PC. */
 190
 191 struct minimal_symbol *
 192 lookup_minimal_symbol_by_pc (pc)
 193      register CORE_ADDR pc;
 194 {
 195   register int lo;
 196   register int hi;
 197   register int new;
 198   register struct objfile *objfile;
 199   register struct minimal_symbol *msymbol;
 200   register struct minimal_symbol *best_symbol = NULL;
 201
 202   for (objfile = object_files;
 203        objfile != NULL;
 204        objfile = objfile -> next)
 205     {
 206       /* If this objfile has a minimal symbol table, go search it using
 207          a binary search.  Note that a minimal symbol table always consists
 208          of at least two symbols, a "real" symbol and the terminating
 209          "null symbol".  If there are no real symbols, then there is no
 210          minimal symbol table at all. */
 211
 212       if ((msymbol = objfile -> msymbols) != NULL)
 213         {
 214           lo = 0;
 215           hi = objfile -> minimal_symbol_count - 2;
 216
 217           /* This code assumes that the minimal symbols are sorted by
 218              ascending address values.  If the pc value is greater than or
 219              equal to the first symbol's address, then some symbol in this
 220              minimal symbol table is a suitable candidate for being the
 221              "best" symbol.  This includes the last real symbol, for cases
 222              where the pc value is larger than any address in this vector.
 223
 224              By iterating until the address associated with the current
 225              hi index (the endpoint of the test interval) is less than
 226              or equal to the desired pc value, we accomplish two things:
 227              (1) the case where the pc value is larger than any minimal
 228              symbol address is trivially solved, (2) the address associated
 229              with the hi index is always the one we want when the interation
 230              terminates.  In essence, we are iterating the test interval
 231              down until the pc value is pushed out of it from the high end.
 232
 233              Warning: this code is trickier than it would appear at first. */
 234
 235           /* Should also requires that pc is <= end of objfile.  FIXME! */
 236           if (pc >= msymbol[lo].address)
 237             {
 238               while (msymbol[hi].address > pc)
 239                 {
 240                   /* pc is still strictly less than highest address */
 241                   /* Note "new" will always be >= lo */
 242                   new = (lo + hi) / 2;
 243                   if ((msymbol[new].address >= pc) || (lo == new))
 244                     {
 245                       hi = new;
 246                     }
 247                   else
 248                     {
 249                       lo = new;
 250                     }
 251                 }
 252               /* The minimal symbol indexed by hi now is the best one in this
 253                  objfile's minimal symbol table.  See if it is the best one
 254                  overall. */
 255
 256               if ((best_symbol == NULL) ||
 257                   (best_symbol -> address < msymbol[hi].address))
 258                 {
 259                   best_symbol = &msymbol[hi];
 260                 }
 261             }
 262         }
 263     }
 264   return (best_symbol);
 265 }
 266
 267 /* Prepare to start collecting minimal symbols.  Note that presetting
 268    msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
 269    symbol to allocate the memory for the first bunch. */
 270
 271 void
 272 init_minimal_symbol_collection ()
 273 {
 274   msym_count = 0;
 275   msym_bunch = NULL;
 276   msym_bunch_index = BUNCH_SIZE;
 277 }
 278
 279 void
 280 prim_record_minimal_symbol (name, address, ms_type)
 281      const char *name;
 282      CORE_ADDR address;
 283      enum minimal_symbol_type ms_type;
 284 {
 285   register struct msym_bunch *new;
 286
 287   if (msym_bunch_index == BUNCH_SIZE)
 288     {
 289       new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch));
 290       msym_bunch_index = 0;
 291       new -> next = msym_bunch;
 292       msym_bunch = new;
 293     }
 294   msym_bunch -> contents[msym_bunch_index].name = (char *) name;
 295   msym_bunch -> contents[msym_bunch_index].address = address;
 296   msym_bunch -> contents[msym_bunch_index].info = NULL;
 297   msym_bunch -> contents[msym_bunch_index].type = ms_type;
 298   msym_bunch_index++;
 299   msym_count++;
 300 }
 301
 302 /* Compare two minimal symbols by address and return a signed result based
 303    on unsigned comparisons, so that we sort into unsigned numeric order.  */
 304
 305 static int
 306 compare_minimal_symbols (fn1p, fn2p)
 307      const PTR fn1p;
 308      const PTR fn2p;
 309 {
 310   register const struct minimal_symbol *fn1;
 311   register const struct minimal_symbol *fn2;
 312
 313   fn1 = (const struct minimal_symbol *) fn1p;
 314   fn2 = (const struct minimal_symbol *) fn2p;
 315
 316   if (fn1 -> address < fn2 -> address)
 317     {
 318       return (-1);
 319     }
 320   else if (fn1 -> address > fn2 -> address)
 321     {
 322       return (1);
 323     }
 324   else
 325     {
 326       return (0);
 327     }
 328 }
 329
 330 /* Discard the currently collected minimal symbols, if any.  If we wish
 331    to save them for later use, we must have already copied them somewhere
 332    else before calling this function.
 333
 334    FIXME:  We could allocate the minimal symbol bunches on their own
 335    obstack and then simply blow the obstack away when we are done with
 336    it.  Is it worth the extra trouble though? */
 337
 338 /* ARGSUSED */
 339 void
 340 discard_minimal_symbols (foo)
 341      int foo;
 342 {
 343   register struct msym_bunch *next;
 344
 345   while (msym_bunch != NULL)
 346     {
 347       next = msym_bunch -> next;
 348       free (msym_bunch);
 349       msym_bunch = next;
 350     }
 351 }
 352
 353 /* Compact duplicate entries out of a minimal symbol table by walking
 354    through the table and compacting out entries with duplicate addresses
 355    and matching names.  Return the number of entries remaining.
 356
 357    On entry, the table resides between msymbol[0] and msymbol[mcount].
 358    On exit, it resides between msymbol[0] and msymbol[result_count].
 359
 360    When files contain multiple sources of symbol information, it is
 361    possible for the minimal symbol table to contain many duplicate entries.
 362    As an example, SVR4 systems use ELF formatted object files, which
 363    usually contain at least two different types of symbol tables (a
 364    standard ELF one and a smaller dynamic linking table), as well as
 365    DWARF debugging information for files compiled with -g.
 366
 367    Without compacting, the minimal symbol table for gdb itself contains
 368    over a 1000 duplicates, about a third of the total table size.  Aside
 369    from the potential trap of not noticing that two successive entries
 370    identify the same location, this duplication impacts the time required
 371    to linearly scan the table, which is done in a number of places.  So we
 372    just do one linear scan here and toss out the duplicates.
 373
 374    Note that we are not concerned here about recovering the space that
 375    is potentially freed up, because the strings themselves are allocated
 376    on the symbol_obstack, and will get automatically freed when the symbol
 377    table is freed.  The caller can free up the unused minimal symbols at
 378    the end of the compacted region if their allocation strategy allows it.
 379
 380    Also note we only go up to the next to last entry within the loop
 381    and then copy the last entry explicitly after the loop terminates.
 382
 383    Since the different sources of information for each symbol may
 384    have different levels of "completeness", we may have duplicates
 385    that have one entry with type "mst_unknown" and the other with a
 386    known type.  So if the one we are leaving alone has type mst_unknown,
 387    overwrite its type with the type from the one we are compacting out.  */
 388
 389 static int
 390 compact_minimal_symbols (msymbol, mcount)
 391      struct minimal_symbol *msymbol;
 392      int mcount;
 393 {
 394   struct minimal_symbol *copyfrom;
 395   struct minimal_symbol *copyto;
 396
 397   if (mcount > 0)
 398     {
 399       copyfrom = copyto = msymbol;
 400       while (copyfrom < msymbol + mcount - 1)
 401         {
 402           if (copyfrom -> address == (copyfrom + 1) -> address
 403               && (strcmp (copyfrom -> name, (copyfrom + 1) -> name) == 0))
 404             {
 405               if ((copyfrom + 1) -> type == mst_unknown)
 406                 {
 407                   (copyfrom + 1) -> type = copyfrom -> type;
 408                 }
 409               copyfrom++;
 410             }
 411           else
 412             {
 413               *copyto++ = *copyfrom++;
 414             }
 415         }
 416       *copyto++ = *copyfrom++;
 417       mcount = copyto - msymbol;
 418     }
 419   return (mcount);
 420 }
 421
 422 /* Add the minimal symbols in the existing bunches to the objfile's
 423    official minimal symbol table.  99% of the time, this adds the
 424    bunches to NO existing symbols.  Once in a while for shared
 425    libraries, we add symbols (e.g. common symbols) to an existing
 426    objfile.  */
 427
 428 void
 429 install_minimal_symbols (objfile)
 430      struct objfile *objfile;
 431 {
 432   register int bindex;
 433   register int mcount;
 434   register struct msym_bunch *bunch;
 435   register struct minimal_symbol *msymbols;
 436   int alloc_count;
 437
 438   if (msym_count > 0)
 439     {
 440       /* Allocate enough space in the obstack, into which we will gather the
 441          bunches of new and existing minimal symbols, sort them, and then
 442          compact out the duplicate entries.  Once we have a final table,
 443          we will give back the excess space.  */
 444
 445       alloc_count = msym_count + objfile->minimal_symbol_count + 1;
 446       obstack_blank (&objfile->symbol_obstack,
 447                      alloc_count * sizeof (struct minimal_symbol));
 448       msymbols = (struct minimal_symbol *)
 449                  obstack_base (&objfile->symbol_obstack);
 450
 451       /* Copy in the existing minimal symbols, if there are any.  */
 452
 453       if (objfile->minimal_symbol_count)
 454         memcpy ((char *)msymbols, (char *)objfile->msymbols,
 455                 objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
 456
 457       /* Walk through the list of minimal symbol bunches, adding each symbol
 458          to the new contiguous array of symbols.  Note that we start with the
 459          current, possibly partially filled bunch (thus we use the current
 460          msym_bunch_index for the first bunch we copy over), and thereafter
 461          each bunch is full. */
 462
 463       mcount = objfile->minimal_symbol_count;
 464
 465       for (bunch = msym_bunch; bunch != NULL; bunch = bunch -> next)
 466         {
 467           for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
 468             {
 469               msymbols[mcount] = bunch -> contents[bindex];
 470 #ifdef NAMES_HAVE_UNDERSCORE
 471               if (msymbols[mcount].name[0] == '_')
 472                 {
 473                   msymbols[mcount].name++;
 474                 }
 475 #endif
 476 #ifdef SOME_NAMES_HAVE_DOT
 477               if (msymbols[mcount].name[0] == '.')
 478                 {
 479                   msymbols[mcount].name++;
 480                 }
 481 #endif
 482             }
 483           msym_bunch_index = BUNCH_SIZE;
 484         }
 485
 486       /* Sort the minimal symbols by address.  */
 487
 488       qsort (msymbols, mcount, sizeof (struct minimal_symbol),
 489              compare_minimal_symbols);
 490
 491       /* Compact out any duplicates, and free up whatever space we are
 492          no longer using.  */
 493
 494       mcount = compact_minimal_symbols (msymbols, mcount);
 495
 496       obstack_blank (&objfile->symbol_obstack,
 497         (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
 498       msymbols = (struct minimal_symbol *)
 499         obstack_finish (&objfile->symbol_obstack);
 500
 501       /* We also terminate the minimal symbol table
 502          with a "null symbol", which is *not* included in the size of
 503          the table.  This makes it easier to find the end of the table
 504          when we are handed a pointer to some symbol in the middle of it.
 505          Zero out the fields in the "null symbol" allocated at the end
 506          of the array.  Note that the symbol count does *not* include
 507          this null symbol, which is why it is indexed by mcount and not
 508          mcount-1. */
 509
 510       msymbols[mcount].name = NULL;
 511       msymbols[mcount].address = 0;
 512       msymbols[mcount].info = NULL;
 513       msymbols[mcount].type = mst_unknown;
 514
 515       /* Attach the minimal symbol table to the specified objfile.
 516          The strings themselves are also located in the symbol_obstack
 517          of this objfile.  */
 518
 519       objfile -> minimal_symbol_count = mcount;
 520       objfile -> msymbols = msymbols;
 521     }
 522 }
 523