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