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