1 /* GDB routines for manipulating the minimal symbol tables.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 /* This file contains support routines for creating, manipulating, and
26 destroying minimal symbol tables.
28 Minimal symbol tables are used to hold some very basic information about
29 all defined global symbols (text, data, bss, abs, etc). The only two
30 required pieces of information are the symbol's name and the address
31 associated with that symbol.
33 In many cases, even if a file was compiled with no special options for
34 debugging at all, as long as was not stripped it will contain sufficient
35 information to build useful minimal symbol tables using this structure.
37 Even when a file contains enough debugging information to build a full
38 symbol table, these minimal symbols are still useful for quickly mapping
39 between names and addresses, and vice versa. They are also sometimes used
40 to figure out what full symbol table entries need to be read in. */
45 #include "gdb_string.h"
54 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
55 At the end, copy them all into one newly allocated location on an objfile's
58 #define BUNCH_SIZE 127
62 struct msym_bunch
*next
;
63 struct minimal_symbol contents
[BUNCH_SIZE
];
66 /* Bunch currently being filled up.
67 The next field points to chain of filled bunches. */
69 static struct msym_bunch
*msym_bunch
;
71 /* Number of slots filled in current bunch. */
73 static int msym_bunch_index
;
75 /* Total number of minimal symbols recorded so far for the objfile. */
77 static int msym_count
;
79 /* Compute a hash code based using the same criteria as `strcmp_iw'. */
82 msymbol_hash_iw (const char *string
)
84 unsigned int hash
= 0;
85 while (*string
&& *string
!= '(')
87 while (isspace (*string
))
89 if (*string
&& *string
!= '(')
91 hash
= hash
* 67 + *string
- 113;
98 /* Compute a hash code for a string. */
101 msymbol_hash (const char *string
)
103 unsigned int hash
= 0;
104 for (; *string
; ++string
)
105 hash
= hash
* 67 + *string
- 113;
109 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */
111 add_minsym_to_hash_table (struct minimal_symbol
*sym
,
112 struct minimal_symbol
**table
)
114 if (sym
->hash_next
== NULL
)
117 = msymbol_hash (SYMBOL_LINKAGE_NAME (sym
)) % MINIMAL_SYMBOL_HASH_SIZE
;
118 sym
->hash_next
= table
[hash
];
123 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
126 add_minsym_to_demangled_hash_table (struct minimal_symbol
*sym
,
127 struct minimal_symbol
**table
)
129 if (sym
->demangled_hash_next
== NULL
)
131 unsigned int hash
= msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym
)) % MINIMAL_SYMBOL_HASH_SIZE
;
132 sym
->demangled_hash_next
= table
[hash
];
138 /* Look through all the current minimal symbol tables and find the
139 first minimal symbol that matches NAME. If OBJF is non-NULL, limit
140 the search to that objfile. If SFILE is non-NULL, the only file-scope
141 symbols considered will be from that source file (global symbols are
142 still preferred). Returns a pointer to the minimal symbol that
143 matches, or NULL if no match is found.
145 Note: One instance where there may be duplicate minimal symbols with
146 the same name is when the symbol tables for a shared library and the
147 symbol tables for an executable contain global symbols with the same
148 names (the dynamic linker deals with the duplication). */
150 struct minimal_symbol
*
151 lookup_minimal_symbol (const char *name
, const char *sfile
,
152 struct objfile
*objf
)
154 struct objfile
*objfile
;
155 struct minimal_symbol
*msymbol
;
156 struct minimal_symbol
*found_symbol
= NULL
;
157 struct minimal_symbol
*found_file_symbol
= NULL
;
158 struct minimal_symbol
*trampoline_symbol
= NULL
;
160 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
161 unsigned int dem_hash
= msymbol_hash_iw (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
163 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
166 char *p
= strrchr (sfile
, '/');
172 for (objfile
= object_files
;
173 objfile
!= NULL
&& found_symbol
== NULL
;
174 objfile
= objfile
->next
)
176 if (objf
== NULL
|| objf
== objfile
)
178 /* Do two passes: the first over the ordinary hash table,
179 and the second over the demangled hash table. */
182 for (pass
= 1; pass
<= 2 && found_symbol
== NULL
; pass
++)
184 /* Select hash list according to pass. */
186 msymbol
= objfile
->msymbol_hash
[hash
];
188 msymbol
= objfile
->msymbol_demangled_hash
[dem_hash
];
190 while (msymbol
!= NULL
&& found_symbol
== NULL
)
192 /* FIXME: carlton/2003-02-27: This is an unholy
193 mixture of linkage names and natural names. If
194 you want to test the linkage names with strcmp,
195 do that. If you want to test the natural names
196 with strcmp_iw, use SYMBOL_MATCHES_NATURAL_NAME. */
197 if (strcmp (DEPRECATED_SYMBOL_NAME (msymbol
), (name
)) == 0
198 || (SYMBOL_DEMANGLED_NAME (msymbol
) != NULL
199 && strcmp_iw (SYMBOL_DEMANGLED_NAME (msymbol
),
202 switch (MSYMBOL_TYPE (msymbol
))
207 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
208 if (sfile
== NULL
|| STREQ (msymbol
->filename
, sfile
))
209 found_file_symbol
= msymbol
;
211 /* We have neither the ability nor the need to
212 deal with the SFILE parameter. If we find
213 more than one symbol, just return the latest
214 one (the user can't expect useful behavior in
216 found_file_symbol
= msymbol
;
220 case mst_solib_trampoline
:
222 /* If a trampoline symbol is found, we prefer to
223 keep looking for the *real* symbol. If the
224 actual symbol is not found, then we'll use the
226 if (trampoline_symbol
== NULL
)
227 trampoline_symbol
= msymbol
;
232 found_symbol
= msymbol
;
237 /* Find the next symbol on the hash chain. */
239 msymbol
= msymbol
->hash_next
;
241 msymbol
= msymbol
->demangled_hash_next
;
246 /* External symbols are best. */
250 /* File-local symbols are next best. */
251 if (found_file_symbol
)
252 return found_file_symbol
;
254 /* Symbols for shared library trampolines are next best. */
255 if (trampoline_symbol
)
256 return trampoline_symbol
;
261 /* Look through all the current minimal symbol tables and find the
262 first minimal symbol that matches NAME and has text type. If OBJF
263 is non-NULL, limit the search to that objfile. Returns a pointer
264 to the minimal symbol that matches, or NULL if no match is found.
266 This function only searches the mangled (linkage) names. */
268 struct minimal_symbol
*
269 lookup_minimal_symbol_text (const char *name
, struct objfile
*objf
)
271 struct objfile
*objfile
;
272 struct minimal_symbol
*msymbol
;
273 struct minimal_symbol
*found_symbol
= NULL
;
274 struct minimal_symbol
*found_file_symbol
= NULL
;
276 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
278 for (objfile
= object_files
;
279 objfile
!= NULL
&& found_symbol
== NULL
;
280 objfile
= objfile
->next
)
282 if (objf
== NULL
|| objf
== objfile
)
284 for (msymbol
= objfile
->msymbol_hash
[hash
];
285 msymbol
!= NULL
&& found_symbol
== NULL
;
286 msymbol
= msymbol
->hash_next
)
288 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol
), name
) == 0 &&
289 (MSYMBOL_TYPE (msymbol
) == mst_text
||
290 MSYMBOL_TYPE (msymbol
) == mst_file_text
))
292 switch (MSYMBOL_TYPE (msymbol
))
295 found_file_symbol
= msymbol
;
298 found_symbol
= msymbol
;
305 /* External symbols are best. */
309 /* File-local symbols are next best. */
310 if (found_file_symbol
)
311 return found_file_symbol
;
316 /* Look through all the current minimal symbol tables and find the
317 first minimal symbol that matches NAME and is a solib trampoline.
318 If OBJF is non-NULL, limit the search to that objfile. Returns a
319 pointer to the minimal symbol that matches, or NULL if no match is
322 This function only searches the mangled (linkage) names. */
324 struct minimal_symbol
*
325 lookup_minimal_symbol_solib_trampoline (const char *name
,
326 struct objfile
*objf
)
328 struct objfile
*objfile
;
329 struct minimal_symbol
*msymbol
;
330 struct minimal_symbol
*found_symbol
= NULL
;
332 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
334 for (objfile
= object_files
;
335 objfile
!= NULL
&& found_symbol
== NULL
;
336 objfile
= objfile
->next
)
338 if (objf
== NULL
|| objf
== objfile
)
340 for (msymbol
= objfile
->msymbol_hash
[hash
];
341 msymbol
!= NULL
&& found_symbol
== NULL
;
342 msymbol
= msymbol
->hash_next
)
344 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol
), name
) == 0 &&
345 MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
355 /* Search through the minimal symbol table for each objfile and find
356 the symbol whose address is the largest address that is still less
357 than or equal to PC, and matches SECTION (if non-null). Returns a
358 pointer to the minimal symbol if such a symbol is found, or NULL if
359 PC is not in a suitable range. Note that we need to look through
360 ALL the minimal symbol tables before deciding on the symbol that
361 comes closest to the specified PC. This is because objfiles can
362 overlap, for example objfile A has .text at 0x100 and .data at
363 0x40000 and objfile B has .text at 0x234 and .data at 0x40048. */
365 struct minimal_symbol
*
366 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc
, asection
*section
)
371 struct objfile
*objfile
;
372 struct minimal_symbol
*msymbol
;
373 struct minimal_symbol
*best_symbol
= NULL
;
374 struct obj_section
*pc_section
;
376 /* pc has to be in a known section. This ensures that anything beyond
377 the end of the last segment doesn't appear to be part of the last
378 function in the last segment. */
379 pc_section
= find_pc_section (pc
);
380 if (pc_section
== NULL
)
383 /* If no section was specified, then just make sure that the PC is in
384 the same section as the minimal symbol we find. */
386 section
= pc_section
->the_bfd_section
;
388 /* FIXME drow/2003-07-19: Should we also check that PC is in SECTION
389 if we were passed a non-NULL SECTION argument? */
391 for (objfile
= object_files
;
393 objfile
= objfile
->next
)
395 /* If this objfile has a minimal symbol table, go search it using
396 a binary search. Note that a minimal symbol table always consists
397 of at least two symbols, a "real" symbol and the terminating
398 "null symbol". If there are no real symbols, then there is no
399 minimal symbol table at all. */
401 if (objfile
->minimal_symbol_count
> 0)
403 msymbol
= objfile
->msymbols
;
405 hi
= objfile
->minimal_symbol_count
- 1;
407 /* This code assumes that the minimal symbols are sorted by
408 ascending address values. If the pc value is greater than or
409 equal to the first symbol's address, then some symbol in this
410 minimal symbol table is a suitable candidate for being the
411 "best" symbol. This includes the last real symbol, for cases
412 where the pc value is larger than any address in this vector.
414 By iterating until the address associated with the current
415 hi index (the endpoint of the test interval) is less than
416 or equal to the desired pc value, we accomplish two things:
417 (1) the case where the pc value is larger than any minimal
418 symbol address is trivially solved, (2) the address associated
419 with the hi index is always the one we want when the interation
420 terminates. In essence, we are iterating the test interval
421 down until the pc value is pushed out of it from the high end.
423 Warning: this code is trickier than it would appear at first. */
425 /* Should also require that pc is <= end of objfile. FIXME! */
426 if (pc
>= SYMBOL_VALUE_ADDRESS (&msymbol
[lo
]))
428 while (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]) > pc
)
430 /* pc is still strictly less than highest address */
431 /* Note "new" will always be >= lo */
433 if ((SYMBOL_VALUE_ADDRESS (&msymbol
[new]) >= pc
) ||
444 /* If we have multiple symbols at the same address, we want
445 hi to point to the last one. That way we can find the
446 right symbol if it has an index greater than hi. */
447 while (hi
< objfile
->minimal_symbol_count
- 1
448 && (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
449 == SYMBOL_VALUE_ADDRESS (&msymbol
[hi
+ 1])))
452 /* The minimal symbol indexed by hi now is the best one in this
453 objfile's minimal symbol table. See if it is the best one
456 /* Skip any absolute symbols. This is apparently what adb
457 and dbx do, and is needed for the CM-5. There are two
458 known possible problems: (1) on ELF, apparently end, edata,
459 etc. are absolute. Not sure ignoring them here is a big
460 deal, but if we want to use them, the fix would go in
461 elfread.c. (2) I think shared library entry points on the
462 NeXT are absolute. If we want special handling for this
463 it probably should be triggered by a special
464 mst_abs_or_lib or some such. */
466 && msymbol
[hi
].type
== mst_abs
)
469 /* If "section" specified, skip any symbol from wrong section */
470 /* This is the new code that distinguishes it from the old function */
473 /* Some types of debug info, such as COFF,
474 don't fill the bfd_section member, so don't
475 throw away symbols on those platforms. */
476 && SYMBOL_BFD_SECTION (&msymbol
[hi
]) != NULL
477 && SYMBOL_BFD_SECTION (&msymbol
[hi
]) != section
)
481 && ((best_symbol
== NULL
) ||
482 (SYMBOL_VALUE_ADDRESS (best_symbol
) <
483 SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]))))
485 best_symbol
= &msymbol
[hi
];
490 return (best_symbol
);
493 /* Backward compatibility: search through the minimal symbol table
494 for a matching PC (no section given) */
496 struct minimal_symbol
*
497 lookup_minimal_symbol_by_pc (CORE_ADDR pc
)
499 return lookup_minimal_symbol_by_pc_section (pc
, find_pc_mapped_section (pc
));
503 /* Return leading symbol character for a BFD. If BFD is NULL,
504 return the leading symbol character from the main objfile. */
506 static int get_symbol_leading_char (bfd
*);
509 get_symbol_leading_char (bfd
*abfd
)
512 return bfd_get_symbol_leading_char (abfd
);
513 if (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
)
514 return bfd_get_symbol_leading_char (symfile_objfile
->obfd
);
518 /* Prepare to start collecting minimal symbols. Note that presetting
519 msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
520 symbol to allocate the memory for the first bunch. */
523 init_minimal_symbol_collection (void)
527 msym_bunch_index
= BUNCH_SIZE
;
531 prim_record_minimal_symbol (const char *name
, CORE_ADDR address
,
532 enum minimal_symbol_type ms_type
,
533 struct objfile
*objfile
)
541 case mst_solib_trampoline
:
542 section
= SECT_OFF_TEXT (objfile
);
546 section
= SECT_OFF_DATA (objfile
);
550 section
= SECT_OFF_BSS (objfile
);
556 prim_record_minimal_symbol_and_info (name
, address
, ms_type
,
557 NULL
, section
, NULL
, objfile
);
560 /* Record a minimal symbol in the msym bunches. Returns the symbol
563 struct minimal_symbol
*
564 prim_record_minimal_symbol_and_info (const char *name
, CORE_ADDR address
,
565 enum minimal_symbol_type ms_type
,
566 char *info
, int section
,
567 asection
*bfd_section
,
568 struct objfile
*objfile
)
570 struct msym_bunch
*new;
571 struct minimal_symbol
*msymbol
;
573 if (ms_type
== mst_file_text
)
575 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
576 the minimal symbols, because if there is also another symbol
577 at the same address (e.g. the first function of the file),
578 lookup_minimal_symbol_by_pc would have no way of getting the
581 && (strcmp (name
, GCC_COMPILED_FLAG_SYMBOL
) == 0
582 || strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
586 const char *tempstring
= name
;
587 if (tempstring
[0] == get_symbol_leading_char (objfile
->obfd
))
589 if (strncmp (tempstring
, "__gnu_compiled", 14) == 0)
594 if (msym_bunch_index
== BUNCH_SIZE
)
596 new = (struct msym_bunch
*) xmalloc (sizeof (struct msym_bunch
));
597 msym_bunch_index
= 0;
598 new->next
= msym_bunch
;
601 msymbol
= &msym_bunch
->contents
[msym_bunch_index
];
602 SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol
, language_unknown
);
603 SYMBOL_LANGUAGE (msymbol
) = language_auto
;
604 SYMBOL_SET_NAMES (msymbol
, (char *)name
, strlen (name
), objfile
);
606 SYMBOL_VALUE_ADDRESS (msymbol
) = address
;
607 SYMBOL_SECTION (msymbol
) = section
;
608 SYMBOL_BFD_SECTION (msymbol
) = bfd_section
;
610 MSYMBOL_TYPE (msymbol
) = ms_type
;
611 /* FIXME: This info, if it remains, needs its own field. */
612 MSYMBOL_INFO (msymbol
) = info
; /* FIXME! */
614 /* The hash pointers must be cleared! If they're not,
615 add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
616 msymbol
->hash_next
= NULL
;
617 msymbol
->demangled_hash_next
= NULL
;
621 OBJSTAT (objfile
, n_minsyms
++);
625 /* Compare two minimal symbols by address and return a signed result based
626 on unsigned comparisons, so that we sort into unsigned numeric order.
627 Within groups with the same address, sort by name. */
630 compare_minimal_symbols (const void *fn1p
, const void *fn2p
)
632 const struct minimal_symbol
*fn1
;
633 const struct minimal_symbol
*fn2
;
635 fn1
= (const struct minimal_symbol
*) fn1p
;
636 fn2
= (const struct minimal_symbol
*) fn2p
;
638 if (SYMBOL_VALUE_ADDRESS (fn1
) < SYMBOL_VALUE_ADDRESS (fn2
))
640 return (-1); /* addr 1 is less than addr 2 */
642 else if (SYMBOL_VALUE_ADDRESS (fn1
) > SYMBOL_VALUE_ADDRESS (fn2
))
644 return (1); /* addr 1 is greater than addr 2 */
647 /* addrs are equal: sort by name */
649 char *name1
= SYMBOL_LINKAGE_NAME (fn1
);
650 char *name2
= SYMBOL_LINKAGE_NAME (fn2
);
652 if (name1
&& name2
) /* both have names */
653 return strcmp (name1
, name2
);
655 return 1; /* fn1 has no name, so it is "less" */
656 else if (name1
) /* fn2 has no name, so it is "less" */
659 return (0); /* neither has a name, so they're equal. */
663 /* Discard the currently collected minimal symbols, if any. If we wish
664 to save them for later use, we must have already copied them somewhere
665 else before calling this function.
667 FIXME: We could allocate the minimal symbol bunches on their own
668 obstack and then simply blow the obstack away when we are done with
669 it. Is it worth the extra trouble though? */
672 do_discard_minimal_symbols_cleanup (void *arg
)
674 struct msym_bunch
*next
;
676 while (msym_bunch
!= NULL
)
678 next
= msym_bunch
->next
;
685 make_cleanup_discard_minimal_symbols (void)
687 return make_cleanup (do_discard_minimal_symbols_cleanup
, 0);
692 /* Compact duplicate entries out of a minimal symbol table by walking
693 through the table and compacting out entries with duplicate addresses
694 and matching names. Return the number of entries remaining.
696 On entry, the table resides between msymbol[0] and msymbol[mcount].
697 On exit, it resides between msymbol[0] and msymbol[result_count].
699 When files contain multiple sources of symbol information, it is
700 possible for the minimal symbol table to contain many duplicate entries.
701 As an example, SVR4 systems use ELF formatted object files, which
702 usually contain at least two different types of symbol tables (a
703 standard ELF one and a smaller dynamic linking table), as well as
704 DWARF debugging information for files compiled with -g.
706 Without compacting, the minimal symbol table for gdb itself contains
707 over a 1000 duplicates, about a third of the total table size. Aside
708 from the potential trap of not noticing that two successive entries
709 identify the same location, this duplication impacts the time required
710 to linearly scan the table, which is done in a number of places. So we
711 just do one linear scan here and toss out the duplicates.
713 Note that we are not concerned here about recovering the space that
714 is potentially freed up, because the strings themselves are allocated
715 on the symbol_obstack, and will get automatically freed when the symbol
716 table is freed. The caller can free up the unused minimal symbols at
717 the end of the compacted region if their allocation strategy allows it.
719 Also note we only go up to the next to last entry within the loop
720 and then copy the last entry explicitly after the loop terminates.
722 Since the different sources of information for each symbol may
723 have different levels of "completeness", we may have duplicates
724 that have one entry with type "mst_unknown" and the other with a
725 known type. So if the one we are leaving alone has type mst_unknown,
726 overwrite its type with the type from the one we are compacting out. */
729 compact_minimal_symbols (struct minimal_symbol
*msymbol
, int mcount
,
730 struct objfile
*objfile
)
732 struct minimal_symbol
*copyfrom
;
733 struct minimal_symbol
*copyto
;
737 copyfrom
= copyto
= msymbol
;
738 while (copyfrom
< msymbol
+ mcount
- 1)
740 if (SYMBOL_VALUE_ADDRESS (copyfrom
) ==
741 SYMBOL_VALUE_ADDRESS ((copyfrom
+ 1)) &&
742 (STREQ (SYMBOL_LINKAGE_NAME (copyfrom
),
743 SYMBOL_LINKAGE_NAME ((copyfrom
+ 1)))))
745 if (MSYMBOL_TYPE ((copyfrom
+ 1)) == mst_unknown
)
747 MSYMBOL_TYPE ((copyfrom
+ 1)) = MSYMBOL_TYPE (copyfrom
);
752 *copyto
++ = *copyfrom
++;
754 *copyto
++ = *copyfrom
++;
755 mcount
= copyto
- msymbol
;
760 /* Build (or rebuild) the minimal symbol hash tables. This is necessary
761 after compacting or sorting the table since the entries move around
762 thus causing the internal minimal_symbol pointers to become jumbled. */
765 build_minimal_symbol_hash_tables (struct objfile
*objfile
)
768 struct minimal_symbol
*msym
;
770 /* Clear the hash tables. */
771 for (i
= 0; i
< MINIMAL_SYMBOL_HASH_SIZE
; i
++)
773 objfile
->msymbol_hash
[i
] = 0;
774 objfile
->msymbol_demangled_hash
[i
] = 0;
777 /* Now, (re)insert the actual entries. */
778 for (i
= objfile
->minimal_symbol_count
, msym
= objfile
->msymbols
;
783 add_minsym_to_hash_table (msym
, objfile
->msymbol_hash
);
785 msym
->demangled_hash_next
= 0;
786 if (SYMBOL_DEMANGLED_NAME (msym
) != NULL
)
787 add_minsym_to_demangled_hash_table (msym
,
788 objfile
->msymbol_demangled_hash
);
792 /* Add the minimal symbols in the existing bunches to the objfile's official
793 minimal symbol table. In most cases there is no minimal symbol table yet
794 for this objfile, and the existing bunches are used to create one. Once
795 in a while (for shared libraries for example), we add symbols (e.g. common
796 symbols) to an existing objfile.
798 Because of the way minimal symbols are collected, we generally have no way
799 of knowing what source language applies to any particular minimal symbol.
800 Specifically, we have no way of knowing if the minimal symbol comes from a
801 C++ compilation unit or not. So for the sake of supporting cached
802 demangled C++ names, we have no choice but to try and demangle each new one
803 that comes in. If the demangling succeeds, then we assume it is a C++
804 symbol and set the symbol's language and demangled name fields
805 appropriately. Note that in order to avoid unnecessary demanglings, and
806 allocating obstack space that subsequently can't be freed for the demangled
807 names, we mark all newly added symbols with language_auto. After
808 compaction of the minimal symbols, we go back and scan the entire minimal
809 symbol table looking for these new symbols. For each new symbol we attempt
810 to demangle it, and if successful, record it as a language_cplus symbol
811 and cache the demangled form on the symbol obstack. Symbols which don't
812 demangle are marked as language_unknown symbols, which inhibits future
813 attempts to demangle them if we later add more minimal symbols. */
816 install_minimal_symbols (struct objfile
*objfile
)
820 struct msym_bunch
*bunch
;
821 struct minimal_symbol
*msymbols
;
827 /* Allocate enough space in the obstack, into which we will gather the
828 bunches of new and existing minimal symbols, sort them, and then
829 compact out the duplicate entries. Once we have a final table,
830 we will give back the excess space. */
832 alloc_count
= msym_count
+ objfile
->minimal_symbol_count
+ 1;
833 obstack_blank (&objfile
->symbol_obstack
,
834 alloc_count
* sizeof (struct minimal_symbol
));
835 msymbols
= (struct minimal_symbol
*)
836 obstack_base (&objfile
->symbol_obstack
);
838 /* Copy in the existing minimal symbols, if there are any. */
840 if (objfile
->minimal_symbol_count
)
841 memcpy ((char *) msymbols
, (char *) objfile
->msymbols
,
842 objfile
->minimal_symbol_count
* sizeof (struct minimal_symbol
));
844 /* Walk through the list of minimal symbol bunches, adding each symbol
845 to the new contiguous array of symbols. Note that we start with the
846 current, possibly partially filled bunch (thus we use the current
847 msym_bunch_index for the first bunch we copy over), and thereafter
848 each bunch is full. */
850 mcount
= objfile
->minimal_symbol_count
;
851 leading_char
= get_symbol_leading_char (objfile
->obfd
);
853 for (bunch
= msym_bunch
; bunch
!= NULL
; bunch
= bunch
->next
)
855 for (bindex
= 0; bindex
< msym_bunch_index
; bindex
++, mcount
++)
857 msymbols
[mcount
] = bunch
->contents
[bindex
];
858 if (SYMBOL_LINKAGE_NAME (&msymbols
[mcount
])[0] == leading_char
)
860 SYMBOL_LINKAGE_NAME (&msymbols
[mcount
])++;
863 msym_bunch_index
= BUNCH_SIZE
;
866 /* Sort the minimal symbols by address. */
868 qsort (msymbols
, mcount
, sizeof (struct minimal_symbol
),
869 compare_minimal_symbols
);
871 /* Compact out any duplicates, and free up whatever space we are
874 mcount
= compact_minimal_symbols (msymbols
, mcount
, objfile
);
876 obstack_blank (&objfile
->symbol_obstack
,
877 (mcount
+ 1 - alloc_count
) * sizeof (struct minimal_symbol
));
878 msymbols
= (struct minimal_symbol
*)
879 obstack_finish (&objfile
->symbol_obstack
);
881 /* We also terminate the minimal symbol table with a "null symbol",
882 which is *not* included in the size of the table. This makes it
883 easier to find the end of the table when we are handed a pointer
884 to some symbol in the middle of it. Zero out the fields in the
885 "null symbol" allocated at the end of the array. Note that the
886 symbol count does *not* include this null symbol, which is why it
887 is indexed by mcount and not mcount-1. */
889 SYMBOL_LINKAGE_NAME (&msymbols
[mcount
]) = NULL
;
890 SYMBOL_VALUE_ADDRESS (&msymbols
[mcount
]) = 0;
891 MSYMBOL_INFO (&msymbols
[mcount
]) = NULL
;
892 MSYMBOL_TYPE (&msymbols
[mcount
]) = mst_unknown
;
893 SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols
[mcount
], language_unknown
);
895 /* Attach the minimal symbol table to the specified objfile.
896 The strings themselves are also located in the symbol_obstack
899 objfile
->minimal_symbol_count
= mcount
;
900 objfile
->msymbols
= msymbols
;
902 /* Try to guess the appropriate C++ ABI by looking at the names
903 of the minimal symbols in the table. */
907 for (i
= 0; i
< mcount
; i
++)
909 /* If a symbol's name starts with _Z and was successfully
910 demangled, then we can assume we've found a GNU v3 symbol.
911 For now we set the C++ ABI globally; if the user is
912 mixing ABIs then the user will need to "set cp-abi"
914 const char *name
= SYMBOL_LINKAGE_NAME (&objfile
->msymbols
[i
]);
915 if (name
[0] == '_' && name
[1] == 'Z'
916 && SYMBOL_DEMANGLED_NAME (&objfile
->msymbols
[i
]) != NULL
)
918 set_cp_abi_as_auto_default ("gnu-v3");
924 /* Now build the hash tables; we can't do this incrementally
925 at an earlier point since we weren't finished with the obstack
926 yet. (And if the msymbol obstack gets moved, all the internal
927 pointers to other msymbols need to be adjusted.) */
928 build_minimal_symbol_hash_tables (objfile
);
932 /* Sort all the minimal symbols in OBJFILE. */
935 msymbols_sort (struct objfile
*objfile
)
937 qsort (objfile
->msymbols
, objfile
->minimal_symbol_count
,
938 sizeof (struct minimal_symbol
), compare_minimal_symbols
);
939 build_minimal_symbol_hash_tables (objfile
);
942 /* Check if PC is in a shared library trampoline code stub.
943 Return minimal symbol for the trampoline entry or NULL if PC is not
944 in a trampoline code stub. */
946 struct minimal_symbol
*
947 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc
)
949 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
951 if (msymbol
!= NULL
&& MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
956 /* If PC is in a shared library trampoline code stub, return the
957 address of the `real' function belonging to the stub.
958 Return 0 if PC is not in a trampoline code stub or if the real
959 function is not found in the minimal symbol table.
961 We may fail to find the right function if a function with the
962 same name is defined in more than one shared library, but this
963 is considered bad programming style. We could return 0 if we find
964 a duplicate function in case this matters someday. */
967 find_solib_trampoline_target (CORE_ADDR pc
)
969 struct objfile
*objfile
;
970 struct minimal_symbol
*msymbol
;
971 struct minimal_symbol
*tsymbol
= lookup_solib_trampoline_symbol_by_pc (pc
);
975 ALL_MSYMBOLS (objfile
, msymbol
)
977 if (MSYMBOL_TYPE (msymbol
) == mst_text
978 && STREQ (SYMBOL_LINKAGE_NAME (msymbol
),
979 SYMBOL_LINKAGE_NAME (tsymbol
)))
980 return SYMBOL_VALUE_ADDRESS (msymbol
);