* minsyms.h: Rearrange. Document header and all functions.
[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 /* See minsyms.h.  */
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 = SYMBOL_HASH_NEXT (hash, *string);
95           ++string;
96         }
97     }
98   return hash;
99 }
100
101 /* See minsyms.h.  */
102
103 unsigned int
104 msymbol_hash (const char *string)
105 {
106   unsigned int hash = 0;
107
108   for (; *string; ++string)
109     hash = SYMBOL_HASH_NEXT (hash, *string);
110   return hash;
111 }
112
113 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE.  */
114 static 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 /* See minsyms.h.  */
145
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                       int (*cmp) (const char *, const char *);
243
244                       cmp = (case_sensitivity == case_sensitive_on
245                              ? strcmp : strcasecmp);
246                       match = cmp (SYMBOL_LINKAGE_NAME (msymbol),
247                                    modified_name) == 0;
248                     }
249                   else
250                     {
251                       /* The function respects CASE_SENSITIVITY.  */
252                       match = SYMBOL_MATCHES_SEARCH_NAME (msymbol,
253                                                           modified_name);
254                     }
255
256                   if (match)
257                     {
258                     switch (MSYMBOL_TYPE (msymbol))
259                       {
260                       case mst_file_text:
261                       case mst_file_data:
262                       case mst_file_bss:
263                         if (sfile == NULL
264                             || filename_cmp (msymbol->filename, sfile) == 0)
265                           found_file_symbol = msymbol;
266                         break;
267
268                       case mst_solib_trampoline:
269
270                         /* If a trampoline symbol is found, we prefer to
271                            keep looking for the *real* symbol.  If the
272                            actual symbol is not found, then we'll use the
273                            trampoline entry.  */
274                         if (trampoline_symbol == NULL)
275                           trampoline_symbol = msymbol;
276                         break;
277
278                       case mst_unknown:
279                       default:
280                         found_symbol = msymbol;
281                         break;
282                       }
283                     }
284
285                 /* Find the next symbol on the hash chain.  */
286                 if (pass == 1)
287                   msymbol = msymbol->hash_next;
288                 else
289                   msymbol = msymbol->demangled_hash_next;
290                 }
291             }
292         }
293     }
294
295   if (needtofreename)
296     xfree ((void *) modified_name);
297
298   /* External symbols are best.  */
299   if (found_symbol)
300     return found_symbol;
301
302   /* File-local symbols are next best.  */
303   if (found_file_symbol)
304     return found_file_symbol;
305
306   /* Symbols for shared library trampolines are next best.  */
307   if (trampoline_symbol)
308     return trampoline_symbol;
309
310   return NULL;
311 }
312
313 /* See minsyms.h.  */
314
315 void
316 iterate_over_minimal_symbols (struct objfile *objf, const char *name,
317                               void (*callback) (struct minimal_symbol *,
318                                                 void *),
319                               void *user_data)
320 {
321   unsigned int hash;
322   struct minimal_symbol *iter;
323   int (*cmp) (const char *, const char *);
324
325   /* The first pass is over the ordinary hash table.  */
326   hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
327   iter = objf->msymbol_hash[hash];
328   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
329   while (iter)
330     {
331       if (cmp (SYMBOL_LINKAGE_NAME (iter), name) == 0)
332         (*callback) (iter, user_data);
333       iter = iter->hash_next;
334     }
335
336   /* The second pass is over the demangled table.  */
337   hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
338   iter = objf->msymbol_demangled_hash[hash];
339   while (iter)
340     {
341       if (SYMBOL_MATCHES_SEARCH_NAME (iter, name))
342         (*callback) (iter, user_data);
343       iter = iter->demangled_hash_next;
344     }
345 }
346
347 /* See minsyms.h.  */
348
349 struct minimal_symbol *
350 lookup_minimal_symbol_text (const char *name, struct objfile *objf)
351 {
352   struct objfile *objfile;
353   struct minimal_symbol *msymbol;
354   struct minimal_symbol *found_symbol = NULL;
355   struct minimal_symbol *found_file_symbol = NULL;
356
357   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
358
359   for (objfile = object_files;
360        objfile != NULL && found_symbol == NULL;
361        objfile = objfile->next)
362     {
363       if (objf == NULL || objf == objfile
364           || objf == objfile->separate_debug_objfile_backlink)
365         {
366           for (msymbol = objfile->msymbol_hash[hash];
367                msymbol != NULL && found_symbol == NULL;
368                msymbol = msymbol->hash_next)
369             {
370               if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
371                   (MSYMBOL_TYPE (msymbol) == mst_text
372                    || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc
373                    || MSYMBOL_TYPE (msymbol) == mst_file_text))
374                 {
375                   switch (MSYMBOL_TYPE (msymbol))
376                     {
377                     case mst_file_text:
378                       found_file_symbol = msymbol;
379                       break;
380                     default:
381                       found_symbol = msymbol;
382                       break;
383                     }
384                 }
385             }
386         }
387     }
388   /* External symbols are best.  */
389   if (found_symbol)
390     return found_symbol;
391
392   /* File-local symbols are next best.  */
393   if (found_file_symbol)
394     return found_file_symbol;
395
396   return NULL;
397 }
398
399 /* See minsyms.h.  */
400
401 struct minimal_symbol *
402 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
403                                   struct objfile *objf)
404 {
405   struct objfile *objfile;
406   struct minimal_symbol *msymbol;
407
408   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
409
410   for (objfile = object_files;
411        objfile != NULL;
412        objfile = objfile->next)
413     {
414       if (objf == NULL || objf == objfile
415           || objf == objfile->separate_debug_objfile_backlink)
416         {
417           for (msymbol = objfile->msymbol_hash[hash];
418                msymbol != NULL;
419                msymbol = msymbol->hash_next)
420             {
421               if (SYMBOL_VALUE_ADDRESS (msymbol) == pc
422                   && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0)
423                 return msymbol;
424             }
425         }
426     }
427
428   return NULL;
429 }
430
431 /* See minsyms.h.  */
432
433 struct minimal_symbol *
434 lookup_minimal_symbol_solib_trampoline (const char *name,
435                                         struct objfile *objf)
436 {
437   struct objfile *objfile;
438   struct minimal_symbol *msymbol;
439   struct minimal_symbol *found_symbol = NULL;
440
441   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
442
443   for (objfile = object_files;
444        objfile != NULL && found_symbol == NULL;
445        objfile = objfile->next)
446     {
447       if (objf == NULL || objf == objfile
448           || objf == objfile->separate_debug_objfile_backlink)
449         {
450           for (msymbol = objfile->msymbol_hash[hash];
451                msymbol != NULL && found_symbol == NULL;
452                msymbol = msymbol->hash_next)
453             {
454               if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
455                   MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
456                 return msymbol;
457             }
458         }
459     }
460
461   return NULL;
462 }
463
464 /* Search through the minimal symbol table for each objfile and find
465    the symbol whose address is the largest address that is still less
466    than or equal to PC, and matches SECTION (which is not NULL).
467    Returns a pointer to the minimal symbol if such a symbol is found,
468    or NULL if PC is not in a suitable range.
469    Note that we need to look through ALL the minimal symbol tables
470    before deciding on the symbol that comes closest to the specified PC.
471    This is because objfiles can overlap, for example objfile A has .text
472    at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
473    .data at 0x40048.
474
475    If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
476    there are text and trampoline symbols at the same address.
477    Otherwise prefer mst_text symbols.  */
478
479 static struct minimal_symbol *
480 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
481                                        struct obj_section *section,
482                                        int want_trampoline)
483 {
484   int lo;
485   int hi;
486   int new;
487   struct objfile *objfile;
488   struct minimal_symbol *msymbol;
489   struct minimal_symbol *best_symbol = NULL;
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                 }
696             }
697         }
698     }
699   return (best_symbol);
700 }
701
702 struct minimal_symbol *
703 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
704 {
705   if (section == NULL)
706     {
707       /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
708          force the section but that (well unless you're doing overlay
709          debugging) always returns NULL making the call somewhat useless.  */
710       section = find_pc_section (pc);
711       if (section == NULL)
712         return NULL;
713     }
714   return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
715 }
716
717 /* See minsyms.h.  */
718
719 struct minimal_symbol *
720 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
721 {
722   return lookup_minimal_symbol_by_pc_section (pc, NULL);
723 }
724
725 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver.  */
726
727 int
728 in_gnu_ifunc_stub (CORE_ADDR pc)
729 {
730   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
731
732   return msymbol && MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc;
733 }
734
735 /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
736
737 static CORE_ADDR
738 stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
739 {
740   error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without "
741            "the ELF support compiled in."),
742          paddress (gdbarch, pc));
743 }
744
745 /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
746
747 static int
748 stub_gnu_ifunc_resolve_name (const char *function_name,
749                              CORE_ADDR *function_address_p)
750 {
751   error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without "
752            "the ELF support compiled in."),
753          function_name);
754 }
755
756 /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
757
758 static void
759 stub_gnu_ifunc_resolver_stop (struct breakpoint *b)
760 {
761   internal_error (__FILE__, __LINE__,
762                   _("elf_gnu_ifunc_resolver_stop cannot be reached."));
763 }
764
765 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
766
767 static void
768 stub_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
769 {
770   internal_error (__FILE__, __LINE__,
771                   _("elf_gnu_ifunc_resolver_return_stop cannot be reached."));
772 }
773
774 /* See elf_gnu_ifunc_fns for its real implementation.  */
775
776 static const struct gnu_ifunc_fns stub_gnu_ifunc_fns =
777 {
778   stub_gnu_ifunc_resolve_addr,
779   stub_gnu_ifunc_resolve_name,
780   stub_gnu_ifunc_resolver_stop,
781   stub_gnu_ifunc_resolver_return_stop,
782 };
783
784 /* A placeholder for &elf_gnu_ifunc_fns.  */
785
786 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
787
788 /* See minsyms.h.  */
789
790 struct minimal_symbol *
791 lookup_minimal_symbol_and_objfile (const char *name,
792                                    struct objfile **objfile_p)
793 {
794   struct objfile *objfile;
795   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
796
797   ALL_OBJFILES (objfile)
798     {
799       struct minimal_symbol *msym;
800
801       for (msym = objfile->msymbol_hash[hash];
802            msym != NULL;
803            msym = msym->hash_next)
804         {
805           if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
806             {
807               *objfile_p = objfile;
808               return msym;
809             }
810         }
811     }
812
813   return 0;
814 }
815 \f
816
817 /* Return leading symbol character for a BFD.  If BFD is NULL,
818    return the leading symbol character from the main objfile.  */
819
820 static int get_symbol_leading_char (bfd *);
821
822 static int
823 get_symbol_leading_char (bfd *abfd)
824 {
825   if (abfd != NULL)
826     return bfd_get_symbol_leading_char (abfd);
827   if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
828     return bfd_get_symbol_leading_char (symfile_objfile->obfd);
829   return 0;
830 }
831
832 /* See minsyms.h.  */
833
834 void
835 init_minimal_symbol_collection (void)
836 {
837   msym_count = 0;
838   msym_bunch = NULL;
839   /* Note that presetting msym_bunch_index to BUNCH_SIZE causes the
840      first call to save a minimal symbol to allocate the memory for
841      the first bunch.  */
842   msym_bunch_index = BUNCH_SIZE;
843 }
844
845 /* See minsyms.h.  */
846
847 void
848 prim_record_minimal_symbol (const char *name, CORE_ADDR address,
849                             enum minimal_symbol_type ms_type,
850                             struct objfile *objfile)
851 {
852   int section;
853
854   switch (ms_type)
855     {
856     case mst_text:
857     case mst_text_gnu_ifunc:
858     case mst_file_text:
859     case mst_solib_trampoline:
860       section = SECT_OFF_TEXT (objfile);
861       break;
862     case mst_data:
863     case mst_file_data:
864       section = SECT_OFF_DATA (objfile);
865       break;
866     case mst_bss:
867     case mst_file_bss:
868       section = SECT_OFF_BSS (objfile);
869       break;
870     default:
871       section = -1;
872     }
873
874   prim_record_minimal_symbol_and_info (name, address, ms_type,
875                                        section, NULL, objfile);
876 }
877
878 /* See minsyms.h.  */
879
880 struct minimal_symbol *
881 prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
882                                  CORE_ADDR address,
883                                  enum minimal_symbol_type ms_type,
884                                  int section,
885                                  asection *bfd_section,
886                                  struct objfile *objfile)
887 {
888   struct obj_section *obj_section;
889   struct msym_bunch *new;
890   struct minimal_symbol *msymbol;
891
892   /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
893      the minimal symbols, because if there is also another symbol
894      at the same address (e.g. the first function of the file),
895      lookup_minimal_symbol_by_pc would have no way of getting the
896      right one.  */
897   if (ms_type == mst_file_text && name[0] == 'g'
898       && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
899           || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
900     return (NULL);
901
902   /* It's safe to strip the leading char here once, since the name
903      is also stored stripped in the minimal symbol table.  */
904   if (name[0] == get_symbol_leading_char (objfile->obfd))
905     {
906       ++name;
907       --name_len;
908     }
909
910   if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
911     return (NULL);
912
913   if (msym_bunch_index == BUNCH_SIZE)
914     {
915       new = XCALLOC (1, struct msym_bunch);
916       msym_bunch_index = 0;
917       new->next = msym_bunch;
918       msym_bunch = new;
919     }
920   msymbol = &msym_bunch->contents[msym_bunch_index];
921   SYMBOL_SET_LANGUAGE (msymbol, language_auto);
922   SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
923
924   SYMBOL_VALUE_ADDRESS (msymbol) = address;
925   SYMBOL_SECTION (msymbol) = section;
926   SYMBOL_OBJ_SECTION (msymbol) = NULL;
927
928   /* Find obj_section corresponding to bfd_section.  */
929   if (bfd_section)
930     ALL_OBJFILE_OSECTIONS (objfile, obj_section)
931       {
932         if (obj_section->the_bfd_section == bfd_section)
933           {
934             SYMBOL_OBJ_SECTION (msymbol) = obj_section;
935             break;
936           }
937       }
938
939   MSYMBOL_TYPE (msymbol) = ms_type;
940   MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
941   MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
942   MSYMBOL_SIZE (msymbol) = 0;
943
944   /* The hash pointers must be cleared! If they're not,
945      add_minsym_to_hash_table will NOT add this msymbol to the hash table.  */
946   msymbol->hash_next = NULL;
947   msymbol->demangled_hash_next = NULL;
948
949   msym_bunch_index++;
950   msym_count++;
951   OBJSTAT (objfile, n_minsyms++);
952   return msymbol;
953 }
954
955 /* See minsyms.h.  */
956
957 struct minimal_symbol *
958 prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address,
959                                      enum minimal_symbol_type ms_type,
960                                      int section,
961                                      asection *bfd_section,
962                                      struct objfile *objfile)
963 {
964   return prim_record_minimal_symbol_full (name, strlen (name), 1,
965                                           address, ms_type, section,
966                                           bfd_section, objfile);
967 }
968
969 /* Compare two minimal symbols by address and return a signed result based
970    on unsigned comparisons, so that we sort into unsigned numeric order.
971    Within groups with the same address, sort by name.  */
972
973 static int
974 compare_minimal_symbols (const void *fn1p, const void *fn2p)
975 {
976   const struct minimal_symbol *fn1;
977   const struct minimal_symbol *fn2;
978
979   fn1 = (const struct minimal_symbol *) fn1p;
980   fn2 = (const struct minimal_symbol *) fn2p;
981
982   if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
983     {
984       return (-1);              /* addr 1 is less than addr 2.  */
985     }
986   else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
987     {
988       return (1);               /* addr 1 is greater than addr 2.  */
989     }
990   else
991     /* addrs are equal: sort by name */
992     {
993       char *name1 = SYMBOL_LINKAGE_NAME (fn1);
994       char *name2 = SYMBOL_LINKAGE_NAME (fn2);
995
996       if (name1 && name2)       /* both have names */
997         return strcmp (name1, name2);
998       else if (name2)
999         return 1;               /* fn1 has no name, so it is "less".  */
1000       else if (name1)           /* fn2 has no name, so it is "less".  */
1001         return -1;
1002       else
1003         return (0);             /* Neither has a name, so they're equal.  */
1004     }
1005 }
1006
1007 /* Discard the currently collected minimal symbols, if any.  If we wish
1008    to save them for later use, we must have already copied them somewhere
1009    else before calling this function.
1010
1011    FIXME:  We could allocate the minimal symbol bunches on their own
1012    obstack and then simply blow the obstack away when we are done with
1013    it.  Is it worth the extra trouble though?  */
1014
1015 static void
1016 do_discard_minimal_symbols_cleanup (void *arg)
1017 {
1018   struct msym_bunch *next;
1019
1020   while (msym_bunch != NULL)
1021     {
1022       next = msym_bunch->next;
1023       xfree (msym_bunch);
1024       msym_bunch = next;
1025     }
1026 }
1027
1028 /* See minsyms.h.  */
1029
1030 struct cleanup *
1031 make_cleanup_discard_minimal_symbols (void)
1032 {
1033   return make_cleanup (do_discard_minimal_symbols_cleanup, 0);
1034 }
1035
1036
1037
1038 /* Compact duplicate entries out of a minimal symbol table by walking
1039    through the table and compacting out entries with duplicate addresses
1040    and matching names.  Return the number of entries remaining.
1041
1042    On entry, the table resides between msymbol[0] and msymbol[mcount].
1043    On exit, it resides between msymbol[0] and msymbol[result_count].
1044
1045    When files contain multiple sources of symbol information, it is
1046    possible for the minimal symbol table to contain many duplicate entries.
1047    As an example, SVR4 systems use ELF formatted object files, which
1048    usually contain at least two different types of symbol tables (a
1049    standard ELF one and a smaller dynamic linking table), as well as
1050    DWARF debugging information for files compiled with -g.
1051
1052    Without compacting, the minimal symbol table for gdb itself contains
1053    over a 1000 duplicates, about a third of the total table size.  Aside
1054    from the potential trap of not noticing that two successive entries
1055    identify the same location, this duplication impacts the time required
1056    to linearly scan the table, which is done in a number of places.  So we
1057    just do one linear scan here and toss out the duplicates.
1058
1059    Note that we are not concerned here about recovering the space that
1060    is potentially freed up, because the strings themselves are allocated
1061    on the objfile_obstack, and will get automatically freed when the symbol
1062    table is freed.  The caller can free up the unused minimal symbols at
1063    the end of the compacted region if their allocation strategy allows it.
1064
1065    Also note we only go up to the next to last entry within the loop
1066    and then copy the last entry explicitly after the loop terminates.
1067
1068    Since the different sources of information for each symbol may
1069    have different levels of "completeness", we may have duplicates
1070    that have one entry with type "mst_unknown" and the other with a
1071    known type.  So if the one we are leaving alone has type mst_unknown,
1072    overwrite its type with the type from the one we are compacting out.  */
1073
1074 static int
1075 compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
1076                          struct objfile *objfile)
1077 {
1078   struct minimal_symbol *copyfrom;
1079   struct minimal_symbol *copyto;
1080
1081   if (mcount > 0)
1082     {
1083       copyfrom = copyto = msymbol;
1084       while (copyfrom < msymbol + mcount - 1)
1085         {
1086           if (SYMBOL_VALUE_ADDRESS (copyfrom)
1087               == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
1088               && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
1089                          SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
1090             {
1091               if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
1092                 {
1093                   MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
1094                 }
1095               copyfrom++;
1096             }
1097           else
1098             *copyto++ = *copyfrom++;
1099         }
1100       *copyto++ = *copyfrom++;
1101       mcount = copyto - msymbol;
1102     }
1103   return (mcount);
1104 }
1105
1106 /* Build (or rebuild) the minimal symbol hash tables.  This is necessary
1107    after compacting or sorting the table since the entries move around
1108    thus causing the internal minimal_symbol pointers to become jumbled.  */
1109   
1110 static void
1111 build_minimal_symbol_hash_tables (struct objfile *objfile)
1112 {
1113   int i;
1114   struct minimal_symbol *msym;
1115
1116   /* Clear the hash tables.  */
1117   for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
1118     {
1119       objfile->msymbol_hash[i] = 0;
1120       objfile->msymbol_demangled_hash[i] = 0;
1121     }
1122
1123   /* Now, (re)insert the actual entries.  */
1124   for (i = objfile->minimal_symbol_count, msym = objfile->msymbols;
1125        i > 0;
1126        i--, msym++)
1127     {
1128       msym->hash_next = 0;
1129       add_minsym_to_hash_table (msym, objfile->msymbol_hash);
1130
1131       msym->demangled_hash_next = 0;
1132       if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
1133         add_minsym_to_demangled_hash_table (msym,
1134                                             objfile->msymbol_demangled_hash);
1135     }
1136 }
1137
1138 /* Add the minimal symbols in the existing bunches to the objfile's official
1139    minimal symbol table.  In most cases there is no minimal symbol table yet
1140    for this objfile, and the existing bunches are used to create one.  Once
1141    in a while (for shared libraries for example), we add symbols (e.g. common
1142    symbols) to an existing objfile.
1143
1144    Because of the way minimal symbols are collected, we generally have no way
1145    of knowing what source language applies to any particular minimal symbol.
1146    Specifically, we have no way of knowing if the minimal symbol comes from a
1147    C++ compilation unit or not.  So for the sake of supporting cached
1148    demangled C++ names, we have no choice but to try and demangle each new one
1149    that comes in.  If the demangling succeeds, then we assume it is a C++
1150    symbol and set the symbol's language and demangled name fields
1151    appropriately.  Note that in order to avoid unnecessary demanglings, and
1152    allocating obstack space that subsequently can't be freed for the demangled
1153    names, we mark all newly added symbols with language_auto.  After
1154    compaction of the minimal symbols, we go back and scan the entire minimal
1155    symbol table looking for these new symbols.  For each new symbol we attempt
1156    to demangle it, and if successful, record it as a language_cplus symbol
1157    and cache the demangled form on the symbol obstack.  Symbols which don't
1158    demangle are marked as language_unknown symbols, which inhibits future
1159    attempts to demangle them if we later add more minimal symbols.  */
1160
1161 void
1162 install_minimal_symbols (struct objfile *objfile)
1163 {
1164   int bindex;
1165   int mcount;
1166   struct msym_bunch *bunch;
1167   struct minimal_symbol *msymbols;
1168   int alloc_count;
1169
1170   if (msym_count > 0)
1171     {
1172       /* Allocate enough space in the obstack, into which we will gather the
1173          bunches of new and existing minimal symbols, sort them, and then
1174          compact out the duplicate entries.  Once we have a final table,
1175          we will give back the excess space.  */
1176
1177       alloc_count = msym_count + objfile->minimal_symbol_count + 1;
1178       obstack_blank (&objfile->objfile_obstack,
1179                      alloc_count * sizeof (struct minimal_symbol));
1180       msymbols = (struct minimal_symbol *)
1181         obstack_base (&objfile->objfile_obstack);
1182
1183       /* Copy in the existing minimal symbols, if there are any.  */
1184
1185       if (objfile->minimal_symbol_count)
1186         memcpy ((char *) msymbols, (char *) objfile->msymbols,
1187             objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
1188
1189       /* Walk through the list of minimal symbol bunches, adding each symbol
1190          to the new contiguous array of symbols.  Note that we start with the
1191          current, possibly partially filled bunch (thus we use the current
1192          msym_bunch_index for the first bunch we copy over), and thereafter
1193          each bunch is full.  */
1194
1195       mcount = objfile->minimal_symbol_count;
1196
1197       for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
1198         {
1199           for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
1200             msymbols[mcount] = bunch->contents[bindex];
1201           msym_bunch_index = BUNCH_SIZE;
1202         }
1203
1204       /* Sort the minimal symbols by address.  */
1205
1206       qsort (msymbols, mcount, sizeof (struct minimal_symbol),
1207              compare_minimal_symbols);
1208
1209       /* Compact out any duplicates, and free up whatever space we are
1210          no longer using.  */
1211
1212       mcount = compact_minimal_symbols (msymbols, mcount, objfile);
1213
1214       obstack_blank (&objfile->objfile_obstack,
1215                (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
1216       msymbols = (struct minimal_symbol *)
1217         obstack_finish (&objfile->objfile_obstack);
1218
1219       /* We also terminate the minimal symbol table with a "null symbol",
1220          which is *not* included in the size of the table.  This makes it
1221          easier to find the end of the table when we are handed a pointer
1222          to some symbol in the middle of it.  Zero out the fields in the
1223          "null symbol" allocated at the end of the array.  Note that the
1224          symbol count does *not* include this null symbol, which is why it
1225          is indexed by mcount and not mcount-1.  */
1226
1227       SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL;
1228       SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
1229       MSYMBOL_TARGET_FLAG_1 (&msymbols[mcount]) = 0;
1230       MSYMBOL_TARGET_FLAG_2 (&msymbols[mcount]) = 0;
1231       MSYMBOL_SIZE (&msymbols[mcount]) = 0;
1232       MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
1233       SYMBOL_SET_LANGUAGE (&msymbols[mcount], language_unknown);
1234
1235       /* Attach the minimal symbol table to the specified objfile.
1236          The strings themselves are also located in the objfile_obstack
1237          of this objfile.  */
1238
1239       objfile->minimal_symbol_count = mcount;
1240       objfile->msymbols = msymbols;
1241
1242       /* Try to guess the appropriate C++ ABI by looking at the names 
1243          of the minimal symbols in the table.  */
1244       {
1245         int i;
1246
1247         for (i = 0; i < mcount; i++)
1248           {
1249             /* If a symbol's name starts with _Z and was successfully
1250                demangled, then we can assume we've found a GNU v3 symbol.
1251                For now we set the C++ ABI globally; if the user is
1252                mixing ABIs then the user will need to "set cp-abi"
1253                manually.  */
1254             const char *name = SYMBOL_LINKAGE_NAME (&objfile->msymbols[i]);
1255
1256             if (name[0] == '_' && name[1] == 'Z'
1257                 && SYMBOL_DEMANGLED_NAME (&objfile->msymbols[i]) != NULL)
1258               {
1259                 set_cp_abi_as_auto_default ("gnu-v3");
1260                 break;
1261               }
1262           }
1263       }
1264
1265       /* Now build the hash tables; we can't do this incrementally
1266          at an earlier point since we weren't finished with the obstack
1267          yet.  (And if the msymbol obstack gets moved, all the internal
1268          pointers to other msymbols need to be adjusted.)  */
1269       build_minimal_symbol_hash_tables (objfile);
1270     }
1271 }
1272
1273 /* See minsyms.h.  */
1274
1275 void
1276 terminate_minimal_symbol_table (struct objfile *objfile)
1277 {
1278   if (! objfile->msymbols)
1279     objfile->msymbols = ((struct minimal_symbol *)
1280                          obstack_alloc (&objfile->objfile_obstack,
1281                                         sizeof (objfile->msymbols[0])));
1282
1283   {
1284     struct minimal_symbol *m
1285       = &objfile->msymbols[objfile->minimal_symbol_count];
1286
1287     memset (m, 0, sizeof (*m));
1288     /* Don't rely on these enumeration values being 0's.  */
1289     MSYMBOL_TYPE (m) = mst_unknown;
1290     SYMBOL_SET_LANGUAGE (m, language_unknown);
1291   }
1292 }
1293
1294 /* Sort all the minimal symbols in OBJFILE.  */
1295
1296 void
1297 msymbols_sort (struct objfile *objfile)
1298 {
1299   qsort (objfile->msymbols, objfile->minimal_symbol_count,
1300          sizeof (struct minimal_symbol), compare_minimal_symbols);
1301   build_minimal_symbol_hash_tables (objfile);
1302 }
1303
1304 /* See minsyms.h.  */
1305
1306 struct minimal_symbol *
1307 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
1308 {
1309   struct obj_section *section = find_pc_section (pc);
1310   struct minimal_symbol *msymbol;
1311
1312   if (section == NULL)
1313     return NULL;
1314   msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
1315
1316   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
1317     return msymbol;
1318   return NULL;
1319 }
1320
1321 /* If PC is in a shared library trampoline code stub, return the
1322    address of the `real' function belonging to the stub.
1323    Return 0 if PC is not in a trampoline code stub or if the real
1324    function is not found in the minimal symbol table.
1325
1326    We may fail to find the right function if a function with the
1327    same name is defined in more than one shared library, but this
1328    is considered bad programming style.  We could return 0 if we find
1329    a duplicate function in case this matters someday.  */
1330
1331 CORE_ADDR
1332 find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
1333 {
1334   struct objfile *objfile;
1335   struct minimal_symbol *msymbol;
1336   struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1337
1338   if (tsymbol != NULL)
1339     {
1340       ALL_MSYMBOLS (objfile, msymbol)
1341       {
1342         if ((MSYMBOL_TYPE (msymbol) == mst_text
1343             || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
1344             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1345                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1346           return SYMBOL_VALUE_ADDRESS (msymbol);
1347
1348         /* Also handle minimal symbols pointing to function descriptors.  */
1349         if (MSYMBOL_TYPE (msymbol) == mst_data
1350             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1351                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1352           {
1353             CORE_ADDR func;
1354
1355             func = gdbarch_convert_from_func_ptr_addr
1356                     (get_objfile_arch (objfile),
1357                      SYMBOL_VALUE_ADDRESS (msymbol),
1358                      &current_target);
1359
1360             /* Ignore data symbols that are not function descriptors.  */
1361             if (func != SYMBOL_VALUE_ADDRESS (msymbol))
1362               return func;
1363           }
1364       }
1365     }
1366   return 0;
1367 }