* ada-lang.c (ada_decode_symbol): Check and set 'ada_mangled'.
[external/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 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   enum minimal_symbol_type want_type, other_type;
489
490   want_type = want_trampoline ? mst_solib_trampoline : mst_text;
491   other_type = want_trampoline ? mst_text : mst_solib_trampoline;
492
493   /* We can not require the symbol found to be in section, because
494      e.g. IRIX 6.5 mdebug relies on this code returning an absolute
495      symbol - but find_pc_section won't return an absolute section and
496      hence the code below would skip over absolute symbols.  We can
497      still take advantage of the call to find_pc_section, though - the
498      object file still must match.  In case we have separate debug
499      files, search both the file and its separate debug file.  There's
500      no telling which one will have the minimal symbols.  */
501
502   gdb_assert (section != NULL);
503
504   for (objfile = section->objfile;
505        objfile != NULL;
506        objfile = objfile_separate_debug_iterate (section->objfile, objfile))
507     {
508       /* If this objfile has a minimal symbol table, go search it using
509          a binary search.  Note that a minimal symbol table always consists
510          of at least two symbols, a "real" symbol and the terminating
511          "null symbol".  If there are no real symbols, then there is no
512          minimal symbol table at all.  */
513
514       if (objfile->minimal_symbol_count > 0)
515         {
516           int best_zero_sized = -1;
517
518           msymbol = objfile->msymbols;
519           lo = 0;
520           hi = objfile->minimal_symbol_count - 1;
521
522           /* This code assumes that the minimal symbols are sorted by
523              ascending address values.  If the pc value is greater than or
524              equal to the first symbol's address, then some symbol in this
525              minimal symbol table is a suitable candidate for being the
526              "best" symbol.  This includes the last real symbol, for cases
527              where the pc value is larger than any address in this vector.
528
529              By iterating until the address associated with the current
530              hi index (the endpoint of the test interval) is less than
531              or equal to the desired pc value, we accomplish two things:
532              (1) the case where the pc value is larger than any minimal
533              symbol address is trivially solved, (2) the address associated
534              with the hi index is always the one we want when the interation
535              terminates.  In essence, we are iterating the test interval
536              down until the pc value is pushed out of it from the high end.
537
538              Warning: this code is trickier than it would appear at first.  */
539
540           /* Should also require that pc is <= end of objfile.  FIXME!  */
541           if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
542             {
543               while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
544                 {
545                   /* pc is still strictly less than highest address.  */
546                   /* Note "new" will always be >= lo.  */
547                   new = (lo + hi) / 2;
548                   if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
549                       (lo == new))
550                     {
551                       hi = new;
552                     }
553                   else
554                     {
555                       lo = new;
556                     }
557                 }
558
559               /* If we have multiple symbols at the same address, we want
560                  hi to point to the last one.  That way we can find the
561                  right symbol if it has an index greater than hi.  */
562               while (hi < objfile->minimal_symbol_count - 1
563                      && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
564                          == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
565                 hi++;
566
567               /* Skip various undesirable symbols.  */
568               while (hi >= 0)
569                 {
570                   /* Skip any absolute symbols.  This is apparently
571                      what adb and dbx do, and is needed for the CM-5.
572                      There are two known possible problems: (1) on
573                      ELF, apparently end, edata, etc. are absolute.
574                      Not sure ignoring them here is a big deal, but if
575                      we want to use them, the fix would go in
576                      elfread.c.  (2) I think shared library entry
577                      points on the NeXT are absolute.  If we want
578                      special handling for this it probably should be
579                      triggered by a special mst_abs_or_lib or some
580                      such.  */
581
582                   if (MSYMBOL_TYPE (&msymbol[hi]) == mst_abs)
583                     {
584                       hi--;
585                       continue;
586                     }
587
588                   /* If SECTION was specified, skip any symbol from
589                      wrong section.  */
590                   if (section
591                       /* Some types of debug info, such as COFF,
592                          don't fill the bfd_section member, so don't
593                          throw away symbols on those platforms.  */
594                       && SYMBOL_OBJ_SECTION (&msymbol[hi]) != NULL
595                       && (!matching_obj_sections
596                           (SYMBOL_OBJ_SECTION (&msymbol[hi]), section)))
597                     {
598                       hi--;
599                       continue;
600                     }
601
602                   /* If we are looking for a trampoline and this is a
603                      text symbol, or the other way around, check the
604                      preceding symbol too.  If they are otherwise
605                      identical prefer that one.  */
606                   if (hi > 0
607                       && MSYMBOL_TYPE (&msymbol[hi]) == other_type
608                       && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
609                       && (MSYMBOL_SIZE (&msymbol[hi])
610                           == MSYMBOL_SIZE (&msymbol[hi - 1]))
611                       && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
612                           == SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
613                       && (SYMBOL_OBJ_SECTION (&msymbol[hi])
614                           == SYMBOL_OBJ_SECTION (&msymbol[hi - 1])))
615                     {
616                       hi--;
617                       continue;
618                     }
619
620                   /* If the minimal symbol has a zero size, save it
621                      but keep scanning backwards looking for one with
622                      a non-zero size.  A zero size may mean that the
623                      symbol isn't an object or function (e.g. a
624                      label), or it may just mean that the size was not
625                      specified.  */
626                   if (MSYMBOL_SIZE (&msymbol[hi]) == 0
627                       && best_zero_sized == -1)
628                     {
629                       best_zero_sized = hi;
630                       hi--;
631                       continue;
632                     }
633
634                   /* If we are past the end of the current symbol, try
635                      the previous symbol if it has a larger overlapping
636                      size.  This happens on i686-pc-linux-gnu with glibc;
637                      the nocancel variants of system calls are inside
638                      the cancellable variants, but both have sizes.  */
639                   if (hi > 0
640                       && MSYMBOL_SIZE (&msymbol[hi]) != 0
641                       && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
642                                 + MSYMBOL_SIZE (&msymbol[hi]))
643                       && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
644                                + MSYMBOL_SIZE (&msymbol[hi - 1])))
645                     {
646                       hi--;
647                       continue;
648                     }
649
650                   /* Otherwise, this symbol must be as good as we're going
651                      to get.  */
652                   break;
653                 }
654
655               /* If HI has a zero size, and best_zero_sized is set,
656                  then we had two or more zero-sized symbols; prefer
657                  the first one we found (which may have a higher
658                  address).  Also, if we ran off the end, be sure
659                  to back up.  */
660               if (best_zero_sized != -1
661                   && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0))
662                 hi = best_zero_sized;
663
664               /* If the minimal symbol has a non-zero size, and this
665                  PC appears to be outside the symbol's contents, then
666                  refuse to use this symbol.  If we found a zero-sized
667                  symbol with an address greater than this symbol's,
668                  use that instead.  We assume that if symbols have
669                  specified sizes, they do not overlap.  */
670
671               if (hi >= 0
672                   && MSYMBOL_SIZE (&msymbol[hi]) != 0
673                   && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
674                             + MSYMBOL_SIZE (&msymbol[hi])))
675                 {
676                   if (best_zero_sized != -1)
677                     hi = best_zero_sized;
678                   else
679                     /* Go on to the next object file.  */
680                     continue;
681                 }
682
683               /* The minimal symbol indexed by hi now is the best one in this
684                  objfile's minimal symbol table.  See if it is the best one
685                  overall.  */
686
687               if (hi >= 0
688                   && ((best_symbol == NULL) ||
689                       (SYMBOL_VALUE_ADDRESS (best_symbol) <
690                        SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
691                 {
692                   best_symbol = &msymbol[hi];
693                 }
694             }
695         }
696     }
697   return (best_symbol);
698 }
699
700 struct minimal_symbol *
701 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
702 {
703   if (section == NULL)
704     {
705       /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
706          force the section but that (well unless you're doing overlay
707          debugging) always returns NULL making the call somewhat useless.  */
708       section = find_pc_section (pc);
709       if (section == NULL)
710         return NULL;
711     }
712   return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
713 }
714
715 /* See minsyms.h.  */
716
717 struct minimal_symbol *
718 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
719 {
720   return lookup_minimal_symbol_by_pc_section (pc, NULL);
721 }
722
723 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver.  */
724
725 int
726 in_gnu_ifunc_stub (CORE_ADDR pc)
727 {
728   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
729
730   return msymbol && MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc;
731 }
732
733 /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
734
735 static CORE_ADDR
736 stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
737 {
738   error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without "
739            "the ELF support compiled in."),
740          paddress (gdbarch, pc));
741 }
742
743 /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
744
745 static int
746 stub_gnu_ifunc_resolve_name (const char *function_name,
747                              CORE_ADDR *function_address_p)
748 {
749   error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without "
750            "the ELF support compiled in."),
751          function_name);
752 }
753
754 /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
755
756 static void
757 stub_gnu_ifunc_resolver_stop (struct breakpoint *b)
758 {
759   internal_error (__FILE__, __LINE__,
760                   _("elf_gnu_ifunc_resolver_stop cannot be reached."));
761 }
762
763 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
764
765 static void
766 stub_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
767 {
768   internal_error (__FILE__, __LINE__,
769                   _("elf_gnu_ifunc_resolver_return_stop cannot be reached."));
770 }
771
772 /* See elf_gnu_ifunc_fns for its real implementation.  */
773
774 static const struct gnu_ifunc_fns stub_gnu_ifunc_fns =
775 {
776   stub_gnu_ifunc_resolve_addr,
777   stub_gnu_ifunc_resolve_name,
778   stub_gnu_ifunc_resolver_stop,
779   stub_gnu_ifunc_resolver_return_stop,
780 };
781
782 /* A placeholder for &elf_gnu_ifunc_fns.  */
783
784 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
785
786 /* See minsyms.h.  */
787
788 struct minimal_symbol *
789 lookup_minimal_symbol_and_objfile (const char *name,
790                                    struct objfile **objfile_p)
791 {
792   struct objfile *objfile;
793   unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
794
795   ALL_OBJFILES (objfile)
796     {
797       struct minimal_symbol *msym;
798
799       for (msym = objfile->msymbol_hash[hash];
800            msym != NULL;
801            msym = msym->hash_next)
802         {
803           if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
804             {
805               *objfile_p = objfile;
806               return msym;
807             }
808         }
809     }
810
811   return 0;
812 }
813 \f
814
815 /* Return leading symbol character for a BFD.  If BFD is NULL,
816    return the leading symbol character from the main objfile.  */
817
818 static int get_symbol_leading_char (bfd *);
819
820 static int
821 get_symbol_leading_char (bfd *abfd)
822 {
823   if (abfd != NULL)
824     return bfd_get_symbol_leading_char (abfd);
825   if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
826     return bfd_get_symbol_leading_char (symfile_objfile->obfd);
827   return 0;
828 }
829
830 /* See minsyms.h.  */
831
832 void
833 init_minimal_symbol_collection (void)
834 {
835   msym_count = 0;
836   msym_bunch = NULL;
837   /* Note that presetting msym_bunch_index to BUNCH_SIZE causes the
838      first call to save a minimal symbol to allocate the memory for
839      the first bunch.  */
840   msym_bunch_index = BUNCH_SIZE;
841 }
842
843 /* See minsyms.h.  */
844
845 void
846 prim_record_minimal_symbol (const char *name, CORE_ADDR address,
847                             enum minimal_symbol_type ms_type,
848                             struct objfile *objfile)
849 {
850   int section;
851
852   switch (ms_type)
853     {
854     case mst_text:
855     case mst_text_gnu_ifunc:
856     case mst_file_text:
857     case mst_solib_trampoline:
858       section = SECT_OFF_TEXT (objfile);
859       break;
860     case mst_data:
861     case mst_file_data:
862       section = SECT_OFF_DATA (objfile);
863       break;
864     case mst_bss:
865     case mst_file_bss:
866       section = SECT_OFF_BSS (objfile);
867       break;
868     default:
869       section = -1;
870     }
871
872   prim_record_minimal_symbol_and_info (name, address, ms_type,
873                                        section, NULL, objfile);
874 }
875
876 /* See minsyms.h.  */
877
878 struct minimal_symbol *
879 prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
880                                  CORE_ADDR address,
881                                  enum minimal_symbol_type ms_type,
882                                  int section,
883                                  asection *bfd_section,
884                                  struct objfile *objfile)
885 {
886   struct obj_section *obj_section;
887   struct msym_bunch *new;
888   struct minimal_symbol *msymbol;
889
890   /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
891      the minimal symbols, because if there is also another symbol
892      at the same address (e.g. the first function of the file),
893      lookup_minimal_symbol_by_pc would have no way of getting the
894      right one.  */
895   if (ms_type == mst_file_text && name[0] == 'g'
896       && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
897           || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
898     return (NULL);
899
900   /* It's safe to strip the leading char here once, since the name
901      is also stored stripped in the minimal symbol table.  */
902   if (name[0] == get_symbol_leading_char (objfile->obfd))
903     {
904       ++name;
905       --name_len;
906     }
907
908   if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
909     return (NULL);
910
911   if (msym_bunch_index == BUNCH_SIZE)
912     {
913       new = XCALLOC (1, struct msym_bunch);
914       msym_bunch_index = 0;
915       new->next = msym_bunch;
916       msym_bunch = new;
917     }
918   msymbol = &msym_bunch->contents[msym_bunch_index];
919   SYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
920   SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
921
922   SYMBOL_VALUE_ADDRESS (msymbol) = address;
923   SYMBOL_SECTION (msymbol) = section;
924   SYMBOL_OBJ_SECTION (msymbol) = NULL;
925
926   /* Find obj_section corresponding to bfd_section.  */
927   if (bfd_section)
928     ALL_OBJFILE_OSECTIONS (objfile, obj_section)
929       {
930         if (obj_section->the_bfd_section == bfd_section)
931           {
932             SYMBOL_OBJ_SECTION (msymbol) = obj_section;
933             break;
934           }
935       }
936
937   MSYMBOL_TYPE (msymbol) = ms_type;
938   MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
939   MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
940   /* Do not use the SET_MSYMBOL_SIZE macro to initialize the size,
941      as it would also set the has_size flag.  */
942   msymbol->size = 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       const char *name1 = SYMBOL_LINKAGE_NAME (fn1);
994       const 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       if (symtab_create_debug)
1173         {
1174           fprintf_unfiltered (gdb_stdlog,
1175                               "Installing %d minimal symbols of objfile %s.\n",
1176                               msym_count, objfile->name);
1177         }
1178
1179       /* Allocate enough space in the obstack, into which we will gather the
1180          bunches of new and existing minimal symbols, sort them, and then
1181          compact out the duplicate entries.  Once we have a final table,
1182          we will give back the excess space.  */
1183
1184       alloc_count = msym_count + objfile->minimal_symbol_count + 1;
1185       obstack_blank (&objfile->objfile_obstack,
1186                      alloc_count * sizeof (struct minimal_symbol));
1187       msymbols = (struct minimal_symbol *)
1188         obstack_base (&objfile->objfile_obstack);
1189
1190       /* Copy in the existing minimal symbols, if there are any.  */
1191
1192       if (objfile->minimal_symbol_count)
1193         memcpy ((char *) msymbols, (char *) objfile->msymbols,
1194             objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
1195
1196       /* Walk through the list of minimal symbol bunches, adding each symbol
1197          to the new contiguous array of symbols.  Note that we start with the
1198          current, possibly partially filled bunch (thus we use the current
1199          msym_bunch_index for the first bunch we copy over), and thereafter
1200          each bunch is full.  */
1201
1202       mcount = objfile->minimal_symbol_count;
1203
1204       for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
1205         {
1206           for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
1207             msymbols[mcount] = bunch->contents[bindex];
1208           msym_bunch_index = BUNCH_SIZE;
1209         }
1210
1211       /* Sort the minimal symbols by address.  */
1212
1213       qsort (msymbols, mcount, sizeof (struct minimal_symbol),
1214              compare_minimal_symbols);
1215
1216       /* Compact out any duplicates, and free up whatever space we are
1217          no longer using.  */
1218
1219       mcount = compact_minimal_symbols (msymbols, mcount, objfile);
1220
1221       obstack_blank (&objfile->objfile_obstack,
1222                (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
1223       msymbols = (struct minimal_symbol *)
1224         obstack_finish (&objfile->objfile_obstack);
1225
1226       /* We also terminate the minimal symbol table with a "null symbol",
1227          which is *not* included in the size of the table.  This makes it
1228          easier to find the end of the table when we are handed a pointer
1229          to some symbol in the middle of it.  Zero out the fields in the
1230          "null symbol" allocated at the end of the array.  Note that the
1231          symbol count does *not* include this null symbol, which is why it
1232          is indexed by mcount and not mcount-1.  */
1233
1234       memset (&msymbols[mcount], 0, sizeof (struct minimal_symbol));
1235
1236       /* Attach the minimal symbol table to the specified objfile.
1237          The strings themselves are also located in the objfile_obstack
1238          of this objfile.  */
1239
1240       objfile->minimal_symbol_count = mcount;
1241       objfile->msymbols = msymbols;
1242
1243       /* Now build the hash tables; we can't do this incrementally
1244          at an earlier point since we weren't finished with the obstack
1245          yet.  (And if the msymbol obstack gets moved, all the internal
1246          pointers to other msymbols need to be adjusted.)  */
1247       build_minimal_symbol_hash_tables (objfile);
1248     }
1249 }
1250
1251 /* See minsyms.h.  */
1252
1253 void
1254 terminate_minimal_symbol_table (struct objfile *objfile)
1255 {
1256   if (! objfile->msymbols)
1257     objfile->msymbols = ((struct minimal_symbol *)
1258                          obstack_alloc (&objfile->objfile_obstack,
1259                                         sizeof (objfile->msymbols[0])));
1260
1261   {
1262     struct minimal_symbol *m
1263       = &objfile->msymbols[objfile->minimal_symbol_count];
1264
1265     memset (m, 0, sizeof (*m));
1266     /* Don't rely on these enumeration values being 0's.  */
1267     MSYMBOL_TYPE (m) = mst_unknown;
1268     SYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
1269   }
1270 }
1271
1272 /* Sort all the minimal symbols in OBJFILE.  */
1273
1274 void
1275 msymbols_sort (struct objfile *objfile)
1276 {
1277   qsort (objfile->msymbols, objfile->minimal_symbol_count,
1278          sizeof (struct minimal_symbol), compare_minimal_symbols);
1279   build_minimal_symbol_hash_tables (objfile);
1280 }
1281
1282 /* Check if PC is in a shared library trampoline code stub.
1283    Return minimal symbol for the trampoline entry or NULL if PC is not
1284    in a trampoline code stub.  */
1285
1286 static struct minimal_symbol *
1287 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
1288 {
1289   struct obj_section *section = find_pc_section (pc);
1290   struct minimal_symbol *msymbol;
1291
1292   if (section == NULL)
1293     return NULL;
1294   msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
1295
1296   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
1297     return msymbol;
1298   return NULL;
1299 }
1300
1301 /* If PC is in a shared library trampoline code stub, return the
1302    address of the `real' function belonging to the stub.
1303    Return 0 if PC is not in a trampoline code stub or if the real
1304    function is not found in the minimal symbol table.
1305
1306    We may fail to find the right function if a function with the
1307    same name is defined in more than one shared library, but this
1308    is considered bad programming style.  We could return 0 if we find
1309    a duplicate function in case this matters someday.  */
1310
1311 CORE_ADDR
1312 find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
1313 {
1314   struct objfile *objfile;
1315   struct minimal_symbol *msymbol;
1316   struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1317
1318   if (tsymbol != NULL)
1319     {
1320       ALL_MSYMBOLS (objfile, msymbol)
1321       {
1322         if ((MSYMBOL_TYPE (msymbol) == mst_text
1323             || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
1324             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1325                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1326           return SYMBOL_VALUE_ADDRESS (msymbol);
1327
1328         /* Also handle minimal symbols pointing to function descriptors.  */
1329         if (MSYMBOL_TYPE (msymbol) == mst_data
1330             && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1331                        SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1332           {
1333             CORE_ADDR func;
1334
1335             func = gdbarch_convert_from_func_ptr_addr
1336                     (get_objfile_arch (objfile),
1337                      SYMBOL_VALUE_ADDRESS (msymbol),
1338                      &current_target);
1339
1340             /* Ignore data symbols that are not function descriptors.  */
1341             if (func != SYMBOL_VALUE_ADDRESS (msymbol))
1342               return func;
1343           }
1344       }
1345     }
1346   return 0;
1347 }