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