1 /* GDB routines for manipulating the minimal symbol tables.
2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
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.
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.
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/>. */
21 /* This file contains support routines for creating, manipulating, and
22 destroying minimal symbol tables.
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.
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.
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. */
43 #include "filenames.h"
50 #include "cp-support.h"
52 #include "cli/cli-utils.h"
59 msymbol_is_text (minimal_symbol *msymbol)
61 switch (MSYMBOL_TYPE (msymbol))
64 case mst_text_gnu_ifunc:
65 case mst_solib_trampoline:
73 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
74 At the end, copy them all into one newly allocated location on an objfile's
75 per-BFD storage obstack. */
77 #define BUNCH_SIZE 127
81 struct msym_bunch *next;
82 struct minimal_symbol contents[BUNCH_SIZE];
88 msymbol_hash_iw (const char *string)
90 unsigned int hash = 0;
92 while (*string && *string != '(')
94 string = skip_spaces (string);
95 if (*string && *string != '(')
97 hash = SYMBOL_HASH_NEXT (hash, *string);
107 msymbol_hash (const char *string)
109 unsigned int hash = 0;
111 for (; *string; ++string)
112 hash = SYMBOL_HASH_NEXT (hash, *string);
116 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */
118 add_minsym_to_hash_table (struct minimal_symbol *sym,
119 struct minimal_symbol **table)
121 if (sym->hash_next == NULL)
124 = msymbol_hash (MSYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
126 sym->hash_next = table[hash];
131 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
134 add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
135 struct objfile *objfile)
137 if (sym->demangled_hash_next == NULL)
139 unsigned int hash = search_name_hash (MSYMBOL_LANGUAGE (sym),
140 MSYMBOL_SEARCH_NAME (sym));
142 auto &vec = objfile->per_bfd->demangled_hash_languages;
143 auto it = std::lower_bound (vec.begin (), vec.end (),
144 MSYMBOL_LANGUAGE (sym));
145 if (it == vec.end () || *it != MSYMBOL_LANGUAGE (sym))
146 vec.insert (it, MSYMBOL_LANGUAGE (sym));
148 struct minimal_symbol **table
149 = objfile->per_bfd->msymbol_demangled_hash;
150 unsigned int hash_index = hash % MINIMAL_SYMBOL_HASH_SIZE;
151 sym->demangled_hash_next = table[hash_index];
152 table[hash_index] = sym;
156 /* Worker object for lookup_minimal_symbol. Stores temporary results
157 while walking the symbol tables. */
159 struct found_minimal_symbols
161 /* External symbols are best. */
162 bound_minimal_symbol external_symbol {};
164 /* File-local symbols are next best. */
165 bound_minimal_symbol file_symbol {};
167 /* Symbols for shared library trampolines are next best. */
168 bound_minimal_symbol trampoline_symbol {};
170 /* Called when a symbol name matches. Check if the minsym is a
171 better type than what we had already found, and record it in one
172 of the members fields if so. Returns true if we collected the
173 real symbol, in which case we can stop searching. */
174 bool maybe_collect (const char *sfile, objfile *objf,
175 minimal_symbol *msymbol);
178 /* See declaration above. */
181 found_minimal_symbols::maybe_collect (const char *sfile,
182 struct objfile *objfile,
183 minimal_symbol *msymbol)
185 switch (MSYMBOL_TYPE (msymbol))
191 || filename_cmp (msymbol->filename, sfile) == 0)
193 file_symbol.minsym = msymbol;
194 file_symbol.objfile = objfile;
198 case mst_solib_trampoline:
200 /* If a trampoline symbol is found, we prefer to keep
201 looking for the *real* symbol. If the actual symbol
202 is not found, then we'll use the trampoline
204 if (trampoline_symbol.minsym == NULL)
206 trampoline_symbol.minsym = msymbol;
207 trampoline_symbol.objfile = objfile;
213 external_symbol.minsym = msymbol;
214 external_symbol.objfile = objfile;
215 /* We have the real symbol. No use looking further. */
223 /* Walk the mangled name hash table, and pass each symbol whose name
224 matches LOOKUP_NAME according to NAMECMP to FOUND. */
227 lookup_minimal_symbol_mangled (const char *lookup_name,
229 struct objfile *objfile,
230 struct minimal_symbol **table,
232 int (*namecmp) (const char *, const char *),
233 found_minimal_symbols &found)
235 for (minimal_symbol *msymbol = table[hash];
237 msymbol = msymbol->hash_next)
239 const char *symbol_name = MSYMBOL_LINKAGE_NAME (msymbol);
241 if (namecmp (symbol_name, lookup_name) == 0
242 && found.maybe_collect (sfile, objfile, msymbol))
247 /* Walk the demangled name hash table, and pass each symbol whose name
248 matches LOOKUP_NAME according to MATCHER to FOUND. */
251 lookup_minimal_symbol_demangled (const lookup_name_info &lookup_name,
253 struct objfile *objfile,
254 struct minimal_symbol **table,
256 symbol_name_matcher_ftype *matcher,
257 found_minimal_symbols &found)
259 for (minimal_symbol *msymbol = table[hash];
261 msymbol = msymbol->demangled_hash_next)
263 const char *symbol_name = MSYMBOL_SEARCH_NAME (msymbol);
265 if (matcher (symbol_name, lookup_name, NULL)
266 && found.maybe_collect (sfile, objfile, msymbol))
271 /* Look through all the current minimal symbol tables and find the
272 first minimal symbol that matches NAME. If OBJF is non-NULL, limit
273 the search to that objfile. If SFILE is non-NULL, the only file-scope
274 symbols considered will be from that source file (global symbols are
275 still preferred). Returns a pointer to the minimal symbol that
276 matches, or NULL if no match is found.
278 Note: One instance where there may be duplicate minimal symbols with
279 the same name is when the symbol tables for a shared library and the
280 symbol tables for an executable contain global symbols with the same
281 names (the dynamic linker deals with the duplication).
283 It's also possible to have minimal symbols with different mangled
284 names, but identical demangled names. For example, the GNU C++ v3
285 ABI requires the generation of two (or perhaps three) copies of
286 constructor functions --- "in-charge", "not-in-charge", and
287 "allocate" copies; destructors may be duplicated as well.
288 Obviously, there must be distinct mangled names for each of these,
289 but the demangled names are all the same: S::S or S::~S. */
291 struct bound_minimal_symbol
292 lookup_minimal_symbol (const char *name, const char *sfile,
293 struct objfile *objf)
295 struct objfile *objfile;
296 found_minimal_symbols found;
298 unsigned int mangled_hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
301 = (case_sensitivity == case_sensitive_on
306 sfile = lbasename (sfile);
308 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
310 for (objfile = object_files;
311 objfile != NULL && found.external_symbol.minsym == NULL;
312 objfile = objfile->next)
314 struct minimal_symbol *msymbol;
316 if (objf == NULL || objf == objfile
317 || objf == objfile->separate_debug_objfile_backlink)
319 if (symbol_lookup_debug)
321 fprintf_unfiltered (gdb_stdlog,
322 "lookup_minimal_symbol (%s, %s, %s)\n",
323 name, sfile != NULL ? sfile : "NULL",
324 objfile_debug_name (objfile));
327 /* Do two passes: the first over the ordinary hash table,
328 and the second over the demangled hash table. */
329 lookup_minimal_symbol_mangled (name, sfile, objfile,
330 objfile->per_bfd->msymbol_hash,
331 mangled_hash, mangled_cmp, found);
333 /* If not found, try the demangled hash table. */
334 if (found.external_symbol.minsym == NULL)
336 /* Once for each language in the demangled hash names
337 table (usually just zero or one languages). */
338 for (auto lang : objfile->per_bfd->demangled_hash_languages)
341 = (lookup_name.search_name_hash (lang)
342 % MINIMAL_SYMBOL_HASH_SIZE);
344 symbol_name_matcher_ftype *match
345 = language_get_symbol_name_matcher (language_def (lang),
347 struct minimal_symbol **msymbol_demangled_hash
348 = objfile->per_bfd->msymbol_demangled_hash;
350 lookup_minimal_symbol_demangled (lookup_name, sfile, objfile,
351 msymbol_demangled_hash,
354 if (found.external_symbol.minsym != NULL)
361 /* External symbols are best. */
362 if (found.external_symbol.minsym != NULL)
364 if (symbol_lookup_debug)
366 minimal_symbol *minsym = found.external_symbol.minsym;
368 fprintf_unfiltered (gdb_stdlog,
369 "lookup_minimal_symbol (...) = %s (external)\n",
370 host_address_to_string (minsym));
372 return found.external_symbol;
375 /* File-local symbols are next best. */
376 if (found.file_symbol.minsym != NULL)
378 if (symbol_lookup_debug)
380 minimal_symbol *minsym = found.file_symbol.minsym;
382 fprintf_unfiltered (gdb_stdlog,
383 "lookup_minimal_symbol (...) = %s (file-local)\n",
384 host_address_to_string (minsym));
386 return found.file_symbol;
389 /* Symbols for shared library trampolines are next best. */
390 if (found.trampoline_symbol.minsym != NULL)
392 if (symbol_lookup_debug)
394 minimal_symbol *minsym = found.trampoline_symbol.minsym;
396 fprintf_unfiltered (gdb_stdlog,
397 "lookup_minimal_symbol (...) = %s (trampoline)\n",
398 host_address_to_string (minsym));
401 return found.trampoline_symbol;
405 if (symbol_lookup_debug)
406 fprintf_unfiltered (gdb_stdlog, "lookup_minimal_symbol (...) = NULL\n");
412 struct bound_minimal_symbol
413 lookup_bound_minimal_symbol (const char *name)
415 return lookup_minimal_symbol (name, NULL, NULL);
418 /* See common/symbol.h. */
421 find_minimal_symbol_address (const char *name, CORE_ADDR *addr,
422 struct objfile *objfile)
424 struct bound_minimal_symbol sym
425 = lookup_minimal_symbol (name, NULL, objfile);
427 if (sym.minsym != NULL)
428 *addr = BMSYMBOL_VALUE_ADDRESS (sym);
430 return sym.minsym == NULL;
436 iterate_over_minimal_symbols (struct objfile *objf,
437 const lookup_name_info &lookup_name,
438 void (*callback) (struct minimal_symbol *,
443 /* The first pass is over the ordinary hash table. */
445 const char *name = lookup_name.name ().c_str ();
446 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
448 = (case_sensitivity == case_sensitive_on
452 for (minimal_symbol *iter = objf->per_bfd->msymbol_hash[hash];
454 iter = iter->hash_next)
456 if (mangled_cmp (MSYMBOL_LINKAGE_NAME (iter), name) == 0)
457 (*callback) (iter, user_data);
461 /* The second pass is over the demangled table. Once for each
462 language in the demangled hash names table (usually just zero or
464 for (auto lang : objf->per_bfd->demangled_hash_languages)
466 const language_defn *lang_def = language_def (lang);
467 symbol_name_matcher_ftype *name_match
468 = language_get_symbol_name_matcher (lang_def, lookup_name);
471 = lookup_name.search_name_hash (lang) % MINIMAL_SYMBOL_HASH_SIZE;
472 for (minimal_symbol *iter = objf->per_bfd->msymbol_demangled_hash[hash];
474 iter = iter->demangled_hash_next)
475 if (name_match (MSYMBOL_SEARCH_NAME (iter), lookup_name, NULL))
476 (*callback) (iter, user_data);
482 struct bound_minimal_symbol
483 lookup_minimal_symbol_text (const char *name, struct objfile *objf)
485 struct objfile *objfile;
486 struct minimal_symbol *msymbol;
487 struct bound_minimal_symbol found_symbol = { NULL, NULL };
488 struct bound_minimal_symbol found_file_symbol = { NULL, NULL };
490 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
492 for (objfile = object_files;
493 objfile != NULL && found_symbol.minsym == NULL;
494 objfile = objfile->next)
496 if (objf == NULL || objf == objfile
497 || objf == objfile->separate_debug_objfile_backlink)
499 for (msymbol = objfile->per_bfd->msymbol_hash[hash];
500 msymbol != NULL && found_symbol.minsym == NULL;
501 msymbol = msymbol->hash_next)
503 if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
504 (MSYMBOL_TYPE (msymbol) == mst_text
505 || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc
506 || MSYMBOL_TYPE (msymbol) == mst_file_text))
508 switch (MSYMBOL_TYPE (msymbol))
511 found_file_symbol.minsym = msymbol;
512 found_file_symbol.objfile = objfile;
515 found_symbol.minsym = msymbol;
516 found_symbol.objfile = objfile;
523 /* External symbols are best. */
524 if (found_symbol.minsym)
527 /* File-local symbols are next best. */
528 return found_file_symbol;
533 struct minimal_symbol *
534 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
535 struct objfile *objf)
537 struct objfile *objfile;
538 struct minimal_symbol *msymbol;
540 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
542 for (objfile = object_files;
544 objfile = objfile->next)
546 if (objf == NULL || objf == objfile
547 || objf == objfile->separate_debug_objfile_backlink)
549 for (msymbol = objfile->per_bfd->msymbol_hash[hash];
551 msymbol = msymbol->hash_next)
553 if (MSYMBOL_VALUE_ADDRESS (objfile, msymbol) == pc
554 && strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0)
565 struct bound_minimal_symbol
566 lookup_minimal_symbol_solib_trampoline (const char *name,
567 struct objfile *objf)
569 struct objfile *objfile;
570 struct minimal_symbol *msymbol;
571 struct bound_minimal_symbol found_symbol = { NULL, NULL };
573 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
575 for (objfile = object_files;
577 objfile = objfile->next)
579 if (objf == NULL || objf == objfile
580 || objf == objfile->separate_debug_objfile_backlink)
582 for (msymbol = objfile->per_bfd->msymbol_hash[hash];
584 msymbol = msymbol->hash_next)
586 if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
587 MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
589 found_symbol.objfile = objfile;
590 found_symbol.minsym = msymbol;
600 /* A helper function that makes *PC section-relative. This searches
601 the sections of OBJFILE and if *PC is in a section, it subtracts
602 the section offset and returns true. Otherwise it returns
606 frob_address (struct objfile *objfile, CORE_ADDR *pc)
608 struct obj_section *iter;
610 ALL_OBJFILE_OSECTIONS (objfile, iter)
612 if (*pc >= obj_section_addr (iter) && *pc < obj_section_endaddr (iter))
614 *pc -= obj_section_offset (iter);
622 /* Search through the minimal symbol table for each objfile and find
623 the symbol whose address is the largest address that is still less
624 than or equal to PC, and matches SECTION (which is not NULL).
625 Returns a pointer to the minimal symbol if such a symbol is found,
626 or NULL if PC is not in a suitable range.
627 Note that we need to look through ALL the minimal symbol tables
628 before deciding on the symbol that comes closest to the specified PC.
629 This is because objfiles can overlap, for example objfile A has .text
630 at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
633 If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
634 there are text and trampoline symbols at the same address.
635 Otherwise prefer mst_text symbols. */
637 static struct bound_minimal_symbol
638 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc_in,
639 struct obj_section *section,
645 struct objfile *objfile;
646 struct minimal_symbol *msymbol;
647 struct minimal_symbol *best_symbol = NULL;
648 struct objfile *best_objfile = NULL;
649 struct bound_minimal_symbol result;
650 enum minimal_symbol_type want_type, other_type;
652 want_type = want_trampoline ? mst_solib_trampoline : mst_text;
653 other_type = want_trampoline ? mst_text : mst_solib_trampoline;
655 /* We can not require the symbol found to be in section, because
656 e.g. IRIX 6.5 mdebug relies on this code returning an absolute
657 symbol - but find_pc_section won't return an absolute section and
658 hence the code below would skip over absolute symbols. We can
659 still take advantage of the call to find_pc_section, though - the
660 object file still must match. In case we have separate debug
661 files, search both the file and its separate debug file. There's
662 no telling which one will have the minimal symbols. */
664 gdb_assert (section != NULL);
666 for (objfile = section->objfile;
668 objfile = objfile_separate_debug_iterate (section->objfile, objfile))
670 CORE_ADDR pc = pc_in;
672 /* If this objfile has a minimal symbol table, go search it using
673 a binary search. Note that a minimal symbol table always consists
674 of at least two symbols, a "real" symbol and the terminating
675 "null symbol". If there are no real symbols, then there is no
676 minimal symbol table at all. */
678 if (objfile->per_bfd->minimal_symbol_count > 0)
680 int best_zero_sized = -1;
682 msymbol = objfile->per_bfd->msymbols;
684 hi = objfile->per_bfd->minimal_symbol_count - 1;
686 /* This code assumes that the minimal symbols are sorted by
687 ascending address values. If the pc value is greater than or
688 equal to the first symbol's address, then some symbol in this
689 minimal symbol table is a suitable candidate for being the
690 "best" symbol. This includes the last real symbol, for cases
691 where the pc value is larger than any address in this vector.
693 By iterating until the address associated with the current
694 hi index (the endpoint of the test interval) is less than
695 or equal to the desired pc value, we accomplish two things:
696 (1) the case where the pc value is larger than any minimal
697 symbol address is trivially solved, (2) the address associated
698 with the hi index is always the one we want when the interation
699 terminates. In essence, we are iterating the test interval
700 down until the pc value is pushed out of it from the high end.
702 Warning: this code is trickier than it would appear at first. */
704 if (frob_address (objfile, &pc)
705 && pc >= MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[lo]))
707 while (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi]) > pc)
709 /* pc is still strictly less than highest address. */
710 /* Note "new" will always be >= lo. */
711 newobj = (lo + hi) / 2;
712 if ((MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[newobj]) >= pc)
723 /* If we have multiple symbols at the same address, we want
724 hi to point to the last one. That way we can find the
725 right symbol if it has an index greater than hi. */
726 while (hi < objfile->per_bfd->minimal_symbol_count - 1
727 && (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
728 == MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi + 1])))
731 /* Skip various undesirable symbols. */
734 /* Skip any absolute symbols. This is apparently
735 what adb and dbx do, and is needed for the CM-5.
736 There are two known possible problems: (1) on
737 ELF, apparently end, edata, etc. are absolute.
738 Not sure ignoring them here is a big deal, but if
739 we want to use them, the fix would go in
740 elfread.c. (2) I think shared library entry
741 points on the NeXT are absolute. If we want
742 special handling for this it probably should be
743 triggered by a special mst_abs_or_lib or some
746 if (MSYMBOL_TYPE (&msymbol[hi]) == mst_abs)
752 /* If SECTION was specified, skip any symbol from
755 /* Some types of debug info, such as COFF,
756 don't fill the bfd_section member, so don't
757 throw away symbols on those platforms. */
758 && MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
759 && (!matching_obj_sections
760 (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
767 /* If we are looking for a trampoline and this is a
768 text symbol, or the other way around, check the
769 preceding symbol too. If they are otherwise
770 identical prefer that one. */
772 && MSYMBOL_TYPE (&msymbol[hi]) == other_type
773 && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
774 && (MSYMBOL_SIZE (&msymbol[hi])
775 == MSYMBOL_SIZE (&msymbol[hi - 1]))
776 && (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
777 == MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi - 1]))
778 && (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
779 == MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
785 /* If the minimal symbol has a zero size, save it
786 but keep scanning backwards looking for one with
787 a non-zero size. A zero size may mean that the
788 symbol isn't an object or function (e.g. a
789 label), or it may just mean that the size was not
791 if (MSYMBOL_SIZE (&msymbol[hi]) == 0)
793 if (best_zero_sized == -1)
794 best_zero_sized = hi;
799 /* If we are past the end of the current symbol, try
800 the previous symbol if it has a larger overlapping
801 size. This happens on i686-pc-linux-gnu with glibc;
802 the nocancel variants of system calls are inside
803 the cancellable variants, but both have sizes. */
805 && MSYMBOL_SIZE (&msymbol[hi]) != 0
806 && pc >= (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
807 + MSYMBOL_SIZE (&msymbol[hi]))
808 && pc < (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi - 1])
809 + MSYMBOL_SIZE (&msymbol[hi - 1])))
815 /* Otherwise, this symbol must be as good as we're going
820 /* If HI has a zero size, and best_zero_sized is set,
821 then we had two or more zero-sized symbols; prefer
822 the first one we found (which may have a higher
823 address). Also, if we ran off the end, be sure
825 if (best_zero_sized != -1
826 && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0))
827 hi = best_zero_sized;
829 /* If the minimal symbol has a non-zero size, and this
830 PC appears to be outside the symbol's contents, then
831 refuse to use this symbol. If we found a zero-sized
832 symbol with an address greater than this symbol's,
833 use that instead. We assume that if symbols have
834 specified sizes, they do not overlap. */
837 && MSYMBOL_SIZE (&msymbol[hi]) != 0
838 && pc >= (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
839 + MSYMBOL_SIZE (&msymbol[hi])))
841 if (best_zero_sized != -1)
842 hi = best_zero_sized;
844 /* Go on to the next object file. */
848 /* The minimal symbol indexed by hi now is the best one in this
849 objfile's minimal symbol table. See if it is the best one
853 && ((best_symbol == NULL) ||
854 (MSYMBOL_VALUE_RAW_ADDRESS (best_symbol) <
855 MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi]))))
857 best_symbol = &msymbol[hi];
858 best_objfile = objfile;
864 result.minsym = best_symbol;
865 result.objfile = best_objfile;
869 struct bound_minimal_symbol
870 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
874 /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
875 force the section but that (well unless you're doing overlay
876 debugging) always returns NULL making the call somewhat useless. */
877 section = find_pc_section (pc);
880 struct bound_minimal_symbol result;
882 memset (&result, 0, sizeof (result));
886 return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
891 struct bound_minimal_symbol
892 lookup_minimal_symbol_by_pc (CORE_ADDR pc)
894 struct obj_section *section = find_pc_section (pc);
898 struct bound_minimal_symbol result;
900 memset (&result, 0, sizeof (result));
903 return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
906 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver. */
909 in_gnu_ifunc_stub (CORE_ADDR pc)
911 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
913 return msymbol.minsym && MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc;
916 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
919 stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
921 error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without "
922 "the ELF support compiled in."),
923 paddress (gdbarch, pc));
926 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
929 stub_gnu_ifunc_resolve_name (const char *function_name,
930 CORE_ADDR *function_address_p)
932 error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without "
933 "the ELF support compiled in."),
937 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
940 stub_gnu_ifunc_resolver_stop (struct breakpoint *b)
942 internal_error (__FILE__, __LINE__,
943 _("elf_gnu_ifunc_resolver_stop cannot be reached."));
946 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
949 stub_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
951 internal_error (__FILE__, __LINE__,
952 _("elf_gnu_ifunc_resolver_return_stop cannot be reached."));
955 /* See elf_gnu_ifunc_fns for its real implementation. */
957 static const struct gnu_ifunc_fns stub_gnu_ifunc_fns =
959 stub_gnu_ifunc_resolve_addr,
960 stub_gnu_ifunc_resolve_name,
961 stub_gnu_ifunc_resolver_stop,
962 stub_gnu_ifunc_resolver_return_stop,
965 /* A placeholder for &elf_gnu_ifunc_fns. */
967 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
971 struct bound_minimal_symbol
972 lookup_minimal_symbol_and_objfile (const char *name)
974 struct bound_minimal_symbol result;
975 struct objfile *objfile;
976 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
978 ALL_OBJFILES (objfile)
980 struct minimal_symbol *msym;
982 for (msym = objfile->per_bfd->msymbol_hash[hash];
984 msym = msym->hash_next)
986 if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
988 result.minsym = msym;
989 result.objfile = objfile;
995 memset (&result, 0, sizeof (result));
1000 /* Return leading symbol character for a BFD. If BFD is NULL,
1001 return the leading symbol character from the main objfile. */
1004 get_symbol_leading_char (bfd *abfd)
1007 return bfd_get_symbol_leading_char (abfd);
1008 if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
1009 return bfd_get_symbol_leading_char (symfile_objfile->obfd);
1013 /* See minsyms.h. */
1015 minimal_symbol_reader::minimal_symbol_reader (struct objfile *obj)
1017 m_msym_bunch (NULL),
1018 /* Note that presetting m_msym_bunch_index to BUNCH_SIZE causes the
1019 first call to save a minimal symbol to allocate the memory for
1021 m_msym_bunch_index (BUNCH_SIZE),
1026 /* Discard the currently collected minimal symbols, if any. If we wish
1027 to save them for later use, we must have already copied them somewhere
1028 else before calling this function.
1030 FIXME: We could allocate the minimal symbol bunches on their own
1031 obstack and then simply blow the obstack away when we are done with
1032 it. Is it worth the extra trouble though? */
1034 minimal_symbol_reader::~minimal_symbol_reader ()
1036 struct msym_bunch *next;
1038 while (m_msym_bunch != NULL)
1040 next = m_msym_bunch->next;
1041 xfree (m_msym_bunch);
1042 m_msym_bunch = next;
1046 /* See minsyms.h. */
1049 minimal_symbol_reader::record (const char *name, CORE_ADDR address,
1050 enum minimal_symbol_type ms_type)
1057 case mst_text_gnu_ifunc:
1059 case mst_solib_trampoline:
1060 section = SECT_OFF_TEXT (m_objfile);
1064 section = SECT_OFF_DATA (m_objfile);
1068 section = SECT_OFF_BSS (m_objfile);
1074 record_with_info (name, address, ms_type, section);
1077 /* See minsyms.h. */
1079 struct minimal_symbol *
1080 minimal_symbol_reader::record_full (const char *name, int name_len,
1081 bool copy_name, CORE_ADDR address,
1082 enum minimal_symbol_type ms_type,
1085 struct msym_bunch *newobj;
1086 struct minimal_symbol *msymbol;
1088 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
1089 the minimal symbols, because if there is also another symbol
1090 at the same address (e.g. the first function of the file),
1091 lookup_minimal_symbol_by_pc would have no way of getting the
1093 if (ms_type == mst_file_text && name[0] == 'g'
1094 && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
1095 || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
1098 /* It's safe to strip the leading char here once, since the name
1099 is also stored stripped in the minimal symbol table. */
1100 if (name[0] == get_symbol_leading_char (m_objfile->obfd))
1106 if (ms_type == mst_file_text && startswith (name, "__gnu_compiled"))
1109 if (m_msym_bunch_index == BUNCH_SIZE)
1111 newobj = XCNEW (struct msym_bunch);
1112 m_msym_bunch_index = 0;
1113 newobj->next = m_msym_bunch;
1114 m_msym_bunch = newobj;
1116 msymbol = &m_msym_bunch->contents[m_msym_bunch_index];
1117 MSYMBOL_SET_LANGUAGE (msymbol, language_auto,
1118 &m_objfile->per_bfd->storage_obstack);
1119 MSYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, m_objfile);
1121 SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
1122 MSYMBOL_SECTION (msymbol) = section;
1124 MSYMBOL_TYPE (msymbol) = ms_type;
1125 MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
1126 MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
1127 /* Do not use the SET_MSYMBOL_SIZE macro to initialize the size,
1128 as it would also set the has_size flag. */
1131 /* The hash pointers must be cleared! If they're not,
1132 add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
1133 msymbol->hash_next = NULL;
1134 msymbol->demangled_hash_next = NULL;
1136 /* If we already read minimal symbols for this objfile, then don't
1137 ever allocate a new one. */
1138 if (!m_objfile->per_bfd->minsyms_read)
1140 m_msym_bunch_index++;
1141 m_objfile->per_bfd->n_minsyms++;
1147 /* Compare two minimal symbols by address and return a signed result based
1148 on unsigned comparisons, so that we sort into unsigned numeric order.
1149 Within groups with the same address, sort by name. */
1152 compare_minimal_symbols (const void *fn1p, const void *fn2p)
1154 const struct minimal_symbol *fn1;
1155 const struct minimal_symbol *fn2;
1157 fn1 = (const struct minimal_symbol *) fn1p;
1158 fn2 = (const struct minimal_symbol *) fn2p;
1160 if (MSYMBOL_VALUE_RAW_ADDRESS (fn1) < MSYMBOL_VALUE_RAW_ADDRESS (fn2))
1162 return (-1); /* addr 1 is less than addr 2. */
1164 else if (MSYMBOL_VALUE_RAW_ADDRESS (fn1) > MSYMBOL_VALUE_RAW_ADDRESS (fn2))
1166 return (1); /* addr 1 is greater than addr 2. */
1169 /* addrs are equal: sort by name */
1171 const char *name1 = MSYMBOL_LINKAGE_NAME (fn1);
1172 const char *name2 = MSYMBOL_LINKAGE_NAME (fn2);
1174 if (name1 && name2) /* both have names */
1175 return strcmp (name1, name2);
1177 return 1; /* fn1 has no name, so it is "less". */
1178 else if (name1) /* fn2 has no name, so it is "less". */
1181 return (0); /* Neither has a name, so they're equal. */
1185 /* Compact duplicate entries out of a minimal symbol table by walking
1186 through the table and compacting out entries with duplicate addresses
1187 and matching names. Return the number of entries remaining.
1189 On entry, the table resides between msymbol[0] and msymbol[mcount].
1190 On exit, it resides between msymbol[0] and msymbol[result_count].
1192 When files contain multiple sources of symbol information, it is
1193 possible for the minimal symbol table to contain many duplicate entries.
1194 As an example, SVR4 systems use ELF formatted object files, which
1195 usually contain at least two different types of symbol tables (a
1196 standard ELF one and a smaller dynamic linking table), as well as
1197 DWARF debugging information for files compiled with -g.
1199 Without compacting, the minimal symbol table for gdb itself contains
1200 over a 1000 duplicates, about a third of the total table size. Aside
1201 from the potential trap of not noticing that two successive entries
1202 identify the same location, this duplication impacts the time required
1203 to linearly scan the table, which is done in a number of places. So we
1204 just do one linear scan here and toss out the duplicates.
1206 Note that we are not concerned here about recovering the space that
1207 is potentially freed up, because the strings themselves are allocated
1208 on the storage_obstack, and will get automatically freed when the symbol
1209 table is freed. The caller can free up the unused minimal symbols at
1210 the end of the compacted region if their allocation strategy allows it.
1212 Also note we only go up to the next to last entry within the loop
1213 and then copy the last entry explicitly after the loop terminates.
1215 Since the different sources of information for each symbol may
1216 have different levels of "completeness", we may have duplicates
1217 that have one entry with type "mst_unknown" and the other with a
1218 known type. So if the one we are leaving alone has type mst_unknown,
1219 overwrite its type with the type from the one we are compacting out. */
1222 compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
1223 struct objfile *objfile)
1225 struct minimal_symbol *copyfrom;
1226 struct minimal_symbol *copyto;
1230 copyfrom = copyto = msymbol;
1231 while (copyfrom < msymbol + mcount - 1)
1233 if (MSYMBOL_VALUE_RAW_ADDRESS (copyfrom)
1234 == MSYMBOL_VALUE_RAW_ADDRESS ((copyfrom + 1))
1235 && MSYMBOL_SECTION (copyfrom) == MSYMBOL_SECTION (copyfrom + 1)
1236 && strcmp (MSYMBOL_LINKAGE_NAME (copyfrom),
1237 MSYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
1239 if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
1241 MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
1246 *copyto++ = *copyfrom++;
1248 *copyto++ = *copyfrom++;
1249 mcount = copyto - msymbol;
1254 /* Build (or rebuild) the minimal symbol hash tables. This is necessary
1255 after compacting or sorting the table since the entries move around
1256 thus causing the internal minimal_symbol pointers to become jumbled. */
1259 build_minimal_symbol_hash_tables (struct objfile *objfile)
1262 struct minimal_symbol *msym;
1264 /* Clear the hash tables. */
1265 for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
1267 objfile->per_bfd->msymbol_hash[i] = 0;
1268 objfile->per_bfd->msymbol_demangled_hash[i] = 0;
1271 /* Now, (re)insert the actual entries. */
1272 for ((i = objfile->per_bfd->minimal_symbol_count,
1273 msym = objfile->per_bfd->msymbols);
1277 msym->hash_next = 0;
1278 add_minsym_to_hash_table (msym, objfile->per_bfd->msymbol_hash);
1280 msym->demangled_hash_next = 0;
1281 if (MSYMBOL_SEARCH_NAME (msym) != MSYMBOL_LINKAGE_NAME (msym))
1282 add_minsym_to_demangled_hash_table (msym, objfile);
1286 /* Add the minimal symbols in the existing bunches to the objfile's official
1287 minimal symbol table. In most cases there is no minimal symbol table yet
1288 for this objfile, and the existing bunches are used to create one. Once
1289 in a while (for shared libraries for example), we add symbols (e.g. common
1290 symbols) to an existing objfile.
1292 Because of the way minimal symbols are collected, we generally have no way
1293 of knowing what source language applies to any particular minimal symbol.
1294 Specifically, we have no way of knowing if the minimal symbol comes from a
1295 C++ compilation unit or not. So for the sake of supporting cached
1296 demangled C++ names, we have no choice but to try and demangle each new one
1297 that comes in. If the demangling succeeds, then we assume it is a C++
1298 symbol and set the symbol's language and demangled name fields
1299 appropriately. Note that in order to avoid unnecessary demanglings, and
1300 allocating obstack space that subsequently can't be freed for the demangled
1301 names, we mark all newly added symbols with language_auto. After
1302 compaction of the minimal symbols, we go back and scan the entire minimal
1303 symbol table looking for these new symbols. For each new symbol we attempt
1304 to demangle it, and if successful, record it as a language_cplus symbol
1305 and cache the demangled form on the symbol obstack. Symbols which don't
1306 demangle are marked as language_unknown symbols, which inhibits future
1307 attempts to demangle them if we later add more minimal symbols. */
1310 minimal_symbol_reader::install ()
1314 struct msym_bunch *bunch;
1315 struct minimal_symbol *msymbols;
1318 if (m_objfile->per_bfd->minsyms_read)
1321 if (m_msym_count > 0)
1323 if (symtab_create_debug)
1325 fprintf_unfiltered (gdb_stdlog,
1326 "Installing %d minimal symbols of objfile %s.\n",
1327 m_msym_count, objfile_name (m_objfile));
1330 /* Allocate enough space in the obstack, into which we will gather the
1331 bunches of new and existing minimal symbols, sort them, and then
1332 compact out the duplicate entries. Once we have a final table,
1333 we will give back the excess space. */
1335 alloc_count = m_msym_count + m_objfile->per_bfd->minimal_symbol_count + 1;
1336 obstack_blank (&m_objfile->per_bfd->storage_obstack,
1337 alloc_count * sizeof (struct minimal_symbol));
1338 msymbols = (struct minimal_symbol *)
1339 obstack_base (&m_objfile->per_bfd->storage_obstack);
1341 /* Copy in the existing minimal symbols, if there are any. */
1343 if (m_objfile->per_bfd->minimal_symbol_count)
1344 memcpy ((char *) msymbols, (char *) m_objfile->per_bfd->msymbols,
1345 m_objfile->per_bfd->minimal_symbol_count * sizeof (struct minimal_symbol));
1347 /* Walk through the list of minimal symbol bunches, adding each symbol
1348 to the new contiguous array of symbols. Note that we start with the
1349 current, possibly partially filled bunch (thus we use the current
1350 msym_bunch_index for the first bunch we copy over), and thereafter
1351 each bunch is full. */
1353 mcount = m_objfile->per_bfd->minimal_symbol_count;
1355 for (bunch = m_msym_bunch; bunch != NULL; bunch = bunch->next)
1357 for (bindex = 0; bindex < m_msym_bunch_index; bindex++, mcount++)
1358 msymbols[mcount] = bunch->contents[bindex];
1359 m_msym_bunch_index = BUNCH_SIZE;
1362 /* Sort the minimal symbols by address. */
1364 qsort (msymbols, mcount, sizeof (struct minimal_symbol),
1365 compare_minimal_symbols);
1367 /* Compact out any duplicates, and free up whatever space we are
1370 mcount = compact_minimal_symbols (msymbols, mcount, m_objfile);
1372 obstack_blank_fast (&m_objfile->per_bfd->storage_obstack,
1373 (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
1374 msymbols = (struct minimal_symbol *)
1375 obstack_finish (&m_objfile->per_bfd->storage_obstack);
1377 /* We also terminate the minimal symbol table with a "null symbol",
1378 which is *not* included in the size of the table. This makes it
1379 easier to find the end of the table when we are handed a pointer
1380 to some symbol in the middle of it. Zero out the fields in the
1381 "null symbol" allocated at the end of the array. Note that the
1382 symbol count does *not* include this null symbol, which is why it
1383 is indexed by mcount and not mcount-1. */
1385 memset (&msymbols[mcount], 0, sizeof (struct minimal_symbol));
1387 /* Attach the minimal symbol table to the specified objfile.
1388 The strings themselves are also located in the storage_obstack
1391 m_objfile->per_bfd->minimal_symbol_count = mcount;
1392 m_objfile->per_bfd->msymbols = msymbols;
1394 /* Now build the hash tables; we can't do this incrementally
1395 at an earlier point since we weren't finished with the obstack
1396 yet. (And if the msymbol obstack gets moved, all the internal
1397 pointers to other msymbols need to be adjusted.) */
1398 build_minimal_symbol_hash_tables (m_objfile);
1402 /* See minsyms.h. */
1405 terminate_minimal_symbol_table (struct objfile *objfile)
1407 if (! objfile->per_bfd->msymbols)
1408 objfile->per_bfd->msymbols
1409 = ((struct minimal_symbol *)
1410 obstack_alloc (&objfile->per_bfd->storage_obstack,
1411 sizeof (struct minimal_symbol)));
1414 struct minimal_symbol *m
1415 = &objfile->per_bfd->msymbols[objfile->per_bfd->minimal_symbol_count];
1417 memset (m, 0, sizeof (*m));
1418 /* Don't rely on these enumeration values being 0's. */
1419 MSYMBOL_TYPE (m) = mst_unknown;
1420 MSYMBOL_SET_LANGUAGE (m, language_unknown,
1421 &objfile->per_bfd->storage_obstack);
1425 /* Check if PC is in a shared library trampoline code stub.
1426 Return minimal symbol for the trampoline entry or NULL if PC is not
1427 in a trampoline code stub. */
1429 static struct minimal_symbol *
1430 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
1432 struct obj_section *section = find_pc_section (pc);
1433 struct bound_minimal_symbol msymbol;
1435 if (section == NULL)
1437 msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
1439 if (msymbol.minsym != NULL
1440 && MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
1441 return msymbol.minsym;
1445 /* If PC is in a shared library trampoline code stub, return the
1446 address of the `real' function belonging to the stub.
1447 Return 0 if PC is not in a trampoline code stub or if the real
1448 function is not found in the minimal symbol table.
1450 We may fail to find the right function if a function with the
1451 same name is defined in more than one shared library, but this
1452 is considered bad programming style. We could return 0 if we find
1453 a duplicate function in case this matters someday. */
1456 find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
1458 struct objfile *objfile;
1459 struct minimal_symbol *msymbol;
1460 struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1462 if (tsymbol != NULL)
1464 ALL_MSYMBOLS (objfile, msymbol)
1466 if ((MSYMBOL_TYPE (msymbol) == mst_text
1467 || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
1468 && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
1469 MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1470 return MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
1472 /* Also handle minimal symbols pointing to function descriptors. */
1473 if (MSYMBOL_TYPE (msymbol) == mst_data
1474 && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
1475 MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1479 func = gdbarch_convert_from_func_ptr_addr
1480 (get_objfile_arch (objfile),
1481 MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
1484 /* Ignore data symbols that are not function descriptors. */
1485 if (func != MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
1493 /* See minsyms.h. */
1496 minimal_symbol_upper_bound (struct bound_minimal_symbol minsym)
1500 struct obj_section *obj_section;
1502 struct minimal_symbol *msymbol;
1504 gdb_assert (minsym.minsym != NULL);
1506 /* If the minimal symbol has a size, use it. Otherwise use the
1507 lesser of the next minimal symbol in the same section, or the end
1508 of the section, as the end of the function. */
1510 if (MSYMBOL_SIZE (minsym.minsym) != 0)
1511 return BMSYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym.minsym);
1513 /* Step over other symbols at this same address, and symbols in
1514 other sections, to find the next symbol in this section with a
1515 different address. */
1517 msymbol = minsym.minsym;
1518 section = MSYMBOL_SECTION (msymbol);
1519 for (i = 1; MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
1521 if ((MSYMBOL_VALUE_RAW_ADDRESS (msymbol + i)
1522 != MSYMBOL_VALUE_RAW_ADDRESS (msymbol))
1523 && MSYMBOL_SECTION (msymbol + i) == section)
1527 obj_section = MSYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
1528 if (MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL
1529 && (MSYMBOL_VALUE_ADDRESS (minsym.objfile, msymbol + i)
1530 < obj_section_endaddr (obj_section)))
1531 result = MSYMBOL_VALUE_ADDRESS (minsym.objfile, msymbol + i);
1533 /* We got the start address from the last msymbol in the objfile.
1534 So the end address is the end of the section. */
1535 result = obj_section_endaddr (obj_section);