Rev 5197 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5197 | serge | 1 | /* Generic symbol-table support for the BFD library. |
6324 | serge | 2 | Copyright (C) 1990-2015 Free Software Foundation, Inc. |
5197 | serge | 3 | Written by Cygnus Support. |
4 | |||
5 | This file is part of BFD, the Binary File Descriptor library. |
||
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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
||
20 | MA 02110-1301, USA. */ |
||
21 | |||
22 | /* |
||
23 | SECTION |
||
24 | Symbols |
||
25 | |||
26 | BFD tries to maintain as much symbol information as it can when |
||
27 | it moves information from file to file. BFD passes information |
||
28 | to applications though the < |
||
29 | application requests the symbol table, BFD reads the table in |
||
30 | the native form and translates parts of it into the internal |
||
31 | format. To maintain more than the information passed to |
||
32 | applications, some targets keep some information ``behind the |
||
33 | scenes'' in a structure only the particular back end knows |
||
34 | about. For example, the coff back end keeps the original |
||
35 | symbol table structure as well as the canonical structure when |
||
36 | a BFD is read in. On output, the coff back end can reconstruct |
||
37 | the output symbol table so that no information is lost, even |
||
38 | information unique to coff which BFD doesn't know or |
||
39 | understand. If a coff symbol table were read, but were written |
||
40 | through an a.out back end, all the coff specific information |
||
41 | would be lost. The symbol table of a BFD |
||
42 | is not necessarily read in until a canonicalize request is |
||
43 | made. Then the BFD back end fills in a table provided by the |
||
44 | application with pointers to the canonical information. To |
||
45 | output symbols, the application provides BFD with a table of |
||
46 | pointers to pointers to < |
||
47 | like the linker to output a symbol as it was read, since the ``behind |
||
48 | the scenes'' information will be still available. |
||
49 | @menu |
||
50 | @* Reading Symbols:: |
||
51 | @* Writing Symbols:: |
||
52 | @* Mini Symbols:: |
||
53 | @* typedef asymbol:: |
||
54 | @* symbol handling functions:: |
||
55 | @end menu |
||
56 | |||
57 | INODE |
||
58 | Reading Symbols, Writing Symbols, Symbols, Symbols |
||
59 | SUBSECTION |
||
60 | Reading symbols |
||
61 | |||
62 | There are two stages to reading a symbol table from a BFD: |
||
63 | allocating storage, and the actual reading process. This is an |
||
64 | excerpt from an application which reads the symbol table: |
||
65 | |||
66 | | long storage_needed; |
||
67 | | asymbol **symbol_table; |
||
68 | | long number_of_symbols; |
||
69 | | long i; |
||
70 | | |
||
71 | | storage_needed = bfd_get_symtab_upper_bound (abfd); |
||
72 | | |
||
73 | | if (storage_needed < 0) |
||
74 | | FAIL |
||
75 | | |
||
76 | | if (storage_needed == 0) |
||
77 | | return; |
||
78 | | |
||
79 | | symbol_table = xmalloc (storage_needed); |
||
80 | | ... |
||
81 | | number_of_symbols = |
||
82 | | bfd_canonicalize_symtab (abfd, symbol_table); |
||
83 | | |
||
84 | | if (number_of_symbols < 0) |
||
85 | | FAIL |
||
86 | | |
||
87 | | for (i = 0; i < number_of_symbols; i++) |
||
88 | | process_symbol (symbol_table[i]); |
||
89 | |||
90 | All storage for the symbols themselves is in an objalloc |
||
91 | connected to the BFD; it is freed when the BFD is closed. |
||
92 | |||
93 | INODE |
||
94 | Writing Symbols, Mini Symbols, Reading Symbols, Symbols |
||
95 | SUBSECTION |
||
96 | Writing symbols |
||
97 | |||
98 | Writing of a symbol table is automatic when a BFD open for |
||
99 | writing is closed. The application attaches a vector of |
||
100 | pointers to pointers to symbols to the BFD being written, and |
||
101 | fills in the symbol count. The close and cleanup code reads |
||
102 | through the table provided and performs all the necessary |
||
103 | operations. The BFD output code must always be provided with an |
||
104 | ``owned'' symbol: one which has come from another BFD, or one |
||
105 | which has been created using < |
||
106 | example showing the creation of a symbol table with only one element: |
||
107 | |||
108 | | #include "sysdep.h" |
||
109 | | #include "bfd.h" |
||
110 | | int main (void) |
||
111 | | { |
||
112 | | bfd *abfd; |
||
113 | | asymbol *ptrs[2]; |
||
114 | | asymbol *new; |
||
115 | | |
||
116 | | abfd = bfd_openw ("foo","a.out-sunos-big"); |
||
117 | | bfd_set_format (abfd, bfd_object); |
||
118 | | new = bfd_make_empty_symbol (abfd); |
||
119 | | new->name = "dummy_symbol"; |
||
120 | | new->section = bfd_make_section_old_way (abfd, ".text"); |
||
121 | | new->flags = BSF_GLOBAL; |
||
122 | | new->value = 0x12345; |
||
123 | | |
||
124 | | ptrs[0] = new; |
||
125 | | ptrs[1] = 0; |
||
126 | | |
||
127 | | bfd_set_symtab (abfd, ptrs, 1); |
||
128 | | bfd_close (abfd); |
||
129 | | return 0; |
||
130 | | } |
||
131 | | |
||
132 | | ./makesym |
||
133 | | nm foo |
||
134 | | 00012345 A dummy_symbol |
||
135 | |||
136 | Many formats cannot represent arbitrary symbol information; for |
||
137 | instance, the < |
||
138 | arbitrary number of sections. A symbol pointing to a section |
||
139 | which is not one of <<.text>>, <<.data>> or <<.bss>> cannot |
||
140 | be described. |
||
141 | |||
142 | INODE |
||
143 | Mini Symbols, typedef asymbol, Writing Symbols, Symbols |
||
144 | SUBSECTION |
||
145 | Mini Symbols |
||
146 | |||
147 | Mini symbols provide read-only access to the symbol table. |
||
148 | They use less memory space, but require more time to access. |
||
149 | They can be useful for tools like nm or objdump, which may |
||
150 | have to handle symbol tables of extremely large executables. |
||
151 | |||
152 | The < |
||
153 | into memory in an internal form. It will return a < |
||
154 | pointer to a block of memory, a symbol count, and the size of |
||
155 | each symbol. The pointer is allocated using < |
||
156 | should be freed by the caller when it is no longer needed. |
||
157 | |||
158 | The function < |
||
159 | to a minisymbol, and a pointer to a structure returned by |
||
160 | < |
||
161 | The return value may or may not be the same as the value from |
||
162 | < |
||
163 | |||
164 | */ |
||
165 | |||
166 | /* |
||
167 | DOCDD |
||
168 | INODE |
||
169 | typedef asymbol, symbol handling functions, Mini Symbols, Symbols |
||
170 | |||
171 | */ |
||
172 | /* |
||
173 | SUBSECTION |
||
174 | typedef asymbol |
||
175 | |||
176 | An < |
||
177 | |||
178 | */ |
||
179 | |||
180 | /* |
||
181 | CODE_FRAGMENT |
||
182 | |||
183 | . |
||
184 | .typedef struct bfd_symbol |
||
185 | .{ |
||
186 | . {* A pointer to the BFD which owns the symbol. This information |
||
187 | . is necessary so that a back end can work out what additional |
||
188 | . information (invisible to the application writer) is carried |
||
189 | . with the symbol. |
||
190 | . |
||
191 | . This field is *almost* redundant, since you can use section->owner |
||
192 | . instead, except that some symbols point to the global sections |
||
193 | . bfd_{abs,com,und}_section. This could be fixed by making |
||
194 | . these globals be per-bfd (or per-target-flavor). FIXME. *} |
||
195 | . struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *} |
||
196 | . |
||
197 | . {* The text of the symbol. The name is left alone, and not copied; the |
||
198 | . application may not alter it. *} |
||
199 | . const char *name; |
||
200 | . |
||
201 | . {* The value of the symbol. This really should be a union of a |
||
202 | . numeric value with a pointer, since some flags indicate that |
||
203 | . a pointer to another symbol is stored here. *} |
||
204 | . symvalue value; |
||
205 | . |
||
206 | . {* Attributes of a symbol. *} |
||
207 | .#define BSF_NO_FLAGS 0x00 |
||
208 | . |
||
209 | . {* The symbol has local scope; < |
||
210 | . is the offset into the section of the data. *} |
||
211 | .#define BSF_LOCAL (1 << 0) |
||
212 | . |
||
213 | . {* The symbol has global scope; initialized data in < |
||
214 | . value is the offset into the section of the data. *} |
||
215 | .#define BSF_GLOBAL (1 << 1) |
||
216 | . |
||
217 | . {* The symbol has global scope and is exported. The value is |
||
218 | . the offset into the section of the data. *} |
||
219 | .#define BSF_EXPORT BSF_GLOBAL {* No real difference. *} |
||
220 | . |
||
221 | . {* A normal C symbol would be one of: |
||
222 | . < |
||
223 | . < |
||
224 | . |
||
225 | . {* The symbol is a debugging record. The value has an arbitrary |
||
226 | . meaning, unless BSF_DEBUGGING_RELOC is also set. *} |
||
227 | .#define BSF_DEBUGGING (1 << 2) |
||
228 | . |
||
229 | . {* The symbol denotes a function entry point. Used in ELF, |
||
230 | . perhaps others someday. *} |
||
231 | .#define BSF_FUNCTION (1 << 3) |
||
232 | . |
||
233 | . {* Used by the linker. *} |
||
234 | .#define BSF_KEEP (1 << 5) |
||
235 | .#define BSF_KEEP_G (1 << 6) |
||
236 | . |
||
237 | . {* A weak global symbol, overridable without warnings by |
||
238 | . a regular global symbol of the same name. *} |
||
239 | .#define BSF_WEAK (1 << 7) |
||
240 | . |
||
241 | . {* This symbol was created to point to a section, e.g. ELF's |
||
242 | . STT_SECTION symbols. *} |
||
243 | .#define BSF_SECTION_SYM (1 << 8) |
||
244 | . |
||
245 | . {* The symbol used to be a common symbol, but now it is |
||
246 | . allocated. *} |
||
247 | .#define BSF_OLD_COMMON (1 << 9) |
||
248 | . |
||
249 | . {* In some files the type of a symbol sometimes alters its |
||
250 | . location in an output file - ie in coff a < |
||
251 | . which is also < |
||
252 | . declared and not at the end of a section. This bit is set |
||
253 | . by the target BFD part to convey this information. *} |
||
254 | .#define BSF_NOT_AT_END (1 << 10) |
||
255 | . |
||
256 | . {* Signal that the symbol is the label of constructor section. *} |
||
257 | .#define BSF_CONSTRUCTOR (1 << 11) |
||
258 | . |
||
259 | . {* Signal that the symbol is a warning symbol. The name is a |
||
260 | . warning. The name of the next symbol is the one to warn about; |
||
261 | . if a reference is made to a symbol with the same name as the next |
||
262 | . symbol, a warning is issued by the linker. *} |
||
263 | .#define BSF_WARNING (1 << 12) |
||
264 | . |
||
265 | . {* Signal that the symbol is indirect. This symbol is an indirect |
||
266 | . pointer to the symbol with the same name as the next symbol. *} |
||
267 | .#define BSF_INDIRECT (1 << 13) |
||
268 | . |
||
269 | . {* BSF_FILE marks symbols that contain a file name. This is used |
||
270 | . for ELF STT_FILE symbols. *} |
||
271 | .#define BSF_FILE (1 << 14) |
||
272 | . |
||
273 | . {* Symbol is from dynamic linking information. *} |
||
274 | .#define BSF_DYNAMIC (1 << 15) |
||
275 | . |
||
276 | . {* The symbol denotes a data object. Used in ELF, and perhaps |
||
277 | . others someday. *} |
||
278 | .#define BSF_OBJECT (1 << 16) |
||
279 | . |
||
280 | . {* This symbol is a debugging symbol. The value is the offset |
||
281 | . into the section of the data. BSF_DEBUGGING should be set |
||
282 | . as well. *} |
||
283 | .#define BSF_DEBUGGING_RELOC (1 << 17) |
||
284 | . |
||
285 | . {* This symbol is thread local. Used in ELF. *} |
||
286 | .#define BSF_THREAD_LOCAL (1 << 18) |
||
287 | . |
||
288 | . {* This symbol represents a complex relocation expression, |
||
289 | . with the expression tree serialized in the symbol name. *} |
||
290 | .#define BSF_RELC (1 << 19) |
||
291 | . |
||
292 | . {* This symbol represents a signed complex relocation expression, |
||
293 | . with the expression tree serialized in the symbol name. *} |
||
294 | .#define BSF_SRELC (1 << 20) |
||
295 | . |
||
296 | . {* This symbol was created by bfd_get_synthetic_symtab. *} |
||
297 | .#define BSF_SYNTHETIC (1 << 21) |
||
298 | . |
||
299 | . {* This symbol is an indirect code object. Unrelated to BSF_INDIRECT. |
||
300 | . The dynamic linker will compute the value of this symbol by |
||
301 | . calling the function that it points to. BSF_FUNCTION must |
||
302 | . also be also set. *} |
||
303 | .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22) |
||
304 | . {* This symbol is a globally unique data object. The dynamic linker |
||
305 | . will make sure that in the entire process there is just one symbol |
||
306 | . with this name and type in use. BSF_OBJECT must also be set. *} |
||
307 | .#define BSF_GNU_UNIQUE (1 << 23) |
||
308 | . |
||
309 | . flagword flags; |
||
310 | . |
||
311 | . {* A pointer to the section to which this symbol is |
||
312 | . relative. This will always be non NULL, there are special |
||
313 | . sections for undefined and absolute symbols. *} |
||
314 | . struct bfd_section *section; |
||
315 | . |
||
316 | . {* Back end special data. *} |
||
317 | . union |
||
318 | . { |
||
319 | . void *p; |
||
320 | . bfd_vma i; |
||
321 | . } |
||
322 | . udata; |
||
323 | .} |
||
324 | .asymbol; |
||
325 | . |
||
326 | */ |
||
327 | |||
328 | #include "sysdep.h" |
||
329 | #include "bfd.h" |
||
330 | #include "libbfd.h" |
||
331 | #include "safe-ctype.h" |
||
332 | #include "bfdlink.h" |
||
333 | #include "aout/stab_gnu.h" |
||
334 | |||
335 | /* |
||
336 | DOCDD |
||
337 | INODE |
||
338 | symbol handling functions, , typedef asymbol, Symbols |
||
339 | SUBSECTION |
||
340 | Symbol handling functions |
||
341 | */ |
||
342 | |||
343 | /* |
||
344 | FUNCTION |
||
345 | bfd_get_symtab_upper_bound |
||
346 | |||
347 | DESCRIPTION |
||
348 | Return the number of bytes required to store a vector of pointers |
||
349 | to < |
||
350 | including a terminal NULL pointer. If there are no symbols in |
||
351 | the BFD, then return 0. If an error occurs, return -1. |
||
352 | |||
353 | .#define bfd_get_symtab_upper_bound(abfd) \ |
||
354 | . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) |
||
355 | . |
||
356 | */ |
||
357 | |||
358 | /* |
||
359 | FUNCTION |
||
360 | bfd_is_local_label |
||
361 | |||
362 | SYNOPSIS |
||
363 | bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); |
||
364 | |||
365 | DESCRIPTION |
||
366 | Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is |
||
367 | a compiler generated local label, else return FALSE. |
||
368 | */ |
||
369 | |||
370 | bfd_boolean |
||
371 | bfd_is_local_label (bfd *abfd, asymbol *sym) |
||
372 | { |
||
373 | /* The BSF_SECTION_SYM check is needed for IA-64, where every label that |
||
374 | starts with '.' is local. This would accidentally catch section names |
||
375 | if we didn't reject them here. */ |
||
376 | if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0) |
||
377 | return FALSE; |
||
378 | if (sym->name == NULL) |
||
379 | return FALSE; |
||
380 | return bfd_is_local_label_name (abfd, sym->name); |
||
381 | } |
||
382 | |||
383 | /* |
||
384 | FUNCTION |
||
385 | bfd_is_local_label_name |
||
386 | |||
387 | SYNOPSIS |
||
388 | bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); |
||
389 | |||
390 | DESCRIPTION |
||
391 | Return TRUE if a symbol with the name @var{name} in the BFD |
||
392 | @var{abfd} is a compiler generated local label, else return |
||
393 | FALSE. This just checks whether the name has the form of a |
||
394 | local label. |
||
395 | |||
396 | .#define bfd_is_local_label_name(abfd, name) \ |
||
397 | . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) |
||
398 | . |
||
399 | */ |
||
400 | |||
401 | /* |
||
402 | FUNCTION |
||
403 | bfd_is_target_special_symbol |
||
404 | |||
405 | SYNOPSIS |
||
406 | bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); |
||
407 | |||
408 | DESCRIPTION |
||
409 | Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something |
||
410 | special to the particular target represented by the BFD. Such symbols |
||
411 | should normally not be mentioned to the user. |
||
412 | |||
413 | .#define bfd_is_target_special_symbol(abfd, sym) \ |
||
414 | . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) |
||
415 | . |
||
416 | */ |
||
417 | |||
418 | /* |
||
419 | FUNCTION |
||
420 | bfd_canonicalize_symtab |
||
421 | |||
422 | DESCRIPTION |
||
423 | Read the symbols from the BFD @var{abfd}, and fills in |
||
424 | the vector @var{location} with pointers to the symbols and |
||
425 | a trailing NULL. |
||
426 | Return the actual number of symbol pointers, not |
||
427 | including the NULL. |
||
428 | |||
429 | .#define bfd_canonicalize_symtab(abfd, location) \ |
||
430 | . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) |
||
431 | . |
||
432 | */ |
||
433 | |||
434 | /* |
||
435 | FUNCTION |
||
436 | bfd_set_symtab |
||
437 | |||
438 | SYNOPSIS |
||
439 | bfd_boolean bfd_set_symtab |
||
440 | (bfd *abfd, asymbol **location, unsigned int count); |
||
441 | |||
442 | DESCRIPTION |
||
443 | Arrange that when the output BFD @var{abfd} is closed, |
||
444 | the table @var{location} of @var{count} pointers to symbols |
||
445 | will be written. |
||
446 | */ |
||
447 | |||
448 | bfd_boolean |
||
449 | bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount) |
||
450 | { |
||
451 | if (abfd->format != bfd_object || bfd_read_p (abfd)) |
||
452 | { |
||
453 | bfd_set_error (bfd_error_invalid_operation); |
||
454 | return FALSE; |
||
455 | } |
||
456 | |||
457 | bfd_get_outsymbols (abfd) = location; |
||
458 | bfd_get_symcount (abfd) = symcount; |
||
459 | return TRUE; |
||
460 | } |
||
461 | |||
462 | /* |
||
463 | FUNCTION |
||
464 | bfd_print_symbol_vandf |
||
465 | |||
466 | SYNOPSIS |
||
467 | void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); |
||
468 | |||
469 | DESCRIPTION |
||
470 | Print the value and flags of the @var{symbol} supplied to the |
||
471 | stream @var{file}. |
||
472 | */ |
||
473 | void |
||
474 | bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol) |
||
475 | { |
||
476 | FILE *file = (FILE *) arg; |
||
477 | |||
478 | flagword type = symbol->flags; |
||
479 | |||
480 | if (symbol->section != NULL) |
||
481 | bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma); |
||
482 | else |
||
483 | bfd_fprintf_vma (abfd, file, symbol->value); |
||
484 | |||
485 | /* This presumes that a symbol can not be both BSF_DEBUGGING and |
||
486 | BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and |
||
487 | BSF_OBJECT. */ |
||
488 | fprintf (file, " %c%c%c%c%c%c%c", |
||
489 | ((type & BSF_LOCAL) |
||
490 | ? (type & BSF_GLOBAL) ? '!' : 'l' |
||
491 | : (type & BSF_GLOBAL) ? 'g' |
||
492 | : (type & BSF_GNU_UNIQUE) ? 'u' : ' '), |
||
493 | (type & BSF_WEAK) ? 'w' : ' ', |
||
494 | (type & BSF_CONSTRUCTOR) ? 'C' : ' ', |
||
495 | (type & BSF_WARNING) ? 'W' : ' ', |
||
496 | (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ', |
||
497 | (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ', |
||
498 | ((type & BSF_FUNCTION) |
||
499 | ? 'F' |
||
500 | : ((type & BSF_FILE) |
||
501 | ? 'f' |
||
502 | : ((type & BSF_OBJECT) ? 'O' : ' ')))); |
||
503 | } |
||
504 | |||
505 | /* |
||
506 | FUNCTION |
||
507 | bfd_make_empty_symbol |
||
508 | |||
509 | DESCRIPTION |
||
510 | Create a new < |
||
511 | and return a pointer to it. |
||
512 | |||
513 | This routine is necessary because each back end has private |
||
514 | information surrounding the < |
||
515 | < |
||
516 | information, and will cause problems later on. |
||
517 | |||
518 | .#define bfd_make_empty_symbol(abfd) \ |
||
519 | . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) |
||
520 | . |
||
521 | */ |
||
522 | |||
523 | /* |
||
524 | FUNCTION |
||
525 | _bfd_generic_make_empty_symbol |
||
526 | |||
527 | SYNOPSIS |
||
528 | asymbol *_bfd_generic_make_empty_symbol (bfd *); |
||
529 | |||
530 | DESCRIPTION |
||
531 | Create a new < |
||
532 | and return a pointer to it. Used by core file routines, |
||
533 | binary back-end and anywhere else where no private info |
||
534 | is needed. |
||
535 | */ |
||
536 | |||
537 | asymbol * |
||
538 | _bfd_generic_make_empty_symbol (bfd *abfd) |
||
539 | { |
||
540 | bfd_size_type amt = sizeof (asymbol); |
||
541 | asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt); |
||
542 | if (new_symbol) |
||
543 | new_symbol->the_bfd = abfd; |
||
544 | return new_symbol; |
||
545 | } |
||
546 | |||
547 | /* |
||
548 | FUNCTION |
||
549 | bfd_make_debug_symbol |
||
550 | |||
551 | DESCRIPTION |
||
552 | Create a new < |
||
553 | to be used as a debugging symbol. Further details of its use have |
||
554 | yet to be worked out. |
||
555 | |||
556 | .#define bfd_make_debug_symbol(abfd,ptr,size) \ |
||
557 | . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) |
||
558 | . |
||
559 | */ |
||
560 | |||
561 | struct section_to_type |
||
562 | { |
||
563 | const char *section; |
||
564 | char type; |
||
565 | }; |
||
566 | |||
567 | /* Map section names to POSIX/BSD single-character symbol types. |
||
568 | This table is probably incomplete. It is sorted for convenience of |
||
569 | adding entries. Since it is so short, a linear search is used. */ |
||
570 | static const struct section_to_type stt[] = |
||
571 | { |
||
572 | {".bss", 'b'}, |
||
573 | {"code", 't'}, /* MRI .text */ |
||
574 | {".data", 'd'}, |
||
575 | {"*DEBUG*", 'N'}, |
||
576 | {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */ |
||
577 | {".drectve", 'i'}, /* MSVC's .drective section */ |
||
578 | {".edata", 'e'}, /* MSVC's .edata (export) section */ |
||
579 | {".fini", 't'}, /* ELF fini section */ |
||
580 | {".idata", 'i'}, /* MSVC's .idata (import) section */ |
||
581 | {".init", 't'}, /* ELF init section */ |
||
582 | {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */ |
||
583 | {".rdata", 'r'}, /* Read only data. */ |
||
584 | {".rodata", 'r'}, /* Read only data. */ |
||
585 | {".sbss", 's'}, /* Small BSS (uninitialized data). */ |
||
586 | {".scommon", 'c'}, /* Small common. */ |
||
587 | {".sdata", 'g'}, /* Small initialized data. */ |
||
588 | {".text", 't'}, |
||
589 | {"vars", 'd'}, /* MRI .data */ |
||
590 | {"zerovars", 'b'}, /* MRI .bss */ |
||
591 | {0, 0} |
||
592 | }; |
||
593 | |||
594 | /* Return the single-character symbol type corresponding to |
||
595 | section S, or '?' for an unknown COFF section. |
||
596 | |||
597 | Check for any leading string which matches, so .text5 returns |
||
598 | 't' as well as .text */ |
||
599 | |||
600 | static char |
||
601 | coff_section_type (const char *s) |
||
602 | { |
||
603 | const struct section_to_type *t; |
||
604 | |||
605 | for (t = &stt[0]; t->section; t++) |
||
606 | if (!strncmp (s, t->section, strlen (t->section))) |
||
607 | return t->type; |
||
608 | |||
609 | return '?'; |
||
610 | } |
||
611 | |||
612 | /* Return the single-character symbol type corresponding to section |
||
613 | SECTION, or '?' for an unknown section. This uses section flags to |
||
614 | identify sections. |
||
615 | |||
616 | FIXME These types are unhandled: c, i, e, p. If we handled these also, |
||
617 | we could perhaps obsolete coff_section_type. */ |
||
618 | |||
619 | static char |
||
620 | decode_section_type (const struct bfd_section *section) |
||
621 | { |
||
622 | if (section->flags & SEC_CODE) |
||
623 | return 't'; |
||
624 | if (section->flags & SEC_DATA) |
||
625 | { |
||
626 | if (section->flags & SEC_READONLY) |
||
627 | return 'r'; |
||
628 | else if (section->flags & SEC_SMALL_DATA) |
||
629 | return 'g'; |
||
630 | else |
||
631 | return 'd'; |
||
632 | } |
||
633 | if ((section->flags & SEC_HAS_CONTENTS) == 0) |
||
634 | { |
||
635 | if (section->flags & SEC_SMALL_DATA) |
||
636 | return 's'; |
||
637 | else |
||
638 | return 'b'; |
||
639 | } |
||
640 | if (section->flags & SEC_DEBUGGING) |
||
641 | return 'N'; |
||
642 | if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY)) |
||
643 | return 'n'; |
||
644 | |||
645 | return '?'; |
||
646 | } |
||
647 | |||
648 | /* |
||
649 | FUNCTION |
||
650 | bfd_decode_symclass |
||
651 | |||
652 | DESCRIPTION |
||
653 | Return a character corresponding to the symbol |
||
654 | class of @var{symbol}, or '?' for an unknown class. |
||
655 | |||
656 | SYNOPSIS |
||
657 | int bfd_decode_symclass (asymbol *symbol); |
||
658 | */ |
||
659 | int |
||
660 | bfd_decode_symclass (asymbol *symbol) |
||
661 | { |
||
662 | char c; |
||
663 | |||
664 | if (symbol->section && bfd_is_com_section (symbol->section)) |
||
665 | return 'C'; |
||
666 | if (bfd_is_und_section (symbol->section)) |
||
667 | { |
||
668 | if (symbol->flags & BSF_WEAK) |
||
669 | { |
||
670 | /* If weak, determine if it's specifically an object |
||
671 | or non-object weak. */ |
||
672 | if (symbol->flags & BSF_OBJECT) |
||
673 | return 'v'; |
||
674 | else |
||
675 | return 'w'; |
||
676 | } |
||
677 | else |
||
678 | return 'U'; |
||
679 | } |
||
680 | if (bfd_is_ind_section (symbol->section)) |
||
681 | return 'I'; |
||
682 | if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION) |
||
683 | return 'i'; |
||
684 | if (symbol->flags & BSF_WEAK) |
||
685 | { |
||
686 | /* If weak, determine if it's specifically an object |
||
687 | or non-object weak. */ |
||
688 | if (symbol->flags & BSF_OBJECT) |
||
689 | return 'V'; |
||
690 | else |
||
691 | return 'W'; |
||
692 | } |
||
693 | if (symbol->flags & BSF_GNU_UNIQUE) |
||
694 | return 'u'; |
||
695 | if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) |
||
696 | return '?'; |
||
697 | |||
698 | if (bfd_is_abs_section (symbol->section)) |
||
699 | c = 'a'; |
||
700 | else if (symbol->section) |
||
701 | { |
||
702 | c = coff_section_type (symbol->section->name); |
||
703 | if (c == '?') |
||
704 | c = decode_section_type (symbol->section); |
||
705 | } |
||
706 | else |
||
707 | return '?'; |
||
708 | if (symbol->flags & BSF_GLOBAL) |
||
709 | c = TOUPPER (c); |
||
710 | return c; |
||
711 | |||
712 | /* We don't have to handle these cases just yet, but we will soon: |
||
713 | N_SETV: 'v'; |
||
714 | N_SETA: 'l'; |
||
715 | N_SETT: 'x'; |
||
716 | N_SETD: 'z'; |
||
717 | N_SETB: 's'; |
||
718 | N_INDR: 'i'; |
||
719 | */ |
||
720 | } |
||
721 | |||
722 | /* |
||
723 | FUNCTION |
||
724 | bfd_is_undefined_symclass |
||
725 | |||
726 | DESCRIPTION |
||
727 | Returns non-zero if the class symbol returned by |
||
728 | bfd_decode_symclass represents an undefined symbol. |
||
729 | Returns zero otherwise. |
||
730 | |||
731 | SYNOPSIS |
||
732 | bfd_boolean bfd_is_undefined_symclass (int symclass); |
||
733 | */ |
||
734 | |||
735 | bfd_boolean |
||
736 | bfd_is_undefined_symclass (int symclass) |
||
737 | { |
||
738 | return symclass == 'U' || symclass == 'w' || symclass == 'v'; |
||
739 | } |
||
740 | |||
741 | /* |
||
742 | FUNCTION |
||
743 | bfd_symbol_info |
||
744 | |||
745 | DESCRIPTION |
||
746 | Fill in the basic info about symbol that nm needs. |
||
747 | Additional info may be added by the back-ends after |
||
748 | calling this function. |
||
749 | |||
750 | SYNOPSIS |
||
751 | void bfd_symbol_info (asymbol *symbol, symbol_info *ret); |
||
752 | */ |
||
753 | |||
754 | void |
||
755 | bfd_symbol_info (asymbol *symbol, symbol_info *ret) |
||
756 | { |
||
757 | ret->type = bfd_decode_symclass (symbol); |
||
758 | |||
759 | if (bfd_is_undefined_symclass (ret->type)) |
||
760 | ret->value = 0; |
||
761 | else |
||
762 | ret->value = symbol->value + symbol->section->vma; |
||
763 | |||
764 | ret->name = symbol->name; |
||
765 | } |
||
766 | |||
767 | /* |
||
768 | FUNCTION |
||
769 | bfd_copy_private_symbol_data |
||
770 | |||
771 | SYNOPSIS |
||
772 | bfd_boolean bfd_copy_private_symbol_data |
||
773 | (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); |
||
774 | |||
775 | DESCRIPTION |
||
776 | Copy private symbol information from @var{isym} in the BFD |
||
777 | @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}. |
||
778 | Return < |
||
779 | returns are: |
||
780 | |||
781 | o < |
||
782 | Not enough memory exists to create private data for @var{osec}. |
||
783 | |||
784 | .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ |
||
785 | . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ |
||
786 | . (ibfd, isymbol, obfd, osymbol)) |
||
787 | . |
||
788 | */ |
||
789 | |||
790 | /* The generic version of the function which returns mini symbols. |
||
791 | This is used when the backend does not provide a more efficient |
||
792 | version. It just uses BFD asymbol structures as mini symbols. */ |
||
793 | |||
794 | long |
||
795 | _bfd_generic_read_minisymbols (bfd *abfd, |
||
796 | bfd_boolean dynamic, |
||
797 | void **minisymsp, |
||
798 | unsigned int *sizep) |
||
799 | { |
||
800 | long storage; |
||
801 | asymbol **syms = NULL; |
||
802 | long symcount; |
||
803 | |||
804 | if (dynamic) |
||
805 | storage = bfd_get_dynamic_symtab_upper_bound (abfd); |
||
806 | else |
||
807 | storage = bfd_get_symtab_upper_bound (abfd); |
||
808 | if (storage < 0) |
||
809 | goto error_return; |
||
810 | if (storage == 0) |
||
811 | return 0; |
||
812 | |||
813 | syms = (asymbol **) bfd_malloc (storage); |
||
814 | if (syms == NULL) |
||
815 | goto error_return; |
||
816 | |||
817 | if (dynamic) |
||
818 | symcount = bfd_canonicalize_dynamic_symtab (abfd, syms); |
||
819 | else |
||
820 | symcount = bfd_canonicalize_symtab (abfd, syms); |
||
821 | if (symcount < 0) |
||
822 | goto error_return; |
||
823 | |||
824 | *minisymsp = syms; |
||
825 | *sizep = sizeof (asymbol *); |
||
6324 | serge | 826 | |
5197 | serge | 827 | return symcount; |
828 | |||
829 | error_return: |
||
830 | bfd_set_error (bfd_error_no_symbols); |
||
831 | if (syms != NULL) |
||
832 | free (syms); |
||
833 | return -1; |
||
834 | } |
||
835 | |||
836 | /* The generic version of the function which converts a minisymbol to |
||
837 | an asymbol. We don't worry about the sym argument we are passed; |
||
838 | we just return the asymbol the minisymbol points to. */ |
||
839 | |||
840 | asymbol * |
||
841 | _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED, |
||
842 | bfd_boolean dynamic ATTRIBUTE_UNUSED, |
||
843 | const void *minisym, |
||
844 | asymbol *sym ATTRIBUTE_UNUSED) |
||
845 | { |
||
846 | return *(asymbol **) minisym; |
||
847 | } |
||
848 | |||
849 | /* Look through stabs debugging information in .stab and .stabstr |
||
850 | sections to find the source file and line closest to a desired |
||
851 | location. This is used by COFF and ELF targets. It sets *pfound |
||
852 | to TRUE if it finds some information. The *pinfo field is used to |
||
853 | pass cached information in and out of this routine; this first time |
||
854 | the routine is called for a BFD, *pinfo should be NULL. The value |
||
855 | placed in *pinfo should be saved with the BFD, and passed back each |
||
856 | time this function is called. */ |
||
857 | |||
858 | /* We use a cache by default. */ |
||
859 | |||
860 | #define ENABLE_CACHING |
||
861 | |||
862 | /* We keep an array of indexentry structures to record where in the |
||
863 | stabs section we should look to find line number information for a |
||
864 | particular address. */ |
||
865 | |||
866 | struct indexentry |
||
867 | { |
||
868 | bfd_vma val; |
||
869 | bfd_byte *stab; |
||
870 | bfd_byte *str; |
||
871 | char *directory_name; |
||
872 | char *file_name; |
||
873 | char *function_name; |
||
874 | }; |
||
875 | |||
876 | /* Compare two indexentry structures. This is called via qsort. */ |
||
877 | |||
878 | static int |
||
879 | cmpindexentry (const void *a, const void *b) |
||
880 | { |
||
881 | const struct indexentry *contestantA = (const struct indexentry *) a; |
||
882 | const struct indexentry *contestantB = (const struct indexentry *) b; |
||
883 | |||
884 | if (contestantA->val < contestantB->val) |
||
885 | return -1; |
||
886 | else if (contestantA->val > contestantB->val) |
||
887 | return 1; |
||
888 | else |
||
889 | return 0; |
||
890 | } |
||
891 | |||
892 | /* A pointer to this structure is stored in *pinfo. */ |
||
893 | |||
894 | struct stab_find_info |
||
895 | { |
||
896 | /* The .stab section. */ |
||
897 | asection *stabsec; |
||
898 | /* The .stabstr section. */ |
||
899 | asection *strsec; |
||
900 | /* The contents of the .stab section. */ |
||
901 | bfd_byte *stabs; |
||
902 | /* The contents of the .stabstr section. */ |
||
903 | bfd_byte *strs; |
||
904 | |||
905 | /* A table that indexes stabs by memory address. */ |
||
906 | struct indexentry *indextable; |
||
907 | /* The number of entries in indextable. */ |
||
908 | int indextablesize; |
||
909 | |||
910 | #ifdef ENABLE_CACHING |
||
911 | /* Cached values to restart quickly. */ |
||
912 | struct indexentry *cached_indexentry; |
||
913 | bfd_vma cached_offset; |
||
914 | bfd_byte *cached_stab; |
||
915 | char *cached_file_name; |
||
916 | #endif |
||
917 | |||
918 | /* Saved ptr to malloc'ed filename. */ |
||
919 | char *filename; |
||
920 | }; |
||
921 | |||
922 | bfd_boolean |
||
923 | _bfd_stab_section_find_nearest_line (bfd *abfd, |
||
924 | asymbol **symbols, |
||
925 | asection *section, |
||
926 | bfd_vma offset, |
||
927 | bfd_boolean *pfound, |
||
928 | const char **pfilename, |
||
929 | const char **pfnname, |
||
930 | unsigned int *pline, |
||
931 | void **pinfo) |
||
932 | { |
||
933 | struct stab_find_info *info; |
||
934 | bfd_size_type stabsize, strsize; |
||
935 | bfd_byte *stab, *str; |
||
6324 | serge | 936 | bfd_byte *nul_fun, *nul_str; |
5197 | serge | 937 | bfd_size_type stroff; |
938 | struct indexentry *indexentry; |
||
939 | char *file_name; |
||
940 | char *directory_name; |
||
941 | bfd_boolean saw_line, saw_func; |
||
942 | |||
943 | *pfound = FALSE; |
||
944 | *pfilename = bfd_get_filename (abfd); |
||
945 | *pfnname = NULL; |
||
946 | *pline = 0; |
||
947 | |||
948 | /* Stabs entries use a 12 byte format: |
||
949 | 4 byte string table index |
||
950 | 1 byte stab type |
||
951 | 1 byte stab other field |
||
952 | 2 byte stab desc field |
||
953 | 4 byte stab value |
||
954 | FIXME: This will have to change for a 64 bit object format. |
||
955 | |||
956 | The stabs symbols are divided into compilation units. For the |
||
957 | first entry in each unit, the type of 0, the value is the length |
||
958 | of the string table for this unit, and the desc field is the |
||
959 | number of stabs symbols for this unit. */ |
||
960 | |||
961 | #define STRDXOFF (0) |
||
962 | #define TYPEOFF (4) |
||
963 | #define OTHEROFF (5) |
||
964 | #define DESCOFF (6) |
||
965 | #define VALOFF (8) |
||
966 | #define STABSIZE (12) |
||
967 | |||
968 | info = (struct stab_find_info *) *pinfo; |
||
969 | if (info != NULL) |
||
970 | { |
||
971 | if (info->stabsec == NULL || info->strsec == NULL) |
||
972 | { |
||
973 | /* No stabs debugging information. */ |
||
974 | return TRUE; |
||
975 | } |
||
976 | |||
977 | stabsize = (info->stabsec->rawsize |
||
978 | ? info->stabsec->rawsize |
||
979 | : info->stabsec->size); |
||
980 | strsize = (info->strsec->rawsize |
||
981 | ? info->strsec->rawsize |
||
982 | : info->strsec->size); |
||
983 | } |
||
984 | else |
||
985 | { |
||
986 | long reloc_size, reloc_count; |
||
987 | arelent **reloc_vector; |
||
988 | int i; |
||
989 | char *function_name; |
||
990 | bfd_size_type amt = sizeof *info; |
||
991 | |||
992 | info = (struct stab_find_info *) bfd_zalloc (abfd, amt); |
||
993 | if (info == NULL) |
||
994 | return FALSE; |
||
995 | |||
996 | /* FIXME: When using the linker --split-by-file or |
||
997 | --split-by-reloc options, it is possible for the .stab and |
||
998 | .stabstr sections to be split. We should handle that. */ |
||
999 | |||
1000 | info->stabsec = bfd_get_section_by_name (abfd, ".stab"); |
||
1001 | info->strsec = bfd_get_section_by_name (abfd, ".stabstr"); |
||
1002 | |||
1003 | if (info->stabsec == NULL || info->strsec == NULL) |
||
1004 | { |
||
1005 | /* Try SOM section names. */ |
||
1006 | info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$"); |
||
1007 | info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$"); |
||
1008 | |||
1009 | if (info->stabsec == NULL || info->strsec == NULL) |
||
1010 | { |
||
1011 | /* No stabs debugging information. Set *pinfo so that we |
||
1012 | can return quickly in the info != NULL case above. */ |
||
1013 | *pinfo = info; |
||
1014 | return TRUE; |
||
1015 | } |
||
1016 | } |
||
1017 | |||
1018 | stabsize = (info->stabsec->rawsize |
||
1019 | ? info->stabsec->rawsize |
||
1020 | : info->stabsec->size); |
||
6324 | serge | 1021 | stabsize = (stabsize / STABSIZE) * STABSIZE; |
5197 | serge | 1022 | strsize = (info->strsec->rawsize |
1023 | ? info->strsec->rawsize |
||
1024 | : info->strsec->size); |
||
1025 | |||
1026 | info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize); |
||
1027 | info->strs = (bfd_byte *) bfd_alloc (abfd, strsize); |
||
1028 | if (info->stabs == NULL || info->strs == NULL) |
||
1029 | return FALSE; |
||
1030 | |||
1031 | if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs, |
||
1032 | 0, stabsize) |
||
1033 | || ! bfd_get_section_contents (abfd, info->strsec, info->strs, |
||
1034 | 0, strsize)) |
||
1035 | return FALSE; |
||
1036 | |||
1037 | /* If this is a relocatable object file, we have to relocate |
||
1038 | the entries in .stab. This should always be simple 32 bit |
||
1039 | relocations against symbols defined in this object file, so |
||
1040 | this should be no big deal. */ |
||
1041 | reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec); |
||
1042 | if (reloc_size < 0) |
||
1043 | return FALSE; |
||
1044 | reloc_vector = (arelent **) bfd_malloc (reloc_size); |
||
1045 | if (reloc_vector == NULL && reloc_size != 0) |
||
1046 | return FALSE; |
||
1047 | reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector, |
||
1048 | symbols); |
||
1049 | if (reloc_count < 0) |
||
1050 | { |
||
1051 | if (reloc_vector != NULL) |
||
1052 | free (reloc_vector); |
||
1053 | return FALSE; |
||
1054 | } |
||
1055 | if (reloc_count > 0) |
||
1056 | { |
||
1057 | arelent **pr; |
||
1058 | |||
1059 | for (pr = reloc_vector; *pr != NULL; pr++) |
||
1060 | { |
||
1061 | arelent *r; |
||
1062 | unsigned long val; |
||
1063 | asymbol *sym; |
||
1064 | |||
1065 | r = *pr; |
||
1066 | /* Ignore R_*_NONE relocs. */ |
||
1067 | if (r->howto->dst_mask == 0) |
||
1068 | continue; |
||
1069 | |||
1070 | if (r->howto->rightshift != 0 |
||
1071 | || r->howto->size != 2 |
||
1072 | || r->howto->bitsize != 32 |
||
1073 | || r->howto->pc_relative |
||
1074 | || r->howto->bitpos != 0 |
||
1075 | || r->howto->dst_mask != 0xffffffff) |
||
1076 | { |
||
1077 | (*_bfd_error_handler) |
||
1078 | (_("Unsupported .stab relocation")); |
||
1079 | bfd_set_error (bfd_error_invalid_operation); |
||
1080 | if (reloc_vector != NULL) |
||
1081 | free (reloc_vector); |
||
1082 | return FALSE; |
||
1083 | } |
||
1084 | |||
1085 | val = bfd_get_32 (abfd, info->stabs + r->address); |
||
1086 | val &= r->howto->src_mask; |
||
1087 | sym = *r->sym_ptr_ptr; |
||
1088 | val += sym->value + sym->section->vma + r->addend; |
||
1089 | bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address); |
||
1090 | } |
||
1091 | } |
||
1092 | |||
1093 | if (reloc_vector != NULL) |
||
1094 | free (reloc_vector); |
||
1095 | |||
1096 | /* First time through this function, build a table matching |
||
1097 | function VM addresses to stabs, then sort based on starting |
||
1098 | VM address. Do this in two passes: once to count how many |
||
1099 | table entries we'll need, and a second to actually build the |
||
1100 | table. */ |
||
1101 | |||
1102 | info->indextablesize = 0; |
||
6324 | serge | 1103 | nul_fun = NULL; |
5197 | serge | 1104 | for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE) |
1105 | { |
||
1106 | if (stab[TYPEOFF] == (bfd_byte) N_SO) |
||
1107 | { |
||
1108 | /* if we did not see a function def, leave space for one. */ |
||
6324 | serge | 1109 | if (nul_fun != NULL) |
5197 | serge | 1110 | ++info->indextablesize; |
1111 | |||
6324 | serge | 1112 | /* N_SO with null name indicates EOF */ |
1113 | if (bfd_get_32 (abfd, stab + STRDXOFF) == 0) |
||
1114 | nul_fun = NULL; |
||
1115 | else |
||
1116 | { |
||
1117 | nul_fun = stab; |
||
5197 | serge | 1118 | |
1119 | /* two N_SO's in a row is a filename and directory. Skip */ |
||
6324 | serge | 1120 | if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize |
5197 | serge | 1121 | && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) |
1122 | stab += STABSIZE; |
||
1123 | } |
||
1124 | } |
||
6324 | serge | 1125 | else if (stab[TYPEOFF] == (bfd_byte) N_FUN |
1126 | && bfd_get_32 (abfd, stab + STRDXOFF) != 0) |
||
5197 | serge | 1127 | { |
6324 | serge | 1128 | nul_fun = NULL; |
5197 | serge | 1129 | ++info->indextablesize; |
1130 | } |
||
1131 | } |
||
1132 | |||
6324 | serge | 1133 | if (nul_fun != NULL) |
5197 | serge | 1134 | ++info->indextablesize; |
1135 | |||
1136 | if (info->indextablesize == 0) |
||
1137 | return TRUE; |
||
1138 | ++info->indextablesize; |
||
1139 | |||
1140 | amt = info->indextablesize; |
||
1141 | amt *= sizeof (struct indexentry); |
||
1142 | info->indextable = (struct indexentry *) bfd_alloc (abfd, amt); |
||
1143 | if (info->indextable == NULL) |
||
1144 | return FALSE; |
||
1145 | |||
1146 | file_name = NULL; |
||
1147 | directory_name = NULL; |
||
6324 | serge | 1148 | nul_fun = NULL; |
5197 | serge | 1149 | stroff = 0; |
1150 | |||
6324 | serge | 1151 | for (i = 0, stab = info->stabs, nul_str = str = info->strs; |
5197 | serge | 1152 | i < info->indextablesize && stab < info->stabs + stabsize; |
1153 | stab += STABSIZE) |
||
1154 | { |
||
1155 | switch (stab[TYPEOFF]) |
||
1156 | { |
||
1157 | case 0: |
||
1158 | /* This is the first entry in a compilation unit. */ |
||
1159 | if ((bfd_size_type) ((info->strs + strsize) - str) < stroff) |
||
1160 | break; |
||
1161 | str += stroff; |
||
1162 | stroff = bfd_get_32 (abfd, stab + VALOFF); |
||
1163 | break; |
||
1164 | |||
1165 | case N_SO: |
||
1166 | /* The main file name. */ |
||
1167 | |||
1168 | /* The following code creates a new indextable entry with |
||
1169 | a NULL function name if there were no N_FUNs in a file. |
||
1170 | Note that a N_SO without a file name is an EOF and |
||
1171 | there could be 2 N_SO following it with the new filename |
||
1172 | and directory. */ |
||
6324 | serge | 1173 | if (nul_fun != NULL) |
5197 | serge | 1174 | { |
6324 | serge | 1175 | info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); |
1176 | info->indextable[i].stab = nul_fun; |
||
1177 | info->indextable[i].str = nul_str; |
||
5197 | serge | 1178 | info->indextable[i].directory_name = directory_name; |
1179 | info->indextable[i].file_name = file_name; |
||
1180 | info->indextable[i].function_name = NULL; |
||
1181 | ++i; |
||
1182 | } |
||
1183 | |||
6324 | serge | 1184 | directory_name = NULL; |
5197 | serge | 1185 | file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); |
6324 | serge | 1186 | if (file_name == (char *) str) |
5197 | serge | 1187 | { |
1188 | file_name = NULL; |
||
6324 | serge | 1189 | nul_fun = NULL; |
5197 | serge | 1190 | } |
1191 | else |
||
1192 | { |
||
6324 | serge | 1193 | nul_fun = stab; |
1194 | nul_str = str; |
||
1195 | if (file_name >= (char *) info->strs + strsize || file_name < (char *) str) |
||
1196 | file_name = NULL; |
||
1197 | if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize |
||
1198 | && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO) |
||
5197 | serge | 1199 | { |
1200 | /* Two consecutive N_SOs are a directory and a |
||
1201 | file name. */ |
||
1202 | stab += STABSIZE; |
||
1203 | directory_name = file_name; |
||
1204 | file_name = ((char *) str |
||
1205 | + bfd_get_32 (abfd, stab + STRDXOFF)); |
||
6324 | serge | 1206 | if (file_name >= (char *) info->strs + strsize || file_name < (char *) str) |
1207 | file_name = NULL; |
||
5197 | serge | 1208 | } |
1209 | } |
||
1210 | break; |
||
1211 | |||
1212 | case N_SOL: |
||
1213 | /* The name of an include file. */ |
||
1214 | file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); |
||
6324 | serge | 1215 | /* PR 17512: file: 0c680a1f. */ |
1216 | /* PR 17512: file: 5da8aec4. */ |
||
1217 | if (file_name >= (char *) info->strs + strsize || file_name < (char *) str) |
||
1218 | file_name = NULL; |
||
5197 | serge | 1219 | break; |
1220 | |||
1221 | case N_FUN: |
||
1222 | /* A function name. */ |
||
6324 | serge | 1223 | function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); |
1224 | if (function_name == (char *) str) |
||
5197 | serge | 1225 | continue; |
6324 | serge | 1226 | if (function_name >= (char *) info->strs + strsize) |
1227 | function_name = NULL; |
||
5197 | serge | 1228 | |
6324 | serge | 1229 | nul_fun = NULL; |
5197 | serge | 1230 | info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF); |
1231 | info->indextable[i].stab = stab; |
||
1232 | info->indextable[i].str = str; |
||
1233 | info->indextable[i].directory_name = directory_name; |
||
1234 | info->indextable[i].file_name = file_name; |
||
1235 | info->indextable[i].function_name = function_name; |
||
1236 | ++i; |
||
1237 | break; |
||
1238 | } |
||
1239 | } |
||
1240 | |||
6324 | serge | 1241 | if (nul_fun != NULL) |
5197 | serge | 1242 | { |
6324 | serge | 1243 | info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF); |
1244 | info->indextable[i].stab = nul_fun; |
||
1245 | info->indextable[i].str = nul_str; |
||
5197 | serge | 1246 | info->indextable[i].directory_name = directory_name; |
1247 | info->indextable[i].file_name = file_name; |
||
1248 | info->indextable[i].function_name = NULL; |
||
1249 | ++i; |
||
1250 | } |
||
1251 | |||
1252 | info->indextable[i].val = (bfd_vma) -1; |
||
1253 | info->indextable[i].stab = info->stabs + stabsize; |
||
1254 | info->indextable[i].str = str; |
||
1255 | info->indextable[i].directory_name = NULL; |
||
1256 | info->indextable[i].file_name = NULL; |
||
1257 | info->indextable[i].function_name = NULL; |
||
1258 | ++i; |
||
1259 | |||
1260 | info->indextablesize = i; |
||
1261 | qsort (info->indextable, (size_t) i, sizeof (struct indexentry), |
||
1262 | cmpindexentry); |
||
1263 | |||
1264 | *pinfo = info; |
||
1265 | } |
||
1266 | |||
1267 | /* We are passed a section relative offset. The offsets in the |
||
1268 | stabs information are absolute. */ |
||
1269 | offset += bfd_get_section_vma (abfd, section); |
||
1270 | |||
1271 | #ifdef ENABLE_CACHING |
||
1272 | if (info->cached_indexentry != NULL |
||
1273 | && offset >= info->cached_offset |
||
1274 | && offset < (info->cached_indexentry + 1)->val) |
||
1275 | { |
||
1276 | stab = info->cached_stab; |
||
1277 | indexentry = info->cached_indexentry; |
||
1278 | file_name = info->cached_file_name; |
||
1279 | } |
||
1280 | else |
||
1281 | #endif |
||
1282 | { |
||
1283 | long low, high; |
||
1284 | long mid = -1; |
||
1285 | |||
1286 | /* Cache non-existent or invalid. Do binary search on |
||
1287 | indextable. */ |
||
1288 | indexentry = NULL; |
||
1289 | |||
1290 | low = 0; |
||
1291 | high = info->indextablesize - 1; |
||
1292 | while (low != high) |
||
1293 | { |
||
1294 | mid = (high + low) / 2; |
||
1295 | if (offset >= info->indextable[mid].val |
||
1296 | && offset < info->indextable[mid + 1].val) |
||
1297 | { |
||
1298 | indexentry = &info->indextable[mid]; |
||
1299 | break; |
||
1300 | } |
||
1301 | |||
1302 | if (info->indextable[mid].val > offset) |
||
1303 | high = mid; |
||
1304 | else |
||
1305 | low = mid + 1; |
||
1306 | } |
||
1307 | |||
1308 | if (indexentry == NULL) |
||
1309 | return TRUE; |
||
1310 | |||
1311 | stab = indexentry->stab + STABSIZE; |
||
1312 | file_name = indexentry->file_name; |
||
1313 | } |
||
1314 | |||
1315 | directory_name = indexentry->directory_name; |
||
1316 | str = indexentry->str; |
||
1317 | |||
1318 | saw_line = FALSE; |
||
1319 | saw_func = FALSE; |
||
1320 | for (; stab < (indexentry+1)->stab; stab += STABSIZE) |
||
1321 | { |
||
1322 | bfd_boolean done; |
||
1323 | bfd_vma val; |
||
1324 | |||
1325 | done = FALSE; |
||
1326 | |||
1327 | switch (stab[TYPEOFF]) |
||
1328 | { |
||
1329 | case N_SOL: |
||
1330 | /* The name of an include file. */ |
||
1331 | val = bfd_get_32 (abfd, stab + VALOFF); |
||
1332 | if (val <= offset) |
||
1333 | { |
||
1334 | file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF); |
||
6324 | serge | 1335 | if (file_name >= (char *) info->strs + strsize || file_name < (char *) str) |
1336 | file_name = NULL; |
||
5197 | serge | 1337 | *pline = 0; |
1338 | } |
||
1339 | break; |
||
1340 | |||
1341 | case N_SLINE: |
||
1342 | case N_DSLINE: |
||
1343 | case N_BSLINE: |
||
1344 | /* A line number. If the function was specified, then the value |
||
1345 | is relative to the start of the function. Otherwise, the |
||
1346 | value is an absolute address. */ |
||
1347 | val = ((indexentry->function_name ? indexentry->val : 0) |
||
1348 | + bfd_get_32 (abfd, stab + VALOFF)); |
||
1349 | /* If this line starts before our desired offset, or if it's |
||
1350 | the first line we've been able to find, use it. The |
||
1351 | !saw_line check works around a bug in GCC 2.95.3, which emits |
||
1352 | the first N_SLINE late. */ |
||
1353 | if (!saw_line || val <= offset) |
||
1354 | { |
||
1355 | *pline = bfd_get_16 (abfd, stab + DESCOFF); |
||
1356 | |||
1357 | #ifdef ENABLE_CACHING |
||
1358 | info->cached_stab = stab; |
||
1359 | info->cached_offset = val; |
||
1360 | info->cached_file_name = file_name; |
||
1361 | info->cached_indexentry = indexentry; |
||
1362 | #endif |
||
1363 | } |
||
1364 | if (val > offset) |
||
1365 | done = TRUE; |
||
1366 | saw_line = TRUE; |
||
1367 | break; |
||
1368 | |||
1369 | case N_FUN: |
||
1370 | case N_SO: |
||
1371 | if (saw_func || saw_line) |
||
1372 | done = TRUE; |
||
1373 | saw_func = TRUE; |
||
1374 | break; |
||
1375 | } |
||
1376 | |||
1377 | if (done) |
||
1378 | break; |
||
1379 | } |
||
1380 | |||
1381 | *pfound = TRUE; |
||
1382 | |||
1383 | if (file_name == NULL || IS_ABSOLUTE_PATH (file_name) |
||
1384 | || directory_name == NULL) |
||
1385 | *pfilename = file_name; |
||
1386 | else |
||
1387 | { |
||
1388 | size_t dirlen; |
||
1389 | |||
1390 | dirlen = strlen (directory_name); |
||
1391 | if (info->filename == NULL |
||
1392 | || filename_ncmp (info->filename, directory_name, dirlen) != 0 |
||
1393 | || filename_cmp (info->filename + dirlen, file_name) != 0) |
||
1394 | { |
||
1395 | size_t len; |
||
1396 | |||
1397 | /* Don't free info->filename here. objdump and other |
||
1398 | apps keep a copy of a previously returned file name |
||
1399 | pointer. */ |
||
1400 | len = strlen (file_name) + 1; |
||
1401 | info->filename = (char *) bfd_alloc (abfd, dirlen + len); |
||
1402 | if (info->filename == NULL) |
||
1403 | return FALSE; |
||
1404 | memcpy (info->filename, directory_name, dirlen); |
||
1405 | memcpy (info->filename + dirlen, file_name, len); |
||
1406 | } |
||
1407 | |||
1408 | *pfilename = info->filename; |
||
1409 | } |
||
1410 | |||
1411 | if (indexentry->function_name != NULL) |
||
1412 | { |
||
1413 | char *s; |
||
1414 | |||
1415 | /* This will typically be something like main:F(0,1), so we want |
||
1416 | to clobber the colon. It's OK to change the name, since the |
||
1417 | string is in our own local storage anyhow. */ |
||
1418 | s = strchr (indexentry->function_name, ':'); |
||
1419 | if (s != NULL) |
||
1420 | *s = '\0'; |
||
1421 | |||
1422 | *pfnname = indexentry->function_name; |
||
1423 | } |
||
1424 | |||
1425 | return TRUE; |
||
1426 | }=>>=>>>>>>>>>>>>>>>>>> |