1 /* GDB routines for manipulating the minimal symbol tables.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2007, 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>. */
22 /* This file contains support routines for creating, manipulating, and
23 destroying minimal symbol tables.
25 Minimal symbol tables are used to hold some very basic information about
26 all defined global symbols (text, data, bss, abs, etc). The only two
27 required pieces of information are the symbol's name and the address
28 associated with that symbol.
30 In many cases, even if a file was compiled with no special options for
31 debugging at all, as long as was not stripped it will contain sufficient
32 information to build useful minimal symbol tables using this structure.
34 Even when a file contains enough debugging information to build a full
35 symbol table, these minimal symbols are still useful for quickly mapping
36 between names and addresses, and vice versa. They are also sometimes used
37 to figure out what full symbol table entries need to be read in. */
42 #include "gdb_string.h"
51 #include "cp-support.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;
86 while (*string
&& *string
!= '(')
88 while (isspace (*string
))
90 if (*string
&& *string
!= '(')
92 hash
= hash
* 67 + *string
- 113;
99 /* Compute a hash code for a string. */
102 msymbol_hash (const char *string
)
104 unsigned int hash
= 0;
106 for (; *string
; ++string
)
107 hash
= hash
* 67 + *string
- 113;
111 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */
113 add_minsym_to_hash_table (struct minimal_symbol
*sym
,
114 struct minimal_symbol
**table
)
116 if (sym
->hash_next
== NULL
)
119 = msymbol_hash (SYMBOL_LINKAGE_NAME (sym
)) % MINIMAL_SYMBOL_HASH_SIZE
;
121 sym
->hash_next
= table
[hash
];
126 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
129 add_minsym_to_demangled_hash_table (struct minimal_symbol
*sym
,
130 struct minimal_symbol
**table
)
132 if (sym
->demangled_hash_next
== NULL
)
135 = msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym
)) % MINIMAL_SYMBOL_HASH_SIZE
;
137 sym
->demangled_hash_next
= table
[hash
];
143 /* Return OBJFILE where minimal symbol SYM is defined. */
145 msymbol_objfile (struct minimal_symbol
*sym
)
147 struct objfile
*objf
;
148 struct minimal_symbol
*tsym
;
151 = msymbol_hash (SYMBOL_LINKAGE_NAME (sym
)) % MINIMAL_SYMBOL_HASH_SIZE
;
153 for (objf
= object_files
; objf
; objf
= objf
->next
)
154 for (tsym
= objf
->msymbol_hash
[hash
]; tsym
; tsym
= tsym
->hash_next
)
158 /* We should always be able to find the objfile ... */
159 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
163 /* Look through all the current minimal symbol tables and find the
164 first minimal symbol that matches NAME. If OBJF is non-NULL, limit
165 the search to that objfile. If SFILE is non-NULL, the only file-scope
166 symbols considered will be from that source file (global symbols are
167 still preferred). Returns a pointer to the minimal symbol that
168 matches, or NULL if no match is found.
170 Note: One instance where there may be duplicate minimal symbols with
171 the same name is when the symbol tables for a shared library and the
172 symbol tables for an executable contain global symbols with the same
173 names (the dynamic linker deals with the duplication).
175 It's also possible to have minimal symbols with different mangled
176 names, but identical demangled names. For example, the GNU C++ v3
177 ABI requires the generation of two (or perhaps three) copies of
178 constructor functions --- "in-charge", "not-in-charge", and
179 "allocate" copies; destructors may be duplicated as well.
180 Obviously, there must be distinct mangled names for each of these,
181 but the demangled names are all the same: S::S or S::~S. */
183 struct minimal_symbol
*
184 lookup_minimal_symbol (const char *name
, const char *sfile
,
185 struct objfile
*objf
)
187 struct objfile
*objfile
;
188 struct minimal_symbol
*msymbol
;
189 struct minimal_symbol
*found_symbol
= NULL
;
190 struct minimal_symbol
*found_file_symbol
= NULL
;
191 struct minimal_symbol
*trampoline_symbol
= NULL
;
193 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
194 unsigned int dem_hash
= msymbol_hash_iw (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
196 int needtofreename
= 0;
197 const char *modified_name
;
201 char *p
= strrchr (sfile
, '/');
207 /* For C++, canonicalize the input name. */
208 modified_name
= name
;
209 if (current_language
->la_language
== language_cplus
)
211 char *cname
= cp_canonicalize_string (name
);
215 modified_name
= cname
;
220 for (objfile
= object_files
;
221 objfile
!= NULL
&& found_symbol
== NULL
;
222 objfile
= objfile
->next
)
224 if (objf
== NULL
|| objf
== objfile
225 || objf
== objfile
->separate_debug_objfile_backlink
)
227 /* Do two passes: the first over the ordinary hash table,
228 and the second over the demangled hash table. */
231 for (pass
= 1; pass
<= 2 && found_symbol
== NULL
; pass
++)
233 /* Select hash list according to pass. */
235 msymbol
= objfile
->msymbol_hash
[hash
];
237 msymbol
= objfile
->msymbol_demangled_hash
[dem_hash
];
239 while (msymbol
!= NULL
&& found_symbol
== NULL
)
245 match
= strcmp (SYMBOL_LINKAGE_NAME (msymbol
),
250 match
= SYMBOL_MATCHES_SEARCH_NAME (msymbol
,
256 switch (MSYMBOL_TYPE (msymbol
))
262 || strcmp (msymbol
->filename
, sfile
) == 0)
263 found_file_symbol
= msymbol
;
266 case mst_solib_trampoline
:
268 /* If a trampoline symbol is found, we prefer to
269 keep looking for the *real* symbol. If the
270 actual symbol is not found, then we'll use the
272 if (trampoline_symbol
== NULL
)
273 trampoline_symbol
= msymbol
;
278 found_symbol
= msymbol
;
283 /* Find the next symbol on the hash chain. */
285 msymbol
= msymbol
->hash_next
;
287 msymbol
= msymbol
->demangled_hash_next
;
294 xfree ((void *) modified_name
);
296 /* External symbols are best. */
300 /* File-local symbols are next best. */
301 if (found_file_symbol
)
302 return found_file_symbol
;
304 /* Symbols for shared library trampolines are next best. */
305 if (trampoline_symbol
)
306 return trampoline_symbol
;
311 /* Look through all the current minimal symbol tables and find the
312 first minimal symbol that matches NAME and has text type. If OBJF
313 is non-NULL, limit the search to that objfile. Returns a pointer
314 to the minimal symbol that matches, or NULL if no match is found.
316 This function only searches the mangled (linkage) names. */
318 struct minimal_symbol
*
319 lookup_minimal_symbol_text (const char *name
, struct objfile
*objf
)
321 struct objfile
*objfile
;
322 struct minimal_symbol
*msymbol
;
323 struct minimal_symbol
*found_symbol
= NULL
;
324 struct minimal_symbol
*found_file_symbol
= NULL
;
326 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
328 for (objfile
= object_files
;
329 objfile
!= NULL
&& found_symbol
== NULL
;
330 objfile
= objfile
->next
)
332 if (objf
== NULL
|| objf
== objfile
333 || objf
== objfile
->separate_debug_objfile_backlink
)
335 for (msymbol
= objfile
->msymbol_hash
[hash
];
336 msymbol
!= NULL
&& found_symbol
== NULL
;
337 msymbol
= msymbol
->hash_next
)
339 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol
), name
) == 0 &&
340 (MSYMBOL_TYPE (msymbol
) == mst_text
||
341 MSYMBOL_TYPE (msymbol
) == mst_file_text
))
343 switch (MSYMBOL_TYPE (msymbol
))
346 found_file_symbol
= msymbol
;
349 found_symbol
= msymbol
;
356 /* External symbols are best. */
360 /* File-local symbols are next best. */
361 if (found_file_symbol
)
362 return found_file_symbol
;
367 /* Look through all the current minimal symbol tables and find the
368 first minimal symbol that matches NAME and PC. If OBJF is non-NULL,
369 limit the search to that objfile. Returns a pointer to the minimal
370 symbol that matches, or NULL if no match is found. */
372 struct minimal_symbol
*
373 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc
, const char *name
,
374 struct objfile
*objf
)
376 struct objfile
*objfile
;
377 struct minimal_symbol
*msymbol
;
379 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
381 for (objfile
= object_files
;
383 objfile
= objfile
->next
)
385 if (objf
== NULL
|| objf
== objfile
386 || objf
== objfile
->separate_debug_objfile_backlink
)
388 for (msymbol
= objfile
->msymbol_hash
[hash
];
390 msymbol
= msymbol
->hash_next
)
392 if (SYMBOL_VALUE_ADDRESS (msymbol
) == pc
393 && strcmp (SYMBOL_LINKAGE_NAME (msymbol
), name
) == 0)
402 /* Look through all the current minimal symbol tables and find the
403 first minimal symbol that matches NAME and is a solib trampoline.
404 If OBJF is non-NULL, limit the search to that objfile. Returns a
405 pointer to the minimal symbol that matches, or NULL if no match is
408 This function only searches the mangled (linkage) names. */
410 struct minimal_symbol
*
411 lookup_minimal_symbol_solib_trampoline (const char *name
,
412 struct objfile
*objf
)
414 struct objfile
*objfile
;
415 struct minimal_symbol
*msymbol
;
416 struct minimal_symbol
*found_symbol
= NULL
;
418 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
420 for (objfile
= object_files
;
421 objfile
!= NULL
&& found_symbol
== NULL
;
422 objfile
= objfile
->next
)
424 if (objf
== NULL
|| objf
== objfile
425 || objf
== objfile
->separate_debug_objfile_backlink
)
427 for (msymbol
= objfile
->msymbol_hash
[hash
];
428 msymbol
!= NULL
&& found_symbol
== NULL
;
429 msymbol
= msymbol
->hash_next
)
431 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol
), name
) == 0 &&
432 MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
441 /* Search through the minimal symbol table for each objfile and find
442 the symbol whose address is the largest address that is still less
443 than or equal to PC, and matches SECTION (which is not NULL).
444 Returns a pointer to the minimal symbol if such a symbol is found,
445 or NULL if PC is not in a suitable range.
446 Note that we need to look through ALL the minimal symbol tables
447 before deciding on the symbol that comes closest to the specified PC.
448 This is because objfiles can overlap, for example objfile A has .text
449 at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
452 If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
453 there are text and trampoline symbols at the same address.
454 Otherwise prefer mst_text symbols. */
456 static struct minimal_symbol
*
457 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc
,
458 struct obj_section
*section
,
464 struct objfile
*objfile
;
465 struct minimal_symbol
*msymbol
;
466 struct minimal_symbol
*best_symbol
= NULL
;
467 enum minimal_symbol_type want_type
, other_type
;
469 want_type
= want_trampoline
? mst_solib_trampoline
: mst_text
;
470 other_type
= want_trampoline
? mst_text
: mst_solib_trampoline
;
472 /* We can not require the symbol found to be in section, because
473 e.g. IRIX 6.5 mdebug relies on this code returning an absolute
474 symbol - but find_pc_section won't return an absolute section and
475 hence the code below would skip over absolute symbols. We can
476 still take advantage of the call to find_pc_section, though - the
477 object file still must match. In case we have separate debug
478 files, search both the file and its separate debug file. There's
479 no telling which one will have the minimal symbols. */
481 gdb_assert (section
!= NULL
);
483 for (objfile
= section
->objfile
;
485 objfile
= objfile_separate_debug_iterate (section
->objfile
, objfile
))
487 /* If this objfile has a minimal symbol table, go search it using
488 a binary search. Note that a minimal symbol table always consists
489 of at least two symbols, a "real" symbol and the terminating
490 "null symbol". If there are no real symbols, then there is no
491 minimal symbol table at all. */
493 if (objfile
->minimal_symbol_count
> 0)
495 int best_zero_sized
= -1;
497 msymbol
= objfile
->msymbols
;
499 hi
= objfile
->minimal_symbol_count
- 1;
501 /* This code assumes that the minimal symbols are sorted by
502 ascending address values. If the pc value is greater than or
503 equal to the first symbol's address, then some symbol in this
504 minimal symbol table is a suitable candidate for being the
505 "best" symbol. This includes the last real symbol, for cases
506 where the pc value is larger than any address in this vector.
508 By iterating until the address associated with the current
509 hi index (the endpoint of the test interval) is less than
510 or equal to the desired pc value, we accomplish two things:
511 (1) the case where the pc value is larger than any minimal
512 symbol address is trivially solved, (2) the address associated
513 with the hi index is always the one we want when the interation
514 terminates. In essence, we are iterating the test interval
515 down until the pc value is pushed out of it from the high end.
517 Warning: this code is trickier than it would appear at first. */
519 /* Should also require that pc is <= end of objfile. FIXME! */
520 if (pc
>= SYMBOL_VALUE_ADDRESS (&msymbol
[lo
]))
522 while (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]) > pc
)
524 /* pc is still strictly less than highest address */
525 /* Note "new" will always be >= lo */
527 if ((SYMBOL_VALUE_ADDRESS (&msymbol
[new]) >= pc
) ||
538 /* If we have multiple symbols at the same address, we want
539 hi to point to the last one. That way we can find the
540 right symbol if it has an index greater than hi. */
541 while (hi
< objfile
->minimal_symbol_count
- 1
542 && (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
543 == SYMBOL_VALUE_ADDRESS (&msymbol
[hi
+ 1])))
546 /* Skip various undesirable symbols. */
549 /* Skip any absolute symbols. This is apparently
550 what adb and dbx do, and is needed for the CM-5.
551 There are two known possible problems: (1) on
552 ELF, apparently end, edata, etc. are absolute.
553 Not sure ignoring them here is a big deal, but if
554 we want to use them, the fix would go in
555 elfread.c. (2) I think shared library entry
556 points on the NeXT are absolute. If we want
557 special handling for this it probably should be
558 triggered by a special mst_abs_or_lib or some
561 if (MSYMBOL_TYPE (&msymbol
[hi
]) == mst_abs
)
567 /* If SECTION was specified, skip any symbol from
570 /* Some types of debug info, such as COFF,
571 don't fill the bfd_section member, so don't
572 throw away symbols on those platforms. */
573 && SYMBOL_OBJ_SECTION (&msymbol
[hi
]) != NULL
574 && (!matching_obj_sections
575 (SYMBOL_OBJ_SECTION (&msymbol
[hi
]), section
)))
581 /* If we are looking for a trampoline and this is a
582 text symbol, or the other way around, check the
583 preceeding symbol too. If they are otherwise
584 identical prefer that one. */
586 && MSYMBOL_TYPE (&msymbol
[hi
]) == other_type
587 && MSYMBOL_TYPE (&msymbol
[hi
- 1]) == want_type
588 && (MSYMBOL_SIZE (&msymbol
[hi
])
589 == MSYMBOL_SIZE (&msymbol
[hi
- 1]))
590 && (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
591 == SYMBOL_VALUE_ADDRESS (&msymbol
[hi
- 1]))
592 && (SYMBOL_OBJ_SECTION (&msymbol
[hi
])
593 == SYMBOL_OBJ_SECTION (&msymbol
[hi
- 1])))
599 /* If the minimal symbol has a zero size, save it
600 but keep scanning backwards looking for one with
601 a non-zero size. A zero size may mean that the
602 symbol isn't an object or function (e.g. a
603 label), or it may just mean that the size was not
605 if (MSYMBOL_SIZE (&msymbol
[hi
]) == 0
606 && best_zero_sized
== -1)
608 best_zero_sized
= hi
;
613 /* If we are past the end of the current symbol, try
614 the previous symbol if it has a larger overlapping
615 size. This happens on i686-pc-linux-gnu with glibc;
616 the nocancel variants of system calls are inside
617 the cancellable variants, but both have sizes. */
619 && MSYMBOL_SIZE (&msymbol
[hi
]) != 0
620 && pc
>= (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
621 + MSYMBOL_SIZE (&msymbol
[hi
]))
622 && pc
< (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
- 1])
623 + MSYMBOL_SIZE (&msymbol
[hi
- 1])))
629 /* Otherwise, this symbol must be as good as we're going
634 /* If HI has a zero size, and best_zero_sized is set,
635 then we had two or more zero-sized symbols; prefer
636 the first one we found (which may have a higher
637 address). Also, if we ran off the end, be sure
639 if (best_zero_sized
!= -1
640 && (hi
< 0 || MSYMBOL_SIZE (&msymbol
[hi
]) == 0))
641 hi
= best_zero_sized
;
643 /* If the minimal symbol has a non-zero size, and this
644 PC appears to be outside the symbol's contents, then
645 refuse to use this symbol. If we found a zero-sized
646 symbol with an address greater than this symbol's,
647 use that instead. We assume that if symbols have
648 specified sizes, they do not overlap. */
651 && MSYMBOL_SIZE (&msymbol
[hi
]) != 0
652 && pc
>= (SYMBOL_VALUE_ADDRESS (&msymbol
[hi
])
653 + MSYMBOL_SIZE (&msymbol
[hi
])))
655 if (best_zero_sized
!= -1)
656 hi
= best_zero_sized
;
658 /* Go on to the next object file. */
662 /* The minimal symbol indexed by hi now is the best one in this
663 objfile's minimal symbol table. See if it is the best one
667 && ((best_symbol
== NULL
) ||
668 (SYMBOL_VALUE_ADDRESS (best_symbol
) <
669 SYMBOL_VALUE_ADDRESS (&msymbol
[hi
]))))
671 best_symbol
= &msymbol
[hi
];
676 return (best_symbol
);
679 struct minimal_symbol
*
680 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc
, struct obj_section
*section
)
684 /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
685 force the section but that (well unless you're doing overlay
686 debugging) always returns NULL making the call somewhat useless. */
687 section
= find_pc_section (pc
);
691 return lookup_minimal_symbol_by_pc_section_1 (pc
, section
, 0);
694 /* Backward compatibility: search through the minimal symbol table
695 for a matching PC (no section given) */
697 struct minimal_symbol
*
698 lookup_minimal_symbol_by_pc (CORE_ADDR pc
)
700 return lookup_minimal_symbol_by_pc_section (pc
, NULL
);
703 /* Find the minimal symbol named NAME, and return both the minsym
704 struct and its objfile. This only checks the linkage name. Sets
705 *OBJFILE_P and returns the minimal symbol, if it is found. If it
706 is not found, returns NULL. */
708 struct minimal_symbol
*
709 lookup_minimal_symbol_and_objfile (const char *name
,
710 struct objfile
**objfile_p
)
712 struct objfile
*objfile
;
713 unsigned int hash
= msymbol_hash (name
) % MINIMAL_SYMBOL_HASH_SIZE
;
715 ALL_OBJFILES (objfile
)
717 struct minimal_symbol
*msym
;
719 for (msym
= objfile
->msymbol_hash
[hash
];
721 msym
= msym
->hash_next
)
723 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
725 *objfile_p
= objfile
;
735 /* Return leading symbol character for a BFD. If BFD is NULL,
736 return the leading symbol character from the main objfile. */
738 static int get_symbol_leading_char (bfd
*);
741 get_symbol_leading_char (bfd
*abfd
)
744 return bfd_get_symbol_leading_char (abfd
);
745 if (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
)
746 return bfd_get_symbol_leading_char (symfile_objfile
->obfd
);
750 /* Prepare to start collecting minimal symbols. Note that presetting
751 msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
752 symbol to allocate the memory for the first bunch. */
755 init_minimal_symbol_collection (void)
759 msym_bunch_index
= BUNCH_SIZE
;
763 prim_record_minimal_symbol (const char *name
, CORE_ADDR address
,
764 enum minimal_symbol_type ms_type
,
765 struct objfile
*objfile
)
773 case mst_solib_trampoline
:
774 section
= SECT_OFF_TEXT (objfile
);
778 section
= SECT_OFF_DATA (objfile
);
782 section
= SECT_OFF_BSS (objfile
);
788 prim_record_minimal_symbol_and_info (name
, address
, ms_type
,
789 section
, NULL
, objfile
);
792 /* Record a minimal symbol in the msym bunches. Returns the symbol
795 struct minimal_symbol
*
796 prim_record_minimal_symbol_full (const char *name
, int name_len
, int copy_name
,
798 enum minimal_symbol_type ms_type
,
800 asection
*bfd_section
,
801 struct objfile
*objfile
)
803 struct obj_section
*obj_section
;
804 struct msym_bunch
*new;
805 struct minimal_symbol
*msymbol
;
807 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
808 the minimal symbols, because if there is also another symbol
809 at the same address (e.g. the first function of the file),
810 lookup_minimal_symbol_by_pc would have no way of getting the
812 if (ms_type
== mst_file_text
&& name
[0] == 'g'
813 && (strcmp (name
, GCC_COMPILED_FLAG_SYMBOL
) == 0
814 || strcmp (name
, GCC2_COMPILED_FLAG_SYMBOL
) == 0))
817 /* It's safe to strip the leading char here once, since the name
818 is also stored stripped in the minimal symbol table. */
819 if (name
[0] == get_symbol_leading_char (objfile
->obfd
))
825 if (ms_type
== mst_file_text
&& strncmp (name
, "__gnu_compiled", 14) == 0)
828 if (msym_bunch_index
== BUNCH_SIZE
)
830 new = XCALLOC (1, struct msym_bunch
);
831 msym_bunch_index
= 0;
832 new->next
= msym_bunch
;
835 msymbol
= &msym_bunch
->contents
[msym_bunch_index
];
836 SYMBOL_SET_LANGUAGE (msymbol
, language_auto
);
837 SYMBOL_SET_NAMES (msymbol
, name
, name_len
, copy_name
, objfile
);
839 SYMBOL_VALUE_ADDRESS (msymbol
) = address
;
840 SYMBOL_SECTION (msymbol
) = section
;
841 SYMBOL_OBJ_SECTION (msymbol
) = NULL
;
843 /* Find obj_section corresponding to bfd_section. */
845 ALL_OBJFILE_OSECTIONS (objfile
, obj_section
)
847 if (obj_section
->the_bfd_section
== bfd_section
)
849 SYMBOL_OBJ_SECTION (msymbol
) = obj_section
;
854 MSYMBOL_TYPE (msymbol
) = ms_type
;
855 MSYMBOL_TARGET_FLAG_1 (msymbol
) = 0;
856 MSYMBOL_TARGET_FLAG_2 (msymbol
) = 0;
857 MSYMBOL_SIZE (msymbol
) = 0;
859 /* The hash pointers must be cleared! If they're not,
860 add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
861 msymbol
->hash_next
= NULL
;
862 msymbol
->demangled_hash_next
= NULL
;
866 OBJSTAT (objfile
, n_minsyms
++);
870 /* Record a minimal symbol in the msym bunches. Returns the symbol
873 struct minimal_symbol
*
874 prim_record_minimal_symbol_and_info (const char *name
, CORE_ADDR address
,
875 enum minimal_symbol_type ms_type
,
877 asection
*bfd_section
,
878 struct objfile
*objfile
)
880 return prim_record_minimal_symbol_full (name
, strlen (name
), 1,
881 address
, ms_type
, section
,
882 bfd_section
, objfile
);
885 /* Compare two minimal symbols by address and return a signed result based
886 on unsigned comparisons, so that we sort into unsigned numeric order.
887 Within groups with the same address, sort by name. */
890 compare_minimal_symbols (const void *fn1p
, const void *fn2p
)
892 const struct minimal_symbol
*fn1
;
893 const struct minimal_symbol
*fn2
;
895 fn1
= (const struct minimal_symbol
*) fn1p
;
896 fn2
= (const struct minimal_symbol
*) fn2p
;
898 if (SYMBOL_VALUE_ADDRESS (fn1
) < SYMBOL_VALUE_ADDRESS (fn2
))
900 return (-1); /* addr 1 is less than addr 2 */
902 else if (SYMBOL_VALUE_ADDRESS (fn1
) > SYMBOL_VALUE_ADDRESS (fn2
))
904 return (1); /* addr 1 is greater than addr 2 */
907 /* addrs are equal: sort by name */
909 char *name1
= SYMBOL_LINKAGE_NAME (fn1
);
910 char *name2
= SYMBOL_LINKAGE_NAME (fn2
);
912 if (name1
&& name2
) /* both have names */
913 return strcmp (name1
, name2
);
915 return 1; /* fn1 has no name, so it is "less" */
916 else if (name1
) /* fn2 has no name, so it is "less" */
919 return (0); /* neither has a name, so they're equal. */
923 /* Discard the currently collected minimal symbols, if any. If we wish
924 to save them for later use, we must have already copied them somewhere
925 else before calling this function.
927 FIXME: We could allocate the minimal symbol bunches on their own
928 obstack and then simply blow the obstack away when we are done with
929 it. Is it worth the extra trouble though? */
932 do_discard_minimal_symbols_cleanup (void *arg
)
934 struct msym_bunch
*next
;
936 while (msym_bunch
!= NULL
)
938 next
= msym_bunch
->next
;
945 make_cleanup_discard_minimal_symbols (void)
947 return make_cleanup (do_discard_minimal_symbols_cleanup
, 0);
952 /* Compact duplicate entries out of a minimal symbol table by walking
953 through the table and compacting out entries with duplicate addresses
954 and matching names. Return the number of entries remaining.
956 On entry, the table resides between msymbol[0] and msymbol[mcount].
957 On exit, it resides between msymbol[0] and msymbol[result_count].
959 When files contain multiple sources of symbol information, it is
960 possible for the minimal symbol table to contain many duplicate entries.
961 As an example, SVR4 systems use ELF formatted object files, which
962 usually contain at least two different types of symbol tables (a
963 standard ELF one and a smaller dynamic linking table), as well as
964 DWARF debugging information for files compiled with -g.
966 Without compacting, the minimal symbol table for gdb itself contains
967 over a 1000 duplicates, about a third of the total table size. Aside
968 from the potential trap of not noticing that two successive entries
969 identify the same location, this duplication impacts the time required
970 to linearly scan the table, which is done in a number of places. So we
971 just do one linear scan here and toss out the duplicates.
973 Note that we are not concerned here about recovering the space that
974 is potentially freed up, because the strings themselves are allocated
975 on the objfile_obstack, and will get automatically freed when the symbol
976 table is freed. The caller can free up the unused minimal symbols at
977 the end of the compacted region if their allocation strategy allows it.
979 Also note we only go up to the next to last entry within the loop
980 and then copy the last entry explicitly after the loop terminates.
982 Since the different sources of information for each symbol may
983 have different levels of "completeness", we may have duplicates
984 that have one entry with type "mst_unknown" and the other with a
985 known type. So if the one we are leaving alone has type mst_unknown,
986 overwrite its type with the type from the one we are compacting out. */
989 compact_minimal_symbols (struct minimal_symbol
*msymbol
, int mcount
,
990 struct objfile
*objfile
)
992 struct minimal_symbol
*copyfrom
;
993 struct minimal_symbol
*copyto
;
997 copyfrom
= copyto
= msymbol
;
998 while (copyfrom
< msymbol
+ mcount
- 1)
1000 if (SYMBOL_VALUE_ADDRESS (copyfrom
)
1001 == SYMBOL_VALUE_ADDRESS ((copyfrom
+ 1))
1002 && strcmp (SYMBOL_LINKAGE_NAME (copyfrom
),
1003 SYMBOL_LINKAGE_NAME ((copyfrom
+ 1))) == 0)
1005 if (MSYMBOL_TYPE ((copyfrom
+ 1)) == mst_unknown
)
1007 MSYMBOL_TYPE ((copyfrom
+ 1)) = MSYMBOL_TYPE (copyfrom
);
1012 *copyto
++ = *copyfrom
++;
1014 *copyto
++ = *copyfrom
++;
1015 mcount
= copyto
- msymbol
;
1020 /* Build (or rebuild) the minimal symbol hash tables. This is necessary
1021 after compacting or sorting the table since the entries move around
1022 thus causing the internal minimal_symbol pointers to become jumbled. */
1025 build_minimal_symbol_hash_tables (struct objfile
*objfile
)
1028 struct minimal_symbol
*msym
;
1030 /* Clear the hash tables. */
1031 for (i
= 0; i
< MINIMAL_SYMBOL_HASH_SIZE
; i
++)
1033 objfile
->msymbol_hash
[i
] = 0;
1034 objfile
->msymbol_demangled_hash
[i
] = 0;
1037 /* Now, (re)insert the actual entries. */
1038 for (i
= objfile
->minimal_symbol_count
, msym
= objfile
->msymbols
;
1042 msym
->hash_next
= 0;
1043 add_minsym_to_hash_table (msym
, objfile
->msymbol_hash
);
1045 msym
->demangled_hash_next
= 0;
1046 if (SYMBOL_SEARCH_NAME (msym
) != SYMBOL_LINKAGE_NAME (msym
))
1047 add_minsym_to_demangled_hash_table (msym
,
1048 objfile
->msymbol_demangled_hash
);
1052 /* Add the minimal symbols in the existing bunches to the objfile's official
1053 minimal symbol table. In most cases there is no minimal symbol table yet
1054 for this objfile, and the existing bunches are used to create one. Once
1055 in a while (for shared libraries for example), we add symbols (e.g. common
1056 symbols) to an existing objfile.
1058 Because of the way minimal symbols are collected, we generally have no way
1059 of knowing what source language applies to any particular minimal symbol.
1060 Specifically, we have no way of knowing if the minimal symbol comes from a
1061 C++ compilation unit or not. So for the sake of supporting cached
1062 demangled C++ names, we have no choice but to try and demangle each new one
1063 that comes in. If the demangling succeeds, then we assume it is a C++
1064 symbol and set the symbol's language and demangled name fields
1065 appropriately. Note that in order to avoid unnecessary demanglings, and
1066 allocating obstack space that subsequently can't be freed for the demangled
1067 names, we mark all newly added symbols with language_auto. After
1068 compaction of the minimal symbols, we go back and scan the entire minimal
1069 symbol table looking for these new symbols. For each new symbol we attempt
1070 to demangle it, and if successful, record it as a language_cplus symbol
1071 and cache the demangled form on the symbol obstack. Symbols which don't
1072 demangle are marked as language_unknown symbols, which inhibits future
1073 attempts to demangle them if we later add more minimal symbols. */
1076 install_minimal_symbols (struct objfile
*objfile
)
1080 struct msym_bunch
*bunch
;
1081 struct minimal_symbol
*msymbols
;
1086 /* Allocate enough space in the obstack, into which we will gather the
1087 bunches of new and existing minimal symbols, sort them, and then
1088 compact out the duplicate entries. Once we have a final table,
1089 we will give back the excess space. */
1091 alloc_count
= msym_count
+ objfile
->minimal_symbol_count
+ 1;
1092 obstack_blank (&objfile
->objfile_obstack
,
1093 alloc_count
* sizeof (struct minimal_symbol
));
1094 msymbols
= (struct minimal_symbol
*)
1095 obstack_base (&objfile
->objfile_obstack
);
1097 /* Copy in the existing minimal symbols, if there are any. */
1099 if (objfile
->minimal_symbol_count
)
1100 memcpy ((char *) msymbols
, (char *) objfile
->msymbols
,
1101 objfile
->minimal_symbol_count
* sizeof (struct minimal_symbol
));
1103 /* Walk through the list of minimal symbol bunches, adding each symbol
1104 to the new contiguous array of symbols. Note that we start with the
1105 current, possibly partially filled bunch (thus we use the current
1106 msym_bunch_index for the first bunch we copy over), and thereafter
1107 each bunch is full. */
1109 mcount
= objfile
->minimal_symbol_count
;
1111 for (bunch
= msym_bunch
; bunch
!= NULL
; bunch
= bunch
->next
)
1113 for (bindex
= 0; bindex
< msym_bunch_index
; bindex
++, mcount
++)
1114 msymbols
[mcount
] = bunch
->contents
[bindex
];
1115 msym_bunch_index
= BUNCH_SIZE
;
1118 /* Sort the minimal symbols by address. */
1120 qsort (msymbols
, mcount
, sizeof (struct minimal_symbol
),
1121 compare_minimal_symbols
);
1123 /* Compact out any duplicates, and free up whatever space we are
1126 mcount
= compact_minimal_symbols (msymbols
, mcount
, objfile
);
1128 obstack_blank (&objfile
->objfile_obstack
,
1129 (mcount
+ 1 - alloc_count
) * sizeof (struct minimal_symbol
));
1130 msymbols
= (struct minimal_symbol
*)
1131 obstack_finish (&objfile
->objfile_obstack
);
1133 /* We also terminate the minimal symbol table with a "null symbol",
1134 which is *not* included in the size of the table. This makes it
1135 easier to find the end of the table when we are handed a pointer
1136 to some symbol in the middle of it. Zero out the fields in the
1137 "null symbol" allocated at the end of the array. Note that the
1138 symbol count does *not* include this null symbol, which is why it
1139 is indexed by mcount and not mcount-1. */
1141 SYMBOL_LINKAGE_NAME (&msymbols
[mcount
]) = NULL
;
1142 SYMBOL_VALUE_ADDRESS (&msymbols
[mcount
]) = 0;
1143 MSYMBOL_TARGET_FLAG_1 (&msymbols
[mcount
]) = 0;
1144 MSYMBOL_TARGET_FLAG_2 (&msymbols
[mcount
]) = 0;
1145 MSYMBOL_SIZE (&msymbols
[mcount
]) = 0;
1146 MSYMBOL_TYPE (&msymbols
[mcount
]) = mst_unknown
;
1147 SYMBOL_SET_LANGUAGE (&msymbols
[mcount
], language_unknown
);
1149 /* Attach the minimal symbol table to the specified objfile.
1150 The strings themselves are also located in the objfile_obstack
1153 objfile
->minimal_symbol_count
= mcount
;
1154 objfile
->msymbols
= msymbols
;
1156 /* Try to guess the appropriate C++ ABI by looking at the names
1157 of the minimal symbols in the table. */
1161 for (i
= 0; i
< mcount
; i
++)
1163 /* If a symbol's name starts with _Z and was successfully
1164 demangled, then we can assume we've found a GNU v3 symbol.
1165 For now we set the C++ ABI globally; if the user is
1166 mixing ABIs then the user will need to "set cp-abi"
1168 const char *name
= SYMBOL_LINKAGE_NAME (&objfile
->msymbols
[i
]);
1170 if (name
[0] == '_' && name
[1] == 'Z'
1171 && SYMBOL_DEMANGLED_NAME (&objfile
->msymbols
[i
]) != NULL
)
1173 set_cp_abi_as_auto_default ("gnu-v3");
1179 /* Now build the hash tables; we can't do this incrementally
1180 at an earlier point since we weren't finished with the obstack
1181 yet. (And if the msymbol obstack gets moved, all the internal
1182 pointers to other msymbols need to be adjusted.) */
1183 build_minimal_symbol_hash_tables (objfile
);
1187 /* Sort all the minimal symbols in OBJFILE. */
1190 msymbols_sort (struct objfile
*objfile
)
1192 qsort (objfile
->msymbols
, objfile
->minimal_symbol_count
,
1193 sizeof (struct minimal_symbol
), compare_minimal_symbols
);
1194 build_minimal_symbol_hash_tables (objfile
);
1197 /* Check if PC is in a shared library trampoline code stub.
1198 Return minimal symbol for the trampoline entry or NULL if PC is not
1199 in a trampoline code stub. */
1201 struct minimal_symbol
*
1202 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc
)
1204 struct obj_section
*section
= find_pc_section (pc
);
1205 struct minimal_symbol
*msymbol
;
1207 if (section
== NULL
)
1209 msymbol
= lookup_minimal_symbol_by_pc_section_1 (pc
, section
, 1);
1211 if (msymbol
!= NULL
&& MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
1216 /* If PC is in a shared library trampoline code stub, return the
1217 address of the `real' function belonging to the stub.
1218 Return 0 if PC is not in a trampoline code stub or if the real
1219 function is not found in the minimal symbol table.
1221 We may fail to find the right function if a function with the
1222 same name is defined in more than one shared library, but this
1223 is considered bad programming style. We could return 0 if we find
1224 a duplicate function in case this matters someday. */
1227 find_solib_trampoline_target (struct frame_info
*frame
, CORE_ADDR pc
)
1229 struct objfile
*objfile
;
1230 struct minimal_symbol
*msymbol
;
1231 struct minimal_symbol
*tsymbol
= lookup_solib_trampoline_symbol_by_pc (pc
);
1233 if (tsymbol
!= NULL
)
1235 ALL_MSYMBOLS (objfile
, msymbol
)
1237 if (MSYMBOL_TYPE (msymbol
) == mst_text
1238 && strcmp (SYMBOL_LINKAGE_NAME (msymbol
),
1239 SYMBOL_LINKAGE_NAME (tsymbol
)) == 0)
1240 return SYMBOL_VALUE_ADDRESS (msymbol
);
1242 /* Also handle minimal symbols pointing to function descriptors. */
1243 if (MSYMBOL_TYPE (msymbol
) == mst_data
1244 && strcmp (SYMBOL_LINKAGE_NAME (msymbol
),
1245 SYMBOL_LINKAGE_NAME (tsymbol
)) == 0)
1249 func
= gdbarch_convert_from_func_ptr_addr
1250 (get_objfile_arch (objfile
),
1251 SYMBOL_VALUE_ADDRESS (msymbol
),
1254 /* Ignore data symbols that are not function descriptors. */
1255 if (func
!= SYMBOL_VALUE_ADDRESS (msymbol
))