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