Commit | Line | Data |
---|---|---|
1ab3bf1b JG |
1 | /* GDB routines for manipulating the minimal symbol tables. |
2 | Copyright 1992 Free Software Foundation, Inc. | |
3 | Contributed by Cygnus Support, using pieces from other GDB modules. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
21 | ||
22 | /* This file contains support routines for creating, manipulating, and | |
23 | destroying minimal symbol tables. | |
24 | ||
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. | |
29 | ||
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. | |
33 | ||
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. */ | |
38 | ||
39 | ||
1ab3bf1b JG |
40 | #include "defs.h" |
41 | #include "symtab.h" | |
42 | #include "bfd.h" | |
43 | #include "symfile.h" | |
5e2e79f8 | 44 | #include "objfiles.h" |
2e4964ad | 45 | #include "demangle.h" |
1ab3bf1b JG |
46 | |
47 | /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE. | |
48 | At the end, copy them all into one newly allocated location on an objfile's | |
49 | symbol obstack. */ | |
50 | ||
51 | #define BUNCH_SIZE 127 | |
52 | ||
53 | struct msym_bunch | |
54 | { | |
55 | struct msym_bunch *next; | |
56 | struct minimal_symbol contents[BUNCH_SIZE]; | |
57 | }; | |
58 | ||
59 | /* Bunch currently being filled up. | |
60 | The next field points to chain of filled bunches. */ | |
61 | ||
62 | static struct msym_bunch *msym_bunch; | |
63 | ||
64 | /* Number of slots filled in current bunch. */ | |
65 | ||
66 | static int msym_bunch_index; | |
67 | ||
68 | /* Total number of minimal symbols recorded so far for the objfile. */ | |
69 | ||
70 | static int msym_count; | |
71 | ||
72 | /* Prototypes for local functions. */ | |
73 | ||
74 | static int | |
75 | compare_minimal_symbols PARAMS ((const void *, const void *)); | |
76 | ||
77 | static int | |
78 | compact_minimal_symbols PARAMS ((struct minimal_symbol *, int)); | |
79 | ||
1ab3bf1b JG |
80 | /* Look through all the current minimal symbol tables and find the first |
81 | minimal symbol that matches NAME. If OBJF is non-NULL, it specifies a | |
82 | particular objfile and the search is limited to that objfile. Returns | |
83 | a pointer to the minimal symbol that matches, or NULL if no match is found. | |
84 | ||
507e4004 | 85 | Note: One instance where there may be duplicate minimal symbols with |
1ab3bf1b JG |
86 | the same name is when the symbol tables for a shared library and the |
87 | symbol tables for an executable contain global symbols with the same | |
88 | names (the dynamic linker deals with the duplication). */ | |
89 | ||
90 | struct minimal_symbol * | |
91 | lookup_minimal_symbol (name, objf) | |
92 | register const char *name; | |
93 | struct objfile *objf; | |
94 | { | |
95 | struct objfile *objfile; | |
96 | struct minimal_symbol *msymbol; | |
97 | struct minimal_symbol *found_symbol = NULL; | |
164207ca | 98 | struct minimal_symbol *found_file_symbol = NULL; |
1eeba686 | 99 | #ifdef IBM6000_TARGET |
507e4004 PB |
100 | struct minimal_symbol *trampoline_symbol = NULL; |
101 | #endif | |
1ab3bf1b JG |
102 | |
103 | for (objfile = object_files; | |
104 | objfile != NULL && found_symbol == NULL; | |
105 | objfile = objfile -> next) | |
106 | { | |
107 | if (objf == NULL || objf == objfile) | |
108 | { | |
109 | for (msymbol = objfile -> msymbols; | |
2e4964ad | 110 | msymbol != NULL && SYMBOL_NAME (msymbol) != NULL && |
1ab3bf1b JG |
111 | found_symbol == NULL; |
112 | msymbol++) | |
113 | { | |
2e4964ad | 114 | if (SYMBOL_MATCHES_NAME (msymbol, name)) |
1ab3bf1b | 115 | { |
164207ca JK |
116 | switch (MSYMBOL_TYPE (msymbol)) |
117 | { | |
118 | case mst_file_text: | |
119 | case mst_file_data: | |
120 | case mst_file_bss: | |
121 | /* It is file-local. If we find more than one, just | |
122 | return the latest one (the user can't expect | |
123 | useful behavior in that case). */ | |
124 | found_file_symbol = msymbol; | |
125 | break; | |
126 | ||
127 | case mst_unknown: | |
1eeba686 | 128 | #ifdef IBM6000_TARGET |
164207ca JK |
129 | /* I *think* all platforms using shared |
130 | libraries (and trampoline code) will suffer | |
131 | this problem. Consider a case where there are | |
132 | 5 shared libraries, each referencing `foo' | |
133 | with a trampoline entry. When someone wants | |
134 | to put a breakpoint on `foo' and the only | |
135 | info we have is minimal symbol vector, we | |
136 | want to use the real `foo', rather than one | |
137 | of those trampoline entries. MGO */ | |
138 | ||
139 | /* If a trampoline symbol is found, we prefer to | |
140 | keep looking for the *real* symbol. If the | |
141 | actual symbol not found, then we'll use the | |
142 | trampoline entry. Sorry for the machine | |
143 | dependent code here, but I hope this will | |
144 | benefit other platforms as well. For | |
145 | trampoline entries, we used mst_unknown | |
146 | earlier. Perhaps we should define a | |
147 | `mst_trampoline' type?? */ | |
148 | ||
149 | if (trampoline_symbol == NULL) | |
150 | trampoline_symbol = msymbol; | |
151 | break; | |
507e4004 | 152 | #else |
164207ca | 153 | /* FALLTHROUGH */ |
507e4004 | 154 | #endif |
164207ca JK |
155 | default: |
156 | found_symbol = msymbol; | |
157 | break; | |
158 | } | |
1ab3bf1b JG |
159 | } |
160 | } | |
161 | } | |
162 | } | |
164207ca JK |
163 | /* External symbols are best. */ |
164 | if (found_symbol) | |
165 | return found_symbol; | |
166 | ||
167 | /* File-local symbols are next best. */ | |
168 | if (found_file_symbol) | |
169 | return found_file_symbol; | |
170 | ||
171 | /* Symbols for IBM shared library trampolines are next best. */ | |
1eeba686 | 172 | #ifdef IBM6000_TARGET |
164207ca JK |
173 | if (trampoline_symbol) |
174 | return trampoline_symbol; | |
507e4004 PB |
175 | #endif |
176 | ||
164207ca | 177 | return NULL; |
1ab3bf1b JG |
178 | } |
179 | ||
180 | ||
181 | /* Search through the minimal symbol table for each objfile and find the | |
182 | symbol whose address is the largest address that is still less than or | |
183 | equal to PC. Returns a pointer to the minimal symbol if such a symbol | |
184 | is found, or NULL if PC is not in a suitable range. Note that we need | |
185 | to look through ALL the minimal symbol tables before deciding on the | |
186 | symbol that comes closest to the specified PC. */ | |
187 | ||
188 | struct minimal_symbol * | |
189 | lookup_minimal_symbol_by_pc (pc) | |
190 | register CORE_ADDR pc; | |
191 | { | |
192 | register int lo; | |
193 | register int hi; | |
194 | register int new; | |
195 | register struct objfile *objfile; | |
196 | register struct minimal_symbol *msymbol; | |
197 | register struct minimal_symbol *best_symbol = NULL; | |
198 | ||
199 | for (objfile = object_files; | |
200 | objfile != NULL; | |
201 | objfile = objfile -> next) | |
202 | { | |
203 | /* If this objfile has a minimal symbol table, go search it using | |
204 | a binary search. Note that a minimal symbol table always consists | |
205 | of at least two symbols, a "real" symbol and the terminating | |
206 | "null symbol". If there are no real symbols, then there is no | |
207 | minimal symbol table at all. */ | |
208 | ||
209 | if ((msymbol = objfile -> msymbols) != NULL) | |
210 | { | |
211 | lo = 0; | |
a521e93a | 212 | hi = objfile -> minimal_symbol_count - 1; |
1ab3bf1b JG |
213 | |
214 | /* This code assumes that the minimal symbols are sorted by | |
215 | ascending address values. If the pc value is greater than or | |
216 | equal to the first symbol's address, then some symbol in this | |
217 | minimal symbol table is a suitable candidate for being the | |
218 | "best" symbol. This includes the last real symbol, for cases | |
219 | where the pc value is larger than any address in this vector. | |
220 | ||
221 | By iterating until the address associated with the current | |
222 | hi index (the endpoint of the test interval) is less than | |
223 | or equal to the desired pc value, we accomplish two things: | |
224 | (1) the case where the pc value is larger than any minimal | |
225 | symbol address is trivially solved, (2) the address associated | |
226 | with the hi index is always the one we want when the interation | |
227 | terminates. In essence, we are iterating the test interval | |
228 | down until the pc value is pushed out of it from the high end. | |
229 | ||
230 | Warning: this code is trickier than it would appear at first. */ | |
231 | ||
1eeba686 | 232 | /* Should also requires that pc is <= end of objfile. FIXME! */ |
2e4964ad | 233 | if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo])) |
1ab3bf1b | 234 | { |
2e4964ad | 235 | while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc) |
1ab3bf1b JG |
236 | { |
237 | /* pc is still strictly less than highest address */ | |
238 | /* Note "new" will always be >= lo */ | |
239 | new = (lo + hi) / 2; | |
2e4964ad FF |
240 | if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) || |
241 | (lo == new)) | |
1ab3bf1b JG |
242 | { |
243 | hi = new; | |
244 | } | |
245 | else | |
246 | { | |
247 | lo = new; | |
248 | } | |
249 | } | |
250 | /* The minimal symbol indexed by hi now is the best one in this | |
251 | objfile's minimal symbol table. See if it is the best one | |
252 | overall. */ | |
253 | ||
254 | if ((best_symbol == NULL) || | |
2e4964ad FF |
255 | (SYMBOL_VALUE_ADDRESS (best_symbol) < |
256 | SYMBOL_VALUE_ADDRESS (&msymbol[hi]))) | |
1ab3bf1b JG |
257 | { |
258 | best_symbol = &msymbol[hi]; | |
259 | } | |
260 | } | |
261 | } | |
262 | } | |
263 | return (best_symbol); | |
264 | } | |
265 | ||
266 | /* Prepare to start collecting minimal symbols. Note that presetting | |
267 | msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal | |
268 | symbol to allocate the memory for the first bunch. */ | |
269 | ||
270 | void | |
271 | init_minimal_symbol_collection () | |
272 | { | |
273 | msym_count = 0; | |
274 | msym_bunch = NULL; | |
275 | msym_bunch_index = BUNCH_SIZE; | |
276 | } | |
277 | ||
278 | void | |
279 | prim_record_minimal_symbol (name, address, ms_type) | |
280 | const char *name; | |
281 | CORE_ADDR address; | |
282 | enum minimal_symbol_type ms_type; | |
283 | { | |
284 | register struct msym_bunch *new; | |
2e4964ad | 285 | register struct minimal_symbol *msymbol; |
1ab3bf1b JG |
286 | |
287 | if (msym_bunch_index == BUNCH_SIZE) | |
288 | { | |
289 | new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch)); | |
290 | msym_bunch_index = 0; | |
291 | new -> next = msym_bunch; | |
292 | msym_bunch = new; | |
293 | } | |
2e4964ad FF |
294 | msymbol = &msym_bunch -> contents[msym_bunch_index]; |
295 | SYMBOL_NAME (msymbol) = (char *) name; | |
7532cf10 | 296 | SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown); |
2e4964ad | 297 | SYMBOL_VALUE_ADDRESS (msymbol) = address; |
3c02636b | 298 | SYMBOL_SECTION (msymbol) = -1; |
2e4964ad FF |
299 | MSYMBOL_TYPE (msymbol) = ms_type; |
300 | /* FIXME: This info, if it remains, needs its own field. */ | |
301 | MSYMBOL_INFO (msymbol) = NULL; /* FIXME! */ | |
1ab3bf1b JG |
302 | msym_bunch_index++; |
303 | msym_count++; | |
304 | } | |
305 | ||
2e4964ad FF |
306 | /* FIXME: Why don't we just combine this function with the one above |
307 | and pass it a NULL info pointer value if info is not needed? */ | |
308 | ||
93297ea0 | 309 | void |
3c02636b | 310 | prim_record_minimal_symbol_and_info (name, address, ms_type, info, section) |
93297ea0 JG |
311 | const char *name; |
312 | CORE_ADDR address; | |
313 | enum minimal_symbol_type ms_type; | |
314 | char *info; | |
3c02636b | 315 | int section; |
93297ea0 JG |
316 | { |
317 | register struct msym_bunch *new; | |
2e4964ad | 318 | register struct minimal_symbol *msymbol; |
93297ea0 JG |
319 | |
320 | if (msym_bunch_index == BUNCH_SIZE) | |
321 | { | |
322 | new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch)); | |
323 | msym_bunch_index = 0; | |
324 | new -> next = msym_bunch; | |
325 | msym_bunch = new; | |
326 | } | |
2e4964ad FF |
327 | msymbol = &msym_bunch -> contents[msym_bunch_index]; |
328 | SYMBOL_NAME (msymbol) = (char *) name; | |
7532cf10 | 329 | SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown); |
2e4964ad | 330 | SYMBOL_VALUE_ADDRESS (msymbol) = address; |
3c02636b | 331 | SYMBOL_SECTION (msymbol) = section; |
2e4964ad FF |
332 | MSYMBOL_TYPE (msymbol) = ms_type; |
333 | /* FIXME: This info, if it remains, needs its own field. */ | |
334 | MSYMBOL_INFO (msymbol) = info; /* FIXME! */ | |
93297ea0 JG |
335 | msym_bunch_index++; |
336 | msym_count++; | |
337 | } | |
338 | ||
1ab3bf1b JG |
339 | /* Compare two minimal symbols by address and return a signed result based |
340 | on unsigned comparisons, so that we sort into unsigned numeric order. */ | |
341 | ||
342 | static int | |
343 | compare_minimal_symbols (fn1p, fn2p) | |
344 | const PTR fn1p; | |
345 | const PTR fn2p; | |
346 | { | |
347 | register const struct minimal_symbol *fn1; | |
348 | register const struct minimal_symbol *fn2; | |
349 | ||
350 | fn1 = (const struct minimal_symbol *) fn1p; | |
351 | fn2 = (const struct minimal_symbol *) fn2p; | |
352 | ||
2e4964ad | 353 | if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2)) |
1ab3bf1b JG |
354 | { |
355 | return (-1); | |
356 | } | |
2e4964ad | 357 | else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2)) |
1ab3bf1b JG |
358 | { |
359 | return (1); | |
360 | } | |
361 | else | |
362 | { | |
363 | return (0); | |
364 | } | |
365 | } | |
366 | ||
367 | /* Discard the currently collected minimal symbols, if any. If we wish | |
368 | to save them for later use, we must have already copied them somewhere | |
369 | else before calling this function. | |
370 | ||
371 | FIXME: We could allocate the minimal symbol bunches on their own | |
372 | obstack and then simply blow the obstack away when we are done with | |
373 | it. Is it worth the extra trouble though? */ | |
374 | ||
375 | /* ARGSUSED */ | |
376 | void | |
377 | discard_minimal_symbols (foo) | |
378 | int foo; | |
379 | { | |
380 | register struct msym_bunch *next; | |
381 | ||
382 | while (msym_bunch != NULL) | |
383 | { | |
384 | next = msym_bunch -> next; | |
84ffdec2 | 385 | free ((PTR)msym_bunch); |
1ab3bf1b JG |
386 | msym_bunch = next; |
387 | } | |
388 | } | |
389 | ||
390 | /* Compact duplicate entries out of a minimal symbol table by walking | |
391 | through the table and compacting out entries with duplicate addresses | |
021959e2 JG |
392 | and matching names. Return the number of entries remaining. |
393 | ||
394 | On entry, the table resides between msymbol[0] and msymbol[mcount]. | |
395 | On exit, it resides between msymbol[0] and msymbol[result_count]. | |
1ab3bf1b JG |
396 | |
397 | When files contain multiple sources of symbol information, it is | |
398 | possible for the minimal symbol table to contain many duplicate entries. | |
399 | As an example, SVR4 systems use ELF formatted object files, which | |
400 | usually contain at least two different types of symbol tables (a | |
401 | standard ELF one and a smaller dynamic linking table), as well as | |
402 | DWARF debugging information for files compiled with -g. | |
403 | ||
404 | Without compacting, the minimal symbol table for gdb itself contains | |
405 | over a 1000 duplicates, about a third of the total table size. Aside | |
406 | from the potential trap of not noticing that two successive entries | |
407 | identify the same location, this duplication impacts the time required | |
021959e2 | 408 | to linearly scan the table, which is done in a number of places. So we |
1ab3bf1b JG |
409 | just do one linear scan here and toss out the duplicates. |
410 | ||
411 | Note that we are not concerned here about recovering the space that | |
412 | is potentially freed up, because the strings themselves are allocated | |
413 | on the symbol_obstack, and will get automatically freed when the symbol | |
021959e2 JG |
414 | table is freed. The caller can free up the unused minimal symbols at |
415 | the end of the compacted region if their allocation strategy allows it. | |
1ab3bf1b JG |
416 | |
417 | Also note we only go up to the next to last entry within the loop | |
418 | and then copy the last entry explicitly after the loop terminates. | |
419 | ||
420 | Since the different sources of information for each symbol may | |
421 | have different levels of "completeness", we may have duplicates | |
422 | that have one entry with type "mst_unknown" and the other with a | |
423 | known type. So if the one we are leaving alone has type mst_unknown, | |
424 | overwrite its type with the type from the one we are compacting out. */ | |
425 | ||
426 | static int | |
427 | compact_minimal_symbols (msymbol, mcount) | |
428 | struct minimal_symbol *msymbol; | |
429 | int mcount; | |
430 | { | |
431 | struct minimal_symbol *copyfrom; | |
432 | struct minimal_symbol *copyto; | |
433 | ||
434 | if (mcount > 0) | |
435 | { | |
436 | copyfrom = copyto = msymbol; | |
437 | while (copyfrom < msymbol + mcount - 1) | |
438 | { | |
2e4964ad FF |
439 | if (SYMBOL_VALUE_ADDRESS (copyfrom) == |
440 | SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) && | |
441 | (STREQ (SYMBOL_NAME (copyfrom), SYMBOL_NAME ((copyfrom + 1))))) | |
1ab3bf1b | 442 | { |
2e4964ad | 443 | if (MSYMBOL_TYPE((copyfrom + 1)) == mst_unknown) |
1ab3bf1b | 444 | { |
2e4964ad | 445 | MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom); |
1ab3bf1b JG |
446 | } |
447 | copyfrom++; | |
448 | } | |
449 | else | |
450 | { | |
451 | *copyto++ = *copyfrom++; | |
452 | } | |
453 | } | |
454 | *copyto++ = *copyfrom++; | |
455 | mcount = copyto - msymbol; | |
456 | } | |
457 | return (mcount); | |
458 | } | |
459 | ||
2e4964ad FF |
460 | /* Add the minimal symbols in the existing bunches to the objfile's official |
461 | minimal symbol table. In most cases there is no minimal symbol table yet | |
462 | for this objfile, and the existing bunches are used to create one. Once | |
463 | in a while (for shared libraries for example), we add symbols (e.g. common | |
464 | symbols) to an existing objfile. | |
465 | ||
466 | Because of the way minimal symbols are collected, we generally have no way | |
467 | of knowing what source language applies to any particular minimal symbol. | |
468 | Specifically, we have no way of knowing if the minimal symbol comes from a | |
469 | C++ compilation unit or not. So for the sake of supporting cached | |
470 | demangled C++ names, we have no choice but to try and demangle each new one | |
471 | that comes in. If the demangling succeeds, then we assume it is a C++ | |
472 | symbol and set the symbol's language and demangled name fields | |
473 | appropriately. Note that in order to avoid unnecessary demanglings, and | |
474 | allocating obstack space that subsequently can't be freed for the demangled | |
475 | names, we mark all newly added symbols with language_auto. After | |
476 | compaction of the minimal symbols, we go back and scan the entire minimal | |
477 | symbol table looking for these new symbols. For each new symbol we attempt | |
478 | to demangle it, and if successful, record it as a language_cplus symbol | |
479 | and cache the demangled form on the symbol obstack. Symbols which don't | |
480 | demangle are marked as language_unknown symbols, which inhibits future | |
481 | attempts to demangle them if we later add more minimal symbols. */ | |
1ab3bf1b JG |
482 | |
483 | void | |
021959e2 | 484 | install_minimal_symbols (objfile) |
1ab3bf1b JG |
485 | struct objfile *objfile; |
486 | { | |
487 | register int bindex; | |
488 | register int mcount; | |
489 | register struct msym_bunch *bunch; | |
490 | register struct minimal_symbol *msymbols; | |
021959e2 | 491 | int alloc_count; |
de9bef49 | 492 | register char leading_char; |
1ab3bf1b JG |
493 | |
494 | if (msym_count > 0) | |
495 | { | |
021959e2 JG |
496 | /* Allocate enough space in the obstack, into which we will gather the |
497 | bunches of new and existing minimal symbols, sort them, and then | |
498 | compact out the duplicate entries. Once we have a final table, | |
499 | we will give back the excess space. */ | |
500 | ||
501 | alloc_count = msym_count + objfile->minimal_symbol_count + 1; | |
502 | obstack_blank (&objfile->symbol_obstack, | |
503 | alloc_count * sizeof (struct minimal_symbol)); | |
1ab3bf1b | 504 | msymbols = (struct minimal_symbol *) |
021959e2 JG |
505 | obstack_base (&objfile->symbol_obstack); |
506 | ||
507 | /* Copy in the existing minimal symbols, if there are any. */ | |
508 | ||
509 | if (objfile->minimal_symbol_count) | |
510 | memcpy ((char *)msymbols, (char *)objfile->msymbols, | |
511 | objfile->minimal_symbol_count * sizeof (struct minimal_symbol)); | |
512 | ||
1ab3bf1b JG |
513 | /* Walk through the list of minimal symbol bunches, adding each symbol |
514 | to the new contiguous array of symbols. Note that we start with the | |
515 | current, possibly partially filled bunch (thus we use the current | |
516 | msym_bunch_index for the first bunch we copy over), and thereafter | |
517 | each bunch is full. */ | |
518 | ||
021959e2 | 519 | mcount = objfile->minimal_symbol_count; |
de9bef49 | 520 | leading_char = bfd_get_symbol_leading_char (objfile->obfd); |
021959e2 | 521 | |
1ab3bf1b JG |
522 | for (bunch = msym_bunch; bunch != NULL; bunch = bunch -> next) |
523 | { | |
524 | for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++) | |
525 | { | |
526 | msymbols[mcount] = bunch -> contents[bindex]; | |
2e4964ad FF |
527 | SYMBOL_LANGUAGE (&msymbols[mcount]) = language_auto; |
528 | if (SYMBOL_NAME (&msymbols[mcount])[0] == leading_char) | |
1ab3bf1b | 529 | { |
2e4964ad | 530 | SYMBOL_NAME(&msymbols[mcount])++; |
1ab3bf1b | 531 | } |
1ab3bf1b JG |
532 | } |
533 | msym_bunch_index = BUNCH_SIZE; | |
534 | } | |
021959e2 | 535 | |
1ab3bf1b JG |
536 | /* Sort the minimal symbols by address. */ |
537 | ||
538 | qsort (msymbols, mcount, sizeof (struct minimal_symbol), | |
539 | compare_minimal_symbols); | |
540 | ||
021959e2 JG |
541 | /* Compact out any duplicates, and free up whatever space we are |
542 | no longer using. */ | |
1ab3bf1b JG |
543 | |
544 | mcount = compact_minimal_symbols (msymbols, mcount); | |
1ab3bf1b | 545 | |
021959e2 JG |
546 | obstack_blank (&objfile->symbol_obstack, |
547 | (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol)); | |
548 | msymbols = (struct minimal_symbol *) | |
549 | obstack_finish (&objfile->symbol_obstack); | |
550 | ||
2e4964ad FF |
551 | /* We also terminate the minimal symbol table with a "null symbol", |
552 | which is *not* included in the size of the table. This makes it | |
553 | easier to find the end of the table when we are handed a pointer | |
554 | to some symbol in the middle of it. Zero out the fields in the | |
555 | "null symbol" allocated at the end of the array. Note that the | |
556 | symbol count does *not* include this null symbol, which is why it | |
557 | is indexed by mcount and not mcount-1. */ | |
558 | ||
559 | SYMBOL_NAME (&msymbols[mcount]) = NULL; | |
560 | SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0; | |
561 | MSYMBOL_INFO (&msymbols[mcount]) = NULL; | |
562 | MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown; | |
7532cf10 | 563 | SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols[mcount], language_unknown); |
021959e2 JG |
564 | |
565 | /* Attach the minimal symbol table to the specified objfile. | |
566 | The strings themselves are also located in the symbol_obstack | |
567 | of this objfile. */ | |
568 | ||
569 | objfile -> minimal_symbol_count = mcount; | |
570 | objfile -> msymbols = msymbols; | |
2e4964ad FF |
571 | |
572 | /* Now walk through all the minimal symbols, selecting the newly added | |
573 | ones and attempting to cache their C++ demangled names. */ | |
574 | ||
575 | for ( ; mcount-- > 0 ; msymbols++) | |
576 | { | |
7532cf10 | 577 | SYMBOL_INIT_DEMANGLED_NAME (msymbols, &objfile->symbol_obstack); |
2e4964ad | 578 | } |
1ab3bf1b JG |
579 | } |
580 | } | |
581 |