1 /* GDB routines for manipulating the minimal symbol tables.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support, using pieces from other GDB modules.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file contains support routines for creating, manipulating, and
25 destroying minimal symbol tables.
27 Minimal symbol tables are used to hold some very basic information about
28 all defined global symbols (text, data, bss, abs, etc). The only two
29 required pieces of information are the symbol's name and the address
30 associated with that symbol.
32 In many cases, even if a file was compiled with no special options for
33 debugging at all, as long as was not stripped it will contain sufficient
34 information to build useful minimal symbol tables using this structure.
36 Even when a file contains enough debugging information to build a full
37 symbol table, these minimal symbols are still useful for quickly mapping
38 between names and addresses, and vice versa. They are also sometimes used
39 to figure out what full symbol table entries need to be read in. */
44 #include "gdb_string.h"
53 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
54 At the end, copy them all into one newly allocated location on an objfile's
57 #define BUNCH_SIZE 127
61 struct msym_bunch
*next
;
62 struct minimal_symbol contents
[BUNCH_SIZE
];
65 /* Bunch currently being filled up.
66 The next field points to chain of filled bunches. */
68 static struct msym_bunch
*msym_bunch
;
70 /* Number of slots filled in current bunch. */
72 static int msym_bunch_index
;
74 /* Total number of minimal symbols recorded so far for the objfile. */
76 static int msym_count
;
78 /* Prototypes for local functions. */
80 static int compare_minimal_symbols (const PTR
, const PTR
);
83 compact_minimal_symbols (struct minimal_symbol
*, int, struct objfile
*);
85 static void add_minsym_to_demangled_hash_table (struct minimal_symbol
*sym
,
86 struct minimal_symbol
**table
);
88 /* Compute a hash code based using the same criteria as `strcmp_iw'. */
91 msymbol_hash_iw (const char *string
)
93 unsigned int hash
= 0;
94 while (*string
&& *string
!= '(')
96 while (isspace (*string
))
98 if (*string
&& *string
!= '(')
99 hash
= (31 * hash
) + *string
;
102 return hash
% MINIMAL_SYMBOL_HASH_SIZE
;
105 /* Compute a hash code for a string. */
108 msymbol_hash (const char *string
)
110 unsigned int hash
= 0;
111 for (; *string
; ++string
)
112 hash
= (31 * hash
) + *string
;
113 return hash
% MINIMAL_SYMBOL_HASH_SIZE
;
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
)
123 unsigned int hash
= msymbol_hash (SYMBOL_NAME (sym
));
124 sym
->hash_next
= table
[hash
];
129 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
132 add_minsym_to_demangled_hash_table (struct minimal_symbol
*sym
,
133 struct minimal_symbol
**table
)
135 if (sym
->demangled_hash_next
== NULL
)
137 unsigned int hash
= msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym
));
138 sym
->demangled_hash_next
= table
[hash
];
144 /* Look through all the current minimal symbol tables and find the
145 first minimal symbol that matches NAME. If OBJF is non-NULL, limit
146 the search to that objfile. If SFILE is non-NULL, limit the search
147 to that source file. Returns a pointer to the minimal symbol that
148 matches, or NULL if no match is found.
150 Note: One instance where there may be duplicate minimal symbols with
151 the same name is when the symbol tables for a shared library and the
152 symbol tables for an executable contain global symbols with the same
153 names (the dynamic linker deals with the duplication). */
155 struct minimal_symbol
*
156 lookup_minimal_symbol (register const char *name
, const char *sfile
,
157 struct objfile
*objf
)
159 struct objfile
*objfile
;
160 struct minimal_symbol
*msymbol
;
161 struct minimal_symbol
*found_symbol
= NULL
;
162 struct minimal_symbol
*found_file_symbol
= NULL
;
163 struct minimal_symbol
*trampoline_symbol
= NULL
;
165 unsigned int hash
= msymbol_hash (name
);
166 unsigned int dem_hash
= msymbol_hash_iw (name
);
168 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
171 char *p
= strrchr (sfile
, '/');
177 for (objfile
= object_files
;
178 objfile
!= NULL
&& found_symbol
== NULL
;
179 objfile
= objfile
->next
)
181 if (objf
== NULL
|| objf
== objfile
)
183 /* Do two passes: the first over the ordinary hash table,
184 and the second over the demangled hash table. */
187 for (pass
= 1; pass
<= 2 && found_symbol
== NULL
; pass
++)
189 /* Select hash list according to pass. */
191 msymbol
= objfile
->msymbol_hash
[hash
];
193 msymbol
= objfile
->msymbol_demangled_hash
[dem_hash
];
195 while (msymbol
!= NULL
&& found_symbol
== NULL
)
197 if (SYMBOL_MATCHES_NAME (msymbol
, name
))
199 switch (MSYMBOL_TYPE (msymbol
))
204 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
205 if (sfile
== NULL
|| STREQ (msymbol
->filename
, sfile
))
206 found_file_symbol
= msymbol
;
208 /* We have neither the ability nor the need to
209 deal with the SFILE parameter. If we find
210 more than one symbol, just return the latest
211 one (the user can't expect useful behavior in
213 found_file_symbol
= msymbol
;
217 case mst_solib_trampoline
:
219 /* If a trampoline symbol is found, we prefer to
220 keep looking for the *real* symbol. If the
221 actual symbol is not found, then we'll use the
223 if (trampoline_symbol
== NULL
)
224 trampoline_symbol
= msymbol
;
229 found_symbol
= msymbol
;
234 /* Find the next symbol on the hash chain. */
236 msymbol
= msymbol
->hash_next
;
238 msymbol
= msymbol
->demangled_hash_next
;
243 /* External symbols are best. */
247 /* File-local symbols are next best. */
248 if (found_file_symbol
)
249 return found_file_symbol
;
251 /* Symbols for shared library trampolines are next best. */
252 if (trampoline_symbol
)
253 return trampoline_symbol
;
258 /* Look through all the current minimal symbol tables and find the
259 first minimal symbol that matches NAME and of text type.
260 If OBJF is non-NULL, limit
261 the search to that objfile. If SFILE is non-NULL, limit the search
262 to that source file. Returns a pointer to the minimal symbol that
263 matches, or NULL if no match is found.
266 struct minimal_symbol
*
267 lookup_minimal_symbol_text (register const char *name
, const char *sfile
,
268 struct objfile
*objf
)
270 struct objfile
*objfile
;
271 struct minimal_symbol
*msymbol
;
272 struct minimal_symbol
*found_symbol
= NULL
;
273 struct minimal_symbol
*found_file_symbol
= NULL
;
275 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
278 char *p
= strrchr (sfile
, '/');
284 for (objfile
= object_files
;
285 objfile
!= NULL
&& found_symbol
== NULL
;
286 objfile
= objfile
->next
)
288 if (objf
== NULL
|| objf
== objfile
)
290 for (msymbol
= objfile
->msymbols
;
291 msymbol
!= NULL
&& SYMBOL_NAME (msymbol
) != NULL
&&
292 found_symbol
== NULL
;
295 if (SYMBOL_MATCHES_NAME (msymbol
, name
) &&
296 (MSYMBOL_TYPE (msymbol
) == mst_text
||
297 MSYMBOL_TYPE (msymbol
) == mst_file_text
))
299 switch (MSYMBOL_TYPE (msymbol
))
302 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
303 if (sfile
== NULL
|| STREQ (msymbol
->filename
, sfile
))
304 found_file_symbol
= msymbol
;
306 /* We have neither the ability nor the need to
307 deal with the SFILE parameter. If we find
308 more than one symbol, just return the latest
309 one (the user can't expect useful behavior in
311 found_file_symbol
= msymbol
;
315 found_symbol
= msymbol
;
322 /* External symbols are best. */
326 /* File-local symbols are next best. */
327 if (found_file_symbol
)
328 return found_file_symbol
;
333 /* Look through all the current minimal symbol tables and find the
334 first minimal symbol that matches NAME and of solib trampoline type.
335 If OBJF is non-NULL, limit
336 the search to that objfile. If SFILE is non-NULL, limit the search
337 to that source file. Returns a pointer to the minimal symbol that
338 matches, or NULL if no match is found.
341 struct minimal_symbol
*
342 lookup_minimal_symbol_solib_trampoline (register const char *name
,
343 const char *sfile
, struct objfile
*objf
)
345 struct objfile
*objfile
;
346 struct minimal_symbol
*msymbol
;
347 struct minimal_symbol
*found_symbol
= NULL
;
349 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
352 char *p
= strrchr (sfile
, '/');
358 for (objfile
= object_files
;
359 objfile
!= NULL
&& found_symbol
== NULL
;
360 objfile
= objfile
->next
)
362 if (objf
== NULL
|| objf
== objfile
)
364 for (msymbol
= objfile
->msymbols
;
365 msymbol
!= NULL
&& SYMBOL_NAME (msymbol
) != NULL
&&
366 found_symbol
== NULL
;
369 if (SYMBOL_MATCHES_NAME (msymbol
, name
) &&
370 MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
380 /* Search through the minimal symbol table for each objfile and find
381 the symbol whose address is the largest address that is still less
382 than or equal to PC, and matches SECTION (if non-null). Returns a
383 pointer to the minimal symbol if such a symbol is found, or NULL if
384 PC is not in a suitable range. Note that we need to look through
385 ALL the minimal symbol tables before deciding on the symbol that
386 comes closest to the specified PC. This is because objfiles can
387 overlap, for example objfile A has .text at 0x100 and .data at
388 0x40000 and objfile B has .text at 0x234 and .data at 0x40048. */
390 struct minimal_symbol
*
391 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc
, asection
*section
)
396 struct objfile
*objfile
;
397 struct minimal_symbol
*msymbol
;
398 struct minimal_symbol
*best_symbol
= NULL
;
400 /* pc has to be in a known section. This ensures that anything beyond
401 the end of the last segment doesn't appear to be part of the last
402 function in the last segment. */
403 if (find_pc_section (pc
) == NULL
)
406 for (objfile
= object_files
;
408 objfile
= objfile
->next
)
410 /* If this objfile has a minimal symbol table, go search it using
411 a binary search. Note that a minimal symbol table always consists
412 of at least two symbols, a "real" symbol and the terminating
413 "null symbol". If there are no real symbols, then there is no
414 minimal symbol table at all. */
416 if ((msymbol
= objfile
->msymbols
) != NULL
)
419 hi
= objfile
->minimal_symbol_count
- 1;
421 /* This code assumes that the minimal symbols are sorted by
422 ascending address values. If the pc value is greater than or
423 equal to the first symbol's address, then some symbol in this
424 minimal symbol table is a suitable candidate for being the
425 "best" symbol. This includes the last real symbol, for cases
426 where the pc value is larger than any address in this vector.
428 By iterating until the address associated with the current
429 hi index (the endpoint of the test interval) is less than
430 or equal to the desired pc value, we accomplish two things:
431 (1) the case where the pc value is larger than any minimal
432 symbol address is trivially solved, (2) the address associated
433 with the hi index is always the one we want when the interation
434 terminates. In essence, we are iterating the test interval
435 down until the pc value is pushed out of it from the high end.
437 Warning: this code is trickier than it would appear at first. */
439 /* Should also require that pc is <= end of objfile. FIXME! */
440 if (pc
>= SYMBOL_VALUE_ADDRESS (&msymbol
[lo
]))
442 while (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]) > pc
)
444 /* pc is still strictly less than highest address */
445 /* Note "new" will always be >= lo */
447 if ((SYMBOL_VALUE_ADDRESS (&msymbol
[new]) >= pc
) ||
458 /* If we have multiple symbols at the same address, we want
459 hi to point to the last one. That way we can find the
460 right symbol if it has an index greater than hi. */
461 while (hi
< objfile
->minimal_symbol_count
- 1
462 && (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
463 == SYMBOL_VALUE_ADDRESS (&msymbol
[hi
+ 1])))
466 /* The minimal symbol indexed by hi now is the best one in this
467 objfile's minimal symbol table. See if it is the best one
470 /* Skip any absolute symbols. This is apparently what adb
471 and dbx do, and is needed for the CM-5. There are two
472 known possible problems: (1) on ELF, apparently end, edata,
473 etc. are absolute. Not sure ignoring them here is a big
474 deal, but if we want to use them, the fix would go in
475 elfread.c. (2) I think shared library entry points on the
476 NeXT are absolute. If we want special handling for this
477 it probably should be triggered by a special
478 mst_abs_or_lib or some such. */
480 && msymbol
[hi
].type
== mst_abs
)
483 /* If "section" specified, skip any symbol from wrong section */
484 /* This is the new code that distinguishes it from the old function */
487 /* Some types of debug info, such as COFF,
488 don't fill the bfd_section member, so don't
489 throw away symbols on those platforms. */
490 && SYMBOL_BFD_SECTION (&msymbol
[hi
]) != NULL
491 && SYMBOL_BFD_SECTION (&msymbol
[hi
]) != section
)
495 && ((best_symbol
== NULL
) ||
496 (SYMBOL_VALUE_ADDRESS (best_symbol
) <
497 SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]))))
499 best_symbol
= &msymbol
[hi
];
504 return (best_symbol
);
507 /* Backward compatibility: search through the minimal symbol table
508 for a matching PC (no section given) */
510 struct minimal_symbol
*
511 lookup_minimal_symbol_by_pc (CORE_ADDR pc
)
513 return lookup_minimal_symbol_by_pc_section (pc
, find_pc_mapped_section (pc
));
516 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
518 find_stab_function_addr (char *namestring
, char *filename
,
519 struct objfile
*objfile
)
521 struct minimal_symbol
*msym
;
525 p
= strchr (namestring
, ':');
530 strncpy (p
, namestring
, n
);
533 msym
= lookup_minimal_symbol (p
, filename
, objfile
);
536 /* Sun Fortran appends an underscore to the minimal symbol name,
537 try again with an appended underscore if the minimal symbol
541 msym
= lookup_minimal_symbol (p
, filename
, objfile
);
544 if (msym
== NULL
&& filename
!= NULL
)
546 /* Try again without the filename. */
548 msym
= lookup_minimal_symbol (p
, 0, objfile
);
550 if (msym
== NULL
&& filename
!= NULL
)
552 /* And try again for Sun Fortran, but without the filename. */
555 msym
= lookup_minimal_symbol (p
, 0, objfile
);
558 return msym
== NULL
? 0 : SYMBOL_VALUE_ADDRESS (msym
);
560 #endif /* SOFUN_ADDRESS_MAYBE_MISSING */
563 /* Return leading symbol character for a BFD. If BFD is NULL,
564 return the leading symbol character from the main objfile. */
566 static int get_symbol_leading_char (bfd
*);
569 get_symbol_leading_char (bfd
*abfd
)
572 return bfd_get_symbol_leading_char (abfd
);
573 if (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
)
574 return bfd_get_symbol_leading_char (symfile_objfile
->obfd
);
578 /* Prepare to start collecting minimal symbols. Note that presetting
579 msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
580 symbol to allocate the memory for the first bunch. */
583 init_minimal_symbol_collection (void)
587 msym_bunch_index
= BUNCH_SIZE
;
591 prim_record_minimal_symbol (const char *name
, CORE_ADDR address
,
592 enum minimal_symbol_type ms_type
,
593 struct objfile
*objfile
)
601 case mst_solib_trampoline
:
602 section
= SECT_OFF_TEXT (objfile
);
606 section
= SECT_OFF_DATA (objfile
);
610 section
= SECT_OFF_BSS (objfile
);
616 prim_record_minimal_symbol_and_info (name
, address
, ms_type
,
617 NULL
, section
, NULL
, objfile
);
620 /* Record a minimal symbol in the msym bunches. Returns the symbol
623 struct minimal_symbol
*
624 prim_record_minimal_symbol_and_info (const char *name
, CORE_ADDR address
,
625 enum minimal_symbol_type ms_type
,
626 char *info
, int section
,
627 asection
*bfd_section
,
628 struct objfile
*objfile
)
630 register struct msym_bunch
*new;
631 register struct minimal_symbol
*msymbol
;
633 if (ms_type
== mst_file_text
)
635 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
636 the minimal symbols, because if there is also another symbol
637 at the same address (e.g. the first function of the file),
638 lookup_minimal_symbol_by_pc would have no way of getting the
641 && (strcmp (name
, GCC_COMPILED_FLAG_SYMBOL
) == 0
642 || strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
646 const char *tempstring
= name
;
647 if (tempstring
[0] == get_symbol_leading_char (objfile
->obfd
))
649 if (STREQN (tempstring
, "__gnu_compiled", 14))
654 if (msym_bunch_index
== BUNCH_SIZE
)
656 new = (struct msym_bunch
*) xmalloc (sizeof (struct msym_bunch
));
657 msym_bunch_index
= 0;
658 new->next
= msym_bunch
;
661 msymbol
= &msym_bunch
->contents
[msym_bunch_index
];
662 SYMBOL_NAME (msymbol
) = obsavestring ((char *) name
, strlen (name
),
663 &objfile
->symbol_obstack
);
664 SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol
, language_unknown
);
665 SYMBOL_VALUE_ADDRESS (msymbol
) = address
;
666 SYMBOL_SECTION (msymbol
) = section
;
667 SYMBOL_BFD_SECTION (msymbol
) = bfd_section
;
669 MSYMBOL_TYPE (msymbol
) = ms_type
;
670 /* FIXME: This info, if it remains, needs its own field. */
671 MSYMBOL_INFO (msymbol
) = info
; /* FIXME! */
673 /* The hash pointers must be cleared! If they're not,
674 add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
675 msymbol
->hash_next
= NULL
;
676 msymbol
->demangled_hash_next
= NULL
;
680 OBJSTAT (objfile
, n_minsyms
++);
684 /* Compare two minimal symbols by address and return a signed result based
685 on unsigned comparisons, so that we sort into unsigned numeric order.
686 Within groups with the same address, sort by name. */
689 compare_minimal_symbols (const PTR fn1p
, const PTR fn2p
)
691 register const struct minimal_symbol
*fn1
;
692 register const struct minimal_symbol
*fn2
;
694 fn1
= (const struct minimal_symbol
*) fn1p
;
695 fn2
= (const struct minimal_symbol
*) fn2p
;
697 if (SYMBOL_VALUE_ADDRESS (fn1
) < SYMBOL_VALUE_ADDRESS (fn2
))
699 return (-1); /* addr 1 is less than addr 2 */
701 else if (SYMBOL_VALUE_ADDRESS (fn1
) > SYMBOL_VALUE_ADDRESS (fn2
))
703 return (1); /* addr 1 is greater than addr 2 */
706 /* addrs are equal: sort by name */
708 char *name1
= SYMBOL_NAME (fn1
);
709 char *name2
= SYMBOL_NAME (fn2
);
711 if (name1
&& name2
) /* both have names */
712 return strcmp (name1
, name2
);
714 return 1; /* fn1 has no name, so it is "less" */
715 else if (name1
) /* fn2 has no name, so it is "less" */
718 return (0); /* neither has a name, so they're equal. */
722 /* Discard the currently collected minimal symbols, if any. If we wish
723 to save them for later use, we must have already copied them somewhere
724 else before calling this function.
726 FIXME: We could allocate the minimal symbol bunches on their own
727 obstack and then simply blow the obstack away when we are done with
728 it. Is it worth the extra trouble though? */
731 do_discard_minimal_symbols_cleanup (void *arg
)
733 register struct msym_bunch
*next
;
735 while (msym_bunch
!= NULL
)
737 next
= msym_bunch
->next
;
744 make_cleanup_discard_minimal_symbols (void)
746 return make_cleanup (do_discard_minimal_symbols_cleanup
, 0);
751 /* Compact duplicate entries out of a minimal symbol table by walking
752 through the table and compacting out entries with duplicate addresses
753 and matching names. Return the number of entries remaining.
755 On entry, the table resides between msymbol[0] and msymbol[mcount].
756 On exit, it resides between msymbol[0] and msymbol[result_count].
758 When files contain multiple sources of symbol information, it is
759 possible for the minimal symbol table to contain many duplicate entries.
760 As an example, SVR4 systems use ELF formatted object files, which
761 usually contain at least two different types of symbol tables (a
762 standard ELF one and a smaller dynamic linking table), as well as
763 DWARF debugging information for files compiled with -g.
765 Without compacting, the minimal symbol table for gdb itself contains
766 over a 1000 duplicates, about a third of the total table size. Aside
767 from the potential trap of not noticing that two successive entries
768 identify the same location, this duplication impacts the time required
769 to linearly scan the table, which is done in a number of places. So we
770 just do one linear scan here and toss out the duplicates.
772 Note that we are not concerned here about recovering the space that
773 is potentially freed up, because the strings themselves are allocated
774 on the symbol_obstack, and will get automatically freed when the symbol
775 table is freed. The caller can free up the unused minimal symbols at
776 the end of the compacted region if their allocation strategy allows it.
778 Also note we only go up to the next to last entry within the loop
779 and then copy the last entry explicitly after the loop terminates.
781 Since the different sources of information for each symbol may
782 have different levels of "completeness", we may have duplicates
783 that have one entry with type "mst_unknown" and the other with a
784 known type. So if the one we are leaving alone has type mst_unknown,
785 overwrite its type with the type from the one we are compacting out. */
788 compact_minimal_symbols (struct minimal_symbol
*msymbol
, int mcount
,
789 struct objfile
*objfile
)
791 struct minimal_symbol
*copyfrom
;
792 struct minimal_symbol
*copyto
;
796 copyfrom
= copyto
= msymbol
;
797 while (copyfrom
< msymbol
+ mcount
- 1)
799 if (SYMBOL_VALUE_ADDRESS (copyfrom
) ==
800 SYMBOL_VALUE_ADDRESS ((copyfrom
+ 1)) &&
801 (STREQ (SYMBOL_NAME (copyfrom
), SYMBOL_NAME ((copyfrom
+ 1)))))
803 if (MSYMBOL_TYPE ((copyfrom
+ 1)) == mst_unknown
)
805 MSYMBOL_TYPE ((copyfrom
+ 1)) = MSYMBOL_TYPE (copyfrom
);
810 *copyto
++ = *copyfrom
++;
812 *copyto
++ = *copyfrom
++;
813 mcount
= copyto
- msymbol
;
818 /* Build (or rebuild) the minimal symbol hash tables. This is necessary
819 after compacting or sorting the table since the entries move around
820 thus causing the internal minimal_symbol pointers to become jumbled. */
823 build_minimal_symbol_hash_tables (struct objfile
*objfile
)
826 struct minimal_symbol
*msym
;
828 /* Clear the hash tables. */
829 for (i
= 0; i
< MINIMAL_SYMBOL_HASH_SIZE
; i
++)
831 objfile
->msymbol_hash
[i
] = 0;
832 objfile
->msymbol_demangled_hash
[i
] = 0;
835 /* Now, (re)insert the actual entries. */
836 for (i
= objfile
->minimal_symbol_count
, msym
= objfile
->msymbols
;
841 add_minsym_to_hash_table (msym
, objfile
->msymbol_hash
);
843 msym
->demangled_hash_next
= 0;
844 if (SYMBOL_DEMANGLED_NAME (msym
) != NULL
)
845 add_minsym_to_demangled_hash_table (msym
,
846 objfile
->msymbol_demangled_hash
);
850 /* Add the minimal symbols in the existing bunches to the objfile's official
851 minimal symbol table. In most cases there is no minimal symbol table yet
852 for this objfile, and the existing bunches are used to create one. Once
853 in a while (for shared libraries for example), we add symbols (e.g. common
854 symbols) to an existing objfile.
856 Because of the way minimal symbols are collected, we generally have no way
857 of knowing what source language applies to any particular minimal symbol.
858 Specifically, we have no way of knowing if the minimal symbol comes from a
859 C++ compilation unit or not. So for the sake of supporting cached
860 demangled C++ names, we have no choice but to try and demangle each new one
861 that comes in. If the demangling succeeds, then we assume it is a C++
862 symbol and set the symbol's language and demangled name fields
863 appropriately. Note that in order to avoid unnecessary demanglings, and
864 allocating obstack space that subsequently can't be freed for the demangled
865 names, we mark all newly added symbols with language_auto. After
866 compaction of the minimal symbols, we go back and scan the entire minimal
867 symbol table looking for these new symbols. For each new symbol we attempt
868 to demangle it, and if successful, record it as a language_cplus symbol
869 and cache the demangled form on the symbol obstack. Symbols which don't
870 demangle are marked as language_unknown symbols, which inhibits future
871 attempts to demangle them if we later add more minimal symbols. */
874 install_minimal_symbols (struct objfile
*objfile
)
878 register struct msym_bunch
*bunch
;
879 register struct minimal_symbol
*msymbols
;
881 register char leading_char
;
885 /* Allocate enough space in the obstack, into which we will gather the
886 bunches of new and existing minimal symbols, sort them, and then
887 compact out the duplicate entries. Once we have a final table,
888 we will give back the excess space. */
890 alloc_count
= msym_count
+ objfile
->minimal_symbol_count
+ 1;
891 obstack_blank (&objfile
->symbol_obstack
,
892 alloc_count
* sizeof (struct minimal_symbol
));
893 msymbols
= (struct minimal_symbol
*)
894 obstack_base (&objfile
->symbol_obstack
);
896 /* Copy in the existing minimal symbols, if there are any. */
898 if (objfile
->minimal_symbol_count
)
899 memcpy ((char *) msymbols
, (char *) objfile
->msymbols
,
900 objfile
->minimal_symbol_count
* sizeof (struct minimal_symbol
));
902 /* Walk through the list of minimal symbol bunches, adding each symbol
903 to the new contiguous array of symbols. Note that we start with the
904 current, possibly partially filled bunch (thus we use the current
905 msym_bunch_index for the first bunch we copy over), and thereafter
906 each bunch is full. */
908 mcount
= objfile
->minimal_symbol_count
;
909 leading_char
= get_symbol_leading_char (objfile
->obfd
);
911 for (bunch
= msym_bunch
; bunch
!= NULL
; bunch
= bunch
->next
)
913 for (bindex
= 0; bindex
< msym_bunch_index
; bindex
++, mcount
++)
915 msymbols
[mcount
] = bunch
->contents
[bindex
];
916 SYMBOL_LANGUAGE (&msymbols
[mcount
]) = language_auto
;
917 if (SYMBOL_NAME (&msymbols
[mcount
])[0] == leading_char
)
919 SYMBOL_NAME (&msymbols
[mcount
])++;
922 msym_bunch_index
= BUNCH_SIZE
;
925 /* Sort the minimal symbols by address. */
927 qsort (msymbols
, mcount
, sizeof (struct minimal_symbol
),
928 compare_minimal_symbols
);
930 /* Compact out any duplicates, and free up whatever space we are
933 mcount
= compact_minimal_symbols (msymbols
, mcount
, objfile
);
935 obstack_blank (&objfile
->symbol_obstack
,
936 (mcount
+ 1 - alloc_count
) * sizeof (struct minimal_symbol
));
937 msymbols
= (struct minimal_symbol
*)
938 obstack_finish (&objfile
->symbol_obstack
);
940 /* We also terminate the minimal symbol table with a "null symbol",
941 which is *not* included in the size of the table. This makes it
942 easier to find the end of the table when we are handed a pointer
943 to some symbol in the middle of it. Zero out the fields in the
944 "null symbol" allocated at the end of the array. Note that the
945 symbol count does *not* include this null symbol, which is why it
946 is indexed by mcount and not mcount-1. */
948 SYMBOL_NAME (&msymbols
[mcount
]) = NULL
;
949 SYMBOL_VALUE_ADDRESS (&msymbols
[mcount
]) = 0;
950 MSYMBOL_INFO (&msymbols
[mcount
]) = NULL
;
951 MSYMBOL_TYPE (&msymbols
[mcount
]) = mst_unknown
;
952 SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols
[mcount
], language_unknown
);
954 /* Attach the minimal symbol table to the specified objfile.
955 The strings themselves are also located in the symbol_obstack
958 objfile
->minimal_symbol_count
= mcount
;
959 objfile
->msymbols
= msymbols
;
961 /* Try to guess the appropriate C++ ABI by looking at the names
962 of the minimal symbols in the table. */
966 for (i
= 0; i
< mcount
; i
++)
968 const char *name
= SYMBOL_NAME (&objfile
->msymbols
[i
]);
969 if (name
[0] == '_' && name
[1] == 'Z')
971 switch_to_cp_abi ("gnu-v3");
977 /* Now walk through all the minimal symbols, selecting the newly added
978 ones and attempting to cache their C++ demangled names. */
979 for (; mcount
-- > 0; msymbols
++)
980 SYMBOL_INIT_DEMANGLED_NAME (msymbols
, &objfile
->symbol_obstack
);
982 /* Now build the hash tables; we can't do this incrementally
983 at an earlier point since we weren't finished with the obstack
984 yet. (And if the msymbol obstack gets moved, all the internal
985 pointers to other msymbols need to be adjusted.) */
986 build_minimal_symbol_hash_tables (objfile
);
990 /* Sort all the minimal symbols in OBJFILE. */
993 msymbols_sort (struct objfile
*objfile
)
995 qsort (objfile
->msymbols
, objfile
->minimal_symbol_count
,
996 sizeof (struct minimal_symbol
), compare_minimal_symbols
);
997 build_minimal_symbol_hash_tables (objfile
);
1000 /* Check if PC is in a shared library trampoline code stub.
1001 Return minimal symbol for the trampoline entry or NULL if PC is not
1002 in a trampoline code stub. */
1004 struct minimal_symbol
*
1005 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc
)
1007 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1009 if (msymbol
!= NULL
&& MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
1014 /* If PC is in a shared library trampoline code stub, return the
1015 address of the `real' function belonging to the stub.
1016 Return 0 if PC is not in a trampoline code stub or if the real
1017 function is not found in the minimal symbol table.
1019 We may fail to find the right function if a function with the
1020 same name is defined in more than one shared library, but this
1021 is considered bad programming style. We could return 0 if we find
1022 a duplicate function in case this matters someday. */
1025 find_solib_trampoline_target (CORE_ADDR pc
)
1027 struct objfile
*objfile
;
1028 struct minimal_symbol
*msymbol
;
1029 struct minimal_symbol
*tsymbol
= lookup_solib_trampoline_symbol_by_pc (pc
);
1031 if (tsymbol
!= NULL
)
1033 ALL_MSYMBOLS (objfile
, msymbol
)
1035 if (MSYMBOL_TYPE (msymbol
) == mst_text
1036 && STREQ (SYMBOL_NAME (msymbol
), SYMBOL_NAME (tsymbol
)))
1037 return SYMBOL_VALUE_ADDRESS (msymbol
);